SYMBOL INDEX (837 symbols across 89 files)

FILE: const_format/src/__ascii_case_conv.rs
  type Case (line 13) | pub enum Case {
  type WordCountAndLength (line 54) | struct WordCountAndLength {
  function words_count_and_length (line 61) | const fn words_count_and_length(bytes: &[u8]) -> WordCountAndLength {
  function size_after_conversion (line 72) | pub const fn size_after_conversion(case: Case, s: &str) -> usize {
  function convert_str (line 86) | pub const fn convert_str<const N: usize>(case: Case, s: &str) -> [u8; N] {
  constant CASE_DIFF (line 169) | const CASE_DIFF: u8 = b'a' - b'A';
  function uppercase_u8 (line 171) | const fn uppercase_u8(b: u8) -> u8 {
  function lowercase_u8 (line 179) | const fn lowercase_u8(b: u8) -> u8 {

FILE: const_format/src/__ascii_case_conv/word_iterator.rs
  type ByteKind (line 19) | struct ByteKind(u8);
    constant Other (line 36) | const Other: Self = Self(0b0001);
    constant Number (line 37) | const Number: Self = Self(0b0010);
    constant LowerCase (line 38) | const LowerCase: Self = Self(0b0100);
    constant UpperCase (line 39) | const UpperCase: Self = Self(0b1000);
    constant Alphabetic (line 40) | const Alphabetic: Self = Self(Self::LowerCase.0 | Self::UpperCase.0);
    constant NonAscii (line 43) | const NonAscii: Self = Self(0b1100);
    method eq (line 49) | pub const fn eq(self, other: Self) -> bool {
    method ne (line 54) | pub const fn ne(self, other: Self) -> bool {
    method is_alphabetic (line 59) | pub const fn is_alphabetic(self) -> bool {
    method is_end_of_word (line 63) | pub const fn is_end_of_word(mut self, prev: Self, other: Self) -> bool {
  method fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type WordIterator (line 77) | pub(crate) struct WordIterator<'a> {
  constant BYTE_KIND (line 82) | const BYTE_KIND: &[ByteKind; 256] = &{
  function new (line 95) | pub(crate) const fn new(bytes: &'a [u8]) -> Self {
  function skip_same_kind (line 99) | const fn skip_same_kind(mut self, mut kind: ByteKind) -> (Self, ByteKind) {
  function next (line 130) | pub(crate) const fn next(self) -> Option<(Self, Range<usize>)> {
  function get_words (line 148) | fn get_words(text: &str) -> ArrayVec<&str, 20> {
  function test_word_iter (line 161) | fn test_word_iter() {

FILE: const_format/src/__hidden_utils.rs
  function max_usize (line 1) | pub(crate) const fn max_usize(l: usize, r: usize) -> usize {
  function saturating_add (line 8) | pub(crate) const fn saturating_add(l: usize, r: usize) -> usize {
  function is_char_boundary_no_len_check (line 17) | pub(crate) const fn is_char_boundary_no_len_check(str: &[u8], index: usi...

FILE: const_format/src/__str_methods.rs
  type AsciiByte (line 24) | pub struct AsciiByte(u8);
    method new (line 28) | pub const fn new(byte: u8) -> Self {
    method get (line 37) | pub const fn get(self) -> u8 {
  function bytes_find (line 45) | const fn bytes_find(left: &[u8], right: &[u8], from: usize) -> Option<us...

FILE: const_format/src/__str_methods/pattern.rs
  type PatternCtor (line 3) | pub(crate) struct PatternCtor<T>(pub(crate) T);
  function conv (line 6) | pub(crate) const fn conv(self) -> Pattern {
  function conv (line 12) | pub(crate) const fn conv(self) -> Pattern {
  function conv (line 22) | pub(crate) const fn conv(self) -> Pattern {
  type Pattern (line 33) | pub(crate) enum Pattern {
    method normalize (line 45) | pub(crate) const fn normalize(&self) -> PatternNorm<'_> {
  type PatternNorm (line 39) | pub(crate) enum PatternNorm<'a> {

FILE: const_format/src/__str_methods/str_indexing.rs
  type StrIndexArgsConv (line 1) | pub struct StrIndexArgsConv<T> {
  function StrIndexArgsConv (line 7) | pub const fn StrIndexArgsConv<T>(str: &'static str, arg: T) -> StrIndexA...
  type StrIndexArgs (line 11) | pub struct StrIndexArgs {
  type IndexValidity (line 21) | pub enum IndexValidity {
    method is_valid (line 30) | pub const fn is_valid(self) -> bool {
    method assert_valid (line 34) | pub const fn assert_valid(self) {
  function index_validity_test (line 154) | fn index_validity_test() {

FILE: const_format/src/__str_methods/str_repeat.rs
  type StrRepeatArgs (line 1) | pub struct StrRepeatArgs {
    method assert_valid (line 30) | pub const fn assert_valid(&self) {
  function StrRepeatArgs (line 10) | pub const fn StrRepeatArgs(str: &'static str, repeat: usize) -> StrRepea...
    method assert_valid (line 30) | pub const fn assert_valid(&self) {

FILE: const_format/src/__str_methods/str_replace.rs
  type ReplaceInputConv (line 3) | pub struct ReplaceInputConv<T>(pub &'static str, pub T, pub &'static str);
  type ReplaceInput (line 23) | pub struct ReplaceInput {
    method replace_length (line 30) | pub const fn replace_length(&self) -> usize {
    method replace (line 33) | pub const fn replace<const L: usize>(&self) -> [u8; L] {
  function str_replace_length (line 38) | const fn str_replace_length(inp: &str, r: Pattern, replaced_with: &str) ...
  function str_replace (line 68) | const fn str_replace<const L: usize>(inp: &str, r: Pattern, replaced_wit...

FILE: const_format/src/__str_methods/str_splice.rs
  type StrSplceArgsConv (line 3) | pub struct StrSplceArgsConv<T> {
  function StrSplceArgsConv (line 10) | pub const fn StrSplceArgsConv<T>(
  type StrSpliceArgs (line 18) | pub struct StrSpliceArgs {
  type SplicedStr (line 31) | pub struct SplicedStr {
  type DecomposedString (line 39) | pub struct DecomposedString<P, M, S> {

FILE: const_format/src/__str_methods/str_split.rs
  type SplitInputConv (line 5) | pub struct SplitInputConv<T>(pub &'static str, pub T);
  type SplitInput (line 27) | pub struct SplitInput {
    method compute_length (line 34) | const fn compute_length(mut self) -> Self {
    method split_it (line 39) | pub const fn split_it<const LEN: usize>(self) -> [&'static str; LEN] {
    method length (line 43) | pub const fn length(&self) -> usize {
  function count_splits (line 48) | pub const fn count_splits(SplitInput { str, pattern, .. }: SplitInput) -...
  function find_u8 (line 85) | const fn find_u8(mut slice: &[u8], byte: u8) -> Option<usize> {
  function find_next_char_boundary (line 98) | const fn find_next_char_boundary(str: &str, mut index: usize) -> Option<...
  function split_it (line 111) | pub const fn split_it<const LEN: usize>(args: SplitInput) -> [&'static s...

FILE: const_format/src/char_encoding.rs
  function char_display_len (line 4) | pub(crate) const fn char_display_len(c: char) -> usize {
  function char_debug_len (line 14) | pub(crate) const fn char_debug_len(c: char) -> usize {
  function char_to_utf8 (line 23) | const fn char_to_utf8(char: char) -> ([u8; 4], usize) {
  function char_to_display (line 48) | pub(crate) const fn char_to_display(char: char) -> FmtChar {
  function char_to_debug (line 56) | pub(crate) const fn char_to_debug(c: char) -> FmtChar {
  type FmtChar (line 89) | pub struct FmtChar {
    method encoded (line 97) | pub const fn encoded(&self) -> &[u8; 6] {
    method len (line 101) | pub const fn len(&self) -> usize {
    method as_bytes (line 105) | pub(crate) const fn as_bytes(&self) -> &[u8] {

FILE: const_format/src/char_encoding/tests.rs
  function char_to_utf8_encoding_test (line 4) | fn char_to_utf8_encoding_test() {
  function char_to_utf8_display_test (line 17) | fn char_to_utf8_display_test() {
  function char_to_utf8_debug_test (line 30) | fn char_to_utf8_debug_test() {

FILE: const_format/src/const_generic_concatcp.rs
  function __priv_concatenate (line 6) | pub const fn __priv_concatenate<const LEN: usize>(input: &[PArgument]) -...

FILE: const_format/src/doctests.rs
  type ImplFmtWhereClause (line 45) | pub struct ImplFmtWhereClause;
  type ConstDebugWhereClause (line 67) | pub struct ConstDebugWhereClause;
  type AsStr_For_StrWriterMut_NoEncoding (line 100) | pub struct AsStr_For_StrWriterMut_NoEncoding;
  type Assert (line 153) | pub struct Assert;
  type AssertCmp (line 184) | pub struct AssertCmp;
  type AssertCP (line 195) | pub struct AssertCP;
  type AssertCPCmp (line 218) | pub struct AssertCPCmp;

FILE: const_format/src/fmt/error.rs
  type Error (line 9) | pub enum Error {
    method unwrap (line 48) | pub const fn unwrap<T>(&self) -> T {
  method fmt (line 20) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  type Result (line 70) | pub type Result<T = (), E = Error> = core::result::Result<T, E>;
  type ToResult (line 77) | pub struct ToResult<T>(pub T);
  function to_result (line 82) | pub const fn to_result(self) -> Result {
  function to_result (line 90) | pub const fn to_result(self) -> Result {

FILE: const_format/src/fmt/formatter.rs
  type ComputeStrLength (line 49) | pub struct ComputeStrLength {
    method new (line 55) | pub const fn new() -> Self {
    method make_formatter (line 61) | pub const fn make_formatter(&mut self, flags: FormattingFlags) -> Form...
    method add_len (line 70) | pub const fn add_len(&mut self, len: usize) {
    method len (line 75) | pub const fn len(&self) -> usize {
    method is_empty (line 80) | pub const fn is_empty(&self) -> bool {
    method borrow_mutably (line 86) | pub const fn borrow_mutably(&mut self) -> &mut Self {
  type WriterBackend (line 93) | enum WriterBackend<'w> {
  type Formatter (line 222) | pub struct Formatter<'w> {
  constant MARGIN_STEP (line 228) | const MARGIN_STEP: u16 = 4;
  function from_sw (line 256) | pub const fn from_sw(writer: &'w mut StrWriter, flags: FormattingFlags) ...
  function from_sw_mut (line 295) | pub const fn from_sw_mut<E: 'static>(
  function from_custom (line 352) | pub const fn from_custom(
  function from_custom_cleared (line 372) | pub const fn from_custom_cleared(
  function flags (line 387) | pub const fn flags(&self) -> FormattingFlags {
  function margin (line 392) | pub const fn margin(&self) -> usize {
  function increment_margin (line 397) | const fn increment_margin(&mut self) -> &mut Self {
  function decrement_margin (line 403) | const fn decrement_margin(&mut self) {
  function borrow_mutably (line 411) | pub const fn borrow_mutably(&mut self) -> &mut Self {
  function make_formatter (line 475) | pub const fn make_formatter(&mut self, flags: FormattingFlags) -> Format...
  function debug_struct (line 496) | pub const fn debug_struct(&mut self, name: &str) -> DebugStruct<'_, 'w> {
  function debug_tuple (line 514) | pub const fn debug_tuple(&mut self, name: &str) -> DebugTuple<'_, 'w> {
  function debug_list (line 532) | pub const fn debug_list(&mut self) -> DebugList<'_, 'w> {
  function debug_set (line 549) | pub const fn debug_set(&mut self) -> DebugSet<'_, 'w> {
  constant COLON_SPACE_LEN (line 568) | const COLON_SPACE_LEN: usize = ": ".len();
  constant COMMA_SPACE_LEN (line 569) | const COMMA_SPACE_LEN: usize = ", ".len();
  constant COMMA_NL_LEN (line 570) | const COMMA_NL_LEN: usize = ",\n".len();
  type DebugStruct (line 726) | pub struct DebugStruct<'f, 'w> {
  function field (line 734) | pub const fn field(&mut self, name: &str) -> &mut Formatter<'w> {
  function finish (line 749) | pub const fn finish(self) -> Result<(), Error> {
  type DebugTuple (line 816) | pub struct DebugTuple<'f, 'w> {
  function field (line 824) | pub const fn field(&mut self) -> &mut Formatter<'w> {
  function finish (line 830) | pub const fn finish(self) -> Result<(), Error> {
  type DebugList (line 918) | pub struct DebugList<'f, 'w> {
  function entry (line 926) | pub const fn entry(&mut self) -> &mut Formatter<'w> {
  function finish (line 932) | pub const fn finish(self) -> Result<(), Error> {
  type DebugSet (line 976) | pub struct DebugSet<'f, 'w> {
  function entry (line 984) | pub const fn entry(&mut self) -> &mut Formatter<'w> {
  function finish (line 990) | pub const fn finish(self) -> Result<(), Error> {
  function calculate_display_len (line 1486) | const fn calculate_display_len(b: &[u8], range: &Range<usize>) -> usize {
  function calculate_display_len_debug_range (line 1492) | const fn calculate_display_len_debug_range(b: &[u8], range: &Range<usize...

FILE: const_format/src/fmt/std_type_impls.rs
  function const_display_fmt (line 14) | pub const fn const_display_fmt(&self, f: &mut Formatter<'_>) -> Result<(...
  function const_debug_fmt (line 18) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  function const_display_fmt (line 24) | pub const fn const_display_fmt(&self, f: &mut Formatter<'_>) -> Result<(...
  function const_debug_fmt (line 29) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  function const_display_fmt (line 35) | pub const fn const_display_fmt(&self, f: &mut Formatter<'_>) -> Result<(...
  function const_debug_fmt (line 40) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  constant PTR (line 156) | const PTR: &'static str = "<pointer>";
  function const_debug_fmt (line 159) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  function const_debug_fmt (line 167) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  function const_debug_fmt (line 175) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...

FILE: const_format/src/fmt/std_type_impls/ranges.rs
  type Kind (line 12) | type Kind = IsStdKind;
  type This (line 13) | type This = Self;
  function coerce (line 18) | pub const fn coerce(self, range: &Range<usize>) -> PWrapper<Range<usize>> {
  constant RANGE (line 27) | const RANGE: &'static str = "..";
  function const_debug_fmt (line 30) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  type Kind (line 41) | type Kind = IsStdKind;
  type This (line 42) | type This = Self;
  function coerce (line 47) | pub const fn coerce(self, range: &RangeFrom<usize>) -> PWrapper<RangeFro...
  constant RANGE (line 53) | const RANGE: &'static str = "..";
  function const_debug_fmt (line 56) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  type Kind (line 66) | type Kind = IsStdKind;
  type This (line 67) | type This = Self;
  function coerce (line 72) | pub const fn coerce(self, range: &RangeTo<usize>) -> PWrapper<RangeTo<us...
  constant RANGE (line 78) | const RANGE: &'static str = "..";
  function const_debug_fmt (line 81) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  type Kind (line 91) | type Kind = IsStdKind;
  type This (line 92) | type This = Self;
  function coerce (line 97) | pub const fn coerce(
  constant RANGE (line 106) | const RANGE: &'static str = "..=";
  function const_debug_fmt (line 109) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  type Kind (line 119) | type Kind = IsStdKind;
  type This (line 120) | type This = Self;
  function coerce (line 125) | pub const fn coerce(self, range: &RangeInclusive<usize>) -> PWrapper<Ran...
  constant RANGE (line 131) | const RANGE: &'static str = "..=";
  function const_debug_fmt (line 134) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...
  type Kind (line 145) | type Kind = IsStdKind;
  type This (line 146) | type This = Self;
  function coerce (line 151) | pub const fn coerce(self, _: &RangeFull) -> PWrapper<RangeFull> {
  constant RANGE (line 157) | const RANGE: &'static str = "..";
  function const_debug_fmt (line 160) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(),...

FILE: const_format/src/fmt/str_writer.rs
  type StrWriter (line 108) | pub struct StrWriter<A: ?Sized = [u8]> {
    method capacity (line 215) | pub const fn capacity(&self) -> usize {
    method remaining_capacity (line 240) | pub const fn remaining_capacity(&self) -> usize {
    method truncate (line 273) | pub const fn truncate(&mut self, length: usize) -> Result<(), Error> {
    method clear (line 299) | pub const fn clear(&mut self) {
    method as_bytes_alt (line 308) | pub const fn as_bytes_alt(&self) -> &[u8] {
    method as_str_alt (line 317) | pub const fn as_str_alt(&self) -> &str {
    method as_str (line 349) | pub const fn as_str(&self) -> &str {
    method as_bytes (line 372) | pub const fn as_bytes(&self) -> &[u8] {
    method as_mut (line 390) | pub const fn as_mut(&mut self) -> StrWriterMut<'_> {
    method make_formatter (line 435) | pub const fn make_formatter(&mut self, flags: FormattingFlags) -> Form...
  function new (line 115) | pub const fn new(array: A) -> Self {
  function buffer (line 143) | pub const fn buffer(&self) -> &A {
  function len (line 166) | pub const fn len(&self) -> usize {
  function is_empty (line 186) | pub const fn is_empty(&self) -> bool {
  function r (line 466) | pub const fn r(&self) -> &StrWriter<[u8]> {
  function unsize (line 487) | pub const fn unsize(&self) -> &StrWriter<[u8]> {
  function as_mut (line 506) | pub const fn as_mut(&mut self) -> StrWriterMut<'_> {
  function borrow_mutably (line 518) | pub const fn borrow_mutably(&mut self) -> &mut Self {

FILE: const_format/src/fmt/str_writer_mut.rs
  type StrWriterMut (line 80) | pub struct StrWriterMut<'w, E = Utf8Encoding> {
  type Utf8Encoding (line 97) | pub enum Utf8Encoding {}
  type NoEncoding (line 103) | pub enum NoEncoding {}
  function new (line 123) | pub const fn new(writer: &'w mut StrWriter) -> Self {
  function from_custom (line 155) | pub const fn from_custom(buffer: &'w mut [u8], length: &'w mut usize) ->...
  function from_custom_cleared (line 195) | pub const fn from_custom_cleared(buffer: &'w mut [u8], length: &'w mut u...
  function buffer (line 227) | pub const fn buffer(&self) -> &[u8] {
  function len (line 252) | pub const fn len(&self) -> usize {
  function is_empty (line 274) | pub const fn is_empty(&self) -> bool {
  function capacity (line 299) | pub const fn capacity(&self) -> usize {
  function remaining_capacity (line 326) | pub const fn remaining_capacity(&self) -> usize {
  function truncate (line 362) | pub const fn truncate(&mut self, length: usize) -> Result<(), Error> {
  function truncate (line 403) | pub const fn truncate(&mut self, length: usize) {
  function clear (line 434) | pub const fn clear(&mut self) {
  function as_bytes_alt (line 443) | pub const fn as_bytes_alt(&self) -> &[u8] {
  function as_str_alt (line 454) | pub const fn as_str_alt(&self) -> &str {
  function as_str (line 477) | pub const fn as_str(&self) -> &str {
  function as_bytes (line 504) | pub const fn as_bytes(&self) -> &[u8] {
  function make_formatter (line 548) | pub const fn make_formatter(&mut self, flags: FormattingFlags) -> Format...
  function borrow_mutably (line 561) | pub const fn borrow_mutably(&mut self) -> &mut StrWriterMut<'w, E> {
  function reborrow (line 599) | pub const fn reborrow(&mut self) -> StrWriterMut<'_, E> {
  function into_byte_encoding (line 608) | pub(crate) const unsafe fn into_byte_encoding(self) -> StrWriterMut<'w, ...
  function is_valid_str_range (line 810) | const fn is_valid_str_range(s: &[u8], Range { start, end }: Range<usize>...
  function is_valid_str_index (line 819) | const fn is_valid_str_index(s: &[u8], index: usize) -> bool {
  function write_str_range (line 853) | pub const fn write_str_range(&mut self, s: &str, range: Range<usize>) ->...
  function write_str (line 882) | pub const fn write_str(&mut self, s: &str) -> Result<(), Error> {
  function write_char (line 908) | pub const fn write_char(&mut self, character: char) -> Result<(), Error> {
  function write_ascii_range (line 935) | pub const fn write_ascii_range(
  function write_ascii (line 964) | pub const fn write_ascii(&mut self, ascii: AsciiStr<'_>) -> Result<(), E...
  function write_ascii_repeated (line 988) | pub const fn write_ascii_repeated(
  function write_str_inner (line 1013) | const fn write_str_inner(
  function write_str_range_debug (line 1067) | pub const fn write_str_range_debug(
  function write_str_debug (line 1100) | pub const fn write_str_debug(&mut self, str: &str) -> Result<(), Error> {
  function write_char_debug (line 1131) | pub const fn write_char_debug(&mut self, character: char) -> Result<(), ...
  function write_ascii_range_debug (line 1158) | pub const fn write_ascii_range_debug(
  function write_ascii_debug (line 1187) | pub const fn write_ascii_debug(&mut self, ascii: AsciiStr<'_>) -> Result...
  function write_str_debug_inner (line 1193) | const fn write_str_debug_inner(

FILE: const_format/src/for_assert_macros.rs
  function assert_ (line 6) | pub const fn assert_(cond: bool, message: &'static str) {
  type ConcatArgsIf (line 14) | pub trait ConcatArgsIf<T, const COND: bool> {
    constant PARGUMENTS (line 15) | const PARGUMENTS: &'static [PArgument];
  constant PARGUMENTS (line 19) | const PARGUMENTS: &'static [PArgument] = &[];

FILE: const_format/src/for_examples.rs
  type Point3 (line 11) | pub struct Point3 {
  type Unit (line 42) | pub struct Unit;

FILE: const_format/src/formatting.rs
  type Formatting (line 3) | pub enum Formatting {
    method is_display (line 11) | pub const fn is_display(self) -> bool {
  type NumberFormatting (line 23) | pub enum NumberFormatting {
    constant ALL (line 47) | pub(crate) const ALL: &'static [Self; 3] = &[
  type HexFormatting (line 35) | pub enum HexFormatting {
  type FormattingFlags (line 101) | pub struct FormattingFlags {
    constant __REG (line 113) | pub const __REG: Self = Self::NEW.set_alternate(false).set_decimal();
    constant __HEX (line 114) | pub const __HEX: Self = Self::NEW.set_alternate(false).set_hexadecimal();
    constant __LOWHEX (line 115) | pub const __LOWHEX: Self = Self::NEW.set_alternate(false).set_lower_he...
    constant __BIN (line 116) | pub const __BIN: Self = Self::NEW.set_alternate(false).set_binary();
    constant __A_REG (line 118) | pub const __A_REG: Self = Self::NEW.set_alternate(true).set_decimal();
    constant __A_HEX (line 119) | pub const __A_HEX: Self = Self::NEW.set_alternate(true).set_hexadecima...
    constant __A_LOWHEX (line 120) | pub const __A_LOWHEX: Self = Self::NEW.set_alternate(true).set_lower_h...
    constant __A_BIN (line 121) | pub const __A_BIN: Self = Self::NEW.set_alternate(true).set_binary();
    constant DEFAULT (line 125) | pub const DEFAULT: Self = Self {
    constant NEW (line 137) | pub const NEW: Self = Self {
    method new (line 150) | pub const fn new() -> Self {
    method set_num_fmt (line 158) | pub const fn set_num_fmt(mut self, num_fmt: NumberFormatting) -> Self {
    method set_decimal (line 167) | pub const fn set_decimal(mut self) -> Self {
    method set_hexadecimal (line 176) | pub const fn set_hexadecimal(mut self) -> Self {
    method set_lower_hexadecimal (line 187) | pub const fn set_lower_hexadecimal(mut self) -> Self {
    method set_binary (line 197) | pub const fn set_binary(mut self) -> Self {
    method set_alternate (line 204) | pub const fn set_alternate(mut self, is_alternate: bool) -> Self {
    method num_fmt (line 211) | pub const fn num_fmt(self) -> NumberFormatting {
    method is_alternate (line 217) | pub const fn is_alternate(self) -> bool {
    method hex_fmt (line 221) | pub(crate) const fn hex_fmt(self) -> HexFormatting {
  type LenAndArray (line 230) | pub struct LenAndArray<T: ?Sized> {
  type StartAndArray (line 238) | pub struct StartAndArray<T: ?Sized> {
  type ForEscaping (line 247) | pub struct ForEscaping {
    method get_backslash_escape (line 256) | pub const fn get_backslash_escape(b: u8) -> u8 {
  function hex_as_ascii (line 264) | pub const fn hex_as_ascii(n: u8, hex_fmt: HexFormatting) -> u8 {
  constant FOR_ESCAPING (line 275) | pub const FOR_ESCAPING: &ForEscaping = {

FILE: const_format/src/lib.rs
  type __AssertStr (line 483) | pub struct __AssertStr {
  type __AssertType (line 489) | pub struct __AssertType<T> {

FILE: const_format/src/marker_traits/format_marker.rs
  type FormatMarker (line 98) | pub trait FormatMarker {
    type Kind (line 261) | type Kind = IsStdKind;
    type This (line 262) | type This = Self;
    type Kind (line 274) | type Kind = IsArrayKind<T>;
    type This (line 275) | type This = Self;
    type Kind (line 279) | type Kind = IsArrayKind<T>;
    type This (line 280) | type This = [T];
    type Kind (line 287) | type Kind = T::Kind;
    type This (line 288) | type This = T::This;
    type Kind (line 295) | type Kind = T::Kind;
    type This (line 296) | type This = T::This;
  type IsArrayKind (line 122) | pub struct IsArrayKind<T>(PhantomData<T>);
  type IsStdKind (line 129) | pub struct IsStdKind;
  type IsNotStdKind (line 136) | pub struct IsNotStdKind;
  type IsAFormatMarker (line 187) | pub struct IsAFormatMarker<K, T: ?Sized, R: ?Sized>(
  method clone (line 198) | fn clone(&self) -> Self {
  constant NEW (line 208) | pub const NEW: Self = Self(PhantomData);
  function infer_type (line 219) | pub const fn infer_type(self, _: &R) -> Self {
  function unreference (line 225) | pub const fn unreference(self, r: &T) -> &T {
  function coerce (line 235) | pub const fn coerce(self, slice: &[U]) -> PWrapper<&[U]> {
  function coerce (line 243) | pub const fn coerce(self, reference: &T) -> &T {
  function coerce (line 268) | pub const fn coerce(self, reference: &str) -> PWrapper<&str> {

FILE: const_format/src/marker_traits/write_marker.rs
  type WriteMarker (line 88) | pub trait WriteMarker {
    type Kind (line 118) | type Kind = IsAStrWriter;
    type This (line 119) | type This = Self;
    type Kind (line 123) | type Kind = IsNotAStrWriter;
    type This (line 124) | type This = Self;
    type Kind (line 128) | type Kind = IsNotAStrWriter;
    type This (line 129) | type This = Self;
    type Kind (line 136) | type Kind = T::Kind;
    type This (line 137) | type This = T::This;
    type Kind (line 144) | type Kind = T::Kind;
    type This (line 145) | type This = T::This;
  type IsAStrWriter (line 106) | pub struct IsAStrWriter;
  type IsNotAStrWriter (line 113) | pub struct IsNotAStrWriter;
  type IsAWriteMarker (line 186) | pub struct IsAWriteMarker<K, T: ?Sized, R: ?Sized>(
  method clone (line 197) | fn clone(&self) -> Self {
  constant NEW (line 207) | pub const NEW: Self = Self(PhantomData);
  function infer_type (line 215) | pub const fn infer_type(self, _: &R) -> Self {
  function coerce (line 225) | pub const fn coerce(self, mutref: &mut StrWriter) -> StrWriterMut<'_> {
  function coerce (line 233) | pub const fn coerce(self, mutref: &mut T) -> &mut T {

FILE: const_format/src/msg.rs
  type ErrorTupleAndStrWriter (line 67) | pub struct ErrorTupleAndStrWriter<A> {
  type ErrorPicker (line 72) | pub struct ErrorPicker<E, Cap>(PhantomData<fn() -> (E, Cap)>);
  type ErrorTuple (line 74) | pub struct ErrorTuple {
  type ErrorAsType (line 79) | pub trait ErrorAsType {

FILE: const_format/src/pargument.rs
  type PArgument (line 11) | pub struct PArgument {
    method calc_len (line 20) | pub const fn calc_len(mut args: &[PArgument]) -> usize {
  type PVariant (line 33) | pub enum PVariant {
  type Integer (line 40) | pub struct Integer {
  type PConvWrapper (line 47) | pub struct PConvWrapper<T>(pub T);
  function to_pargument_display (line 130) | pub const fn to_pargument_display(self, _: FormattingFlags) -> PArgument {
  function to_pargument_debug (line 134) | pub const fn to_pargument_debug(self, _: FormattingFlags) -> PArgument {
  function to_pargument_display (line 142) | pub const fn to_pargument_display(self, _: FormattingFlags) -> PArgument {
  function to_pargument_debug (line 147) | pub const fn to_pargument_debug(self, fmt_flags: FormattingFlags) -> PAr...
  function to_pargument_display (line 155) | pub const fn to_pargument_display(self, fmt_flags: FormattingFlags) -> P...
  function to_pargument_debug (line 165) | pub const fn to_pargument_debug(self, fmt_flags: FormattingFlags) -> PAr...
  function to_pargument_display (line 179) | pub const fn to_pargument_display(self, fmt_flags: FormattingFlags) -> P...
  function to_pargument_debug (line 188) | pub const fn to_pargument_debug(self, fmt_flags: FormattingFlags) -> PAr...

FILE: const_format/src/slice_cmp.rs
  function str_eq (line 36) | pub const fn str_eq(left: &str, right: &str) -> bool {
  function u8_slice_eq (line 75) | pub const fn u8_slice_eq(left: &[u8], right: &[u8]) -> bool {
  function slice_eq_test (line 96) | fn slice_eq_test() {
  function str_eq_test (line 110) | fn str_eq_test() {

FILE: const_format/src/test_utils.rs
  constant ALL_ASCII (line 58) | pub const ALL_ASCII: &str = "\
  constant ALL_ASCII_ESCAPED (line 65) | pub const ALL_ASCII_ESCAPED: &str = "\

FILE: const_format/src/utils.rs
  type Constructor (line 6) | pub(crate) struct Constructor<T>(#[allow(dead_code)] fn() -> T);
  function saturate_range (line 12) | pub const fn saturate_range(s: &[u8], range: &Range<usize>) -> Range<usi...
  function slice_up_to_len_alt (line 32) | pub const fn slice_up_to_len_alt<T>(slice: &[T], len: usize) -> &[T] {
  function slice_up_to_len (line 59) | pub const fn slice_up_to_len<T>(slice: &[T], len: usize) -> &[T] {
  function min_usize (line 69) | pub(crate) const fn min_usize(l: usize, r: usize) -> usize {
  function test_slice_up_to_len_alt (line 82) | fn test_slice_up_to_len_alt() {
  function slice_in_bounds (line 93) | fn slice_in_bounds() {

FILE: const_format/src/wrapper_types/ascii_str.rs
  type AsciiStr (line 41) | pub struct AsciiStr<'a>(&'a [u8]);
  function from_str (line 60) | pub const fn from_str(s: &'a str) -> Result<Self, NotAsciiError> {
  function new (line 79) | pub const fn new(s: &'a [u8]) -> Result<Self, NotAsciiError> {
  function empty (line 97) | pub const fn empty() -> Self {
  function len (line 112) | pub const fn len(self) -> usize {
  function is_empty (line 127) | pub const fn is_empty(self) -> bool {
  function as_bytes (line 142) | pub const fn as_bytes(self) -> &'a [u8] {
  function as_str (line 157) | pub const fn as_str(self) -> &'a str {
  type NotAsciiError (line 168) | pub struct NotAsciiError {
  method fmt (line 174) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
  function basic (line 208) | fn basic() {
  function only_ascii_constructible (line 227) | fn only_ascii_constructible() {
  function formatting (line 250) | fn formatting() {

FILE: const_format/src/wrapper_types/pwrapper.rs
  type PWrapper (line 79) | pub struct PWrapper<T>(pub T);
  function slice (line 86) | pub const fn slice(x: &'a [T]) -> Self {
  type UWord (line 223) | type UWord = u16;
  type UWord (line 225) | type UWord = u32;
  type UWord (line 227) | type UWord = u64;
  type UWord (line 229) | type UWord = u128;
  type IWord (line 232) | type IWord = i16;
  type IWord (line 234) | type IWord = i32;
  type IWord (line 236) | type IWord = i64;
  type IWord (line 238) | type IWord = i128;
  function unsigned_abs (line 277) | pub const fn unsigned_abs(self) -> usize {
  function unsigned_abs (line 284) | pub const fn unsigned_abs(self) -> usize {
  method as_negative (line 291) | const fn as_negative(self) -> i128 {
  function to_start_array_binary (line 298) | pub const fn to_start_array_binary(self, flags: FormattingFlags) -> Star...
  function to_start_array_hexadecimal (line 332) | pub const fn to_start_array_hexadecimal(
  function to_start_array_display (line 372) | pub const fn to_start_array_display(self) -> StartAndArray<[u8; 40]> {
  function to_start_array_debug (line 399) | pub const fn to_start_array_debug(self) -> StartAndArray<[u8; 40]> {
  function compute_utf8_debug_len (line 407) | pub const fn compute_utf8_debug_len(self) -> usize {
  function compute_utf8_debug_len_in_range (line 413) | pub const fn compute_utf8_debug_len_in_range(self, mut range: Range<usiz...
  function compute_debug_len (line 437) | pub const fn compute_debug_len(self, _: FormattingFlags) -> usize {
  function compute_display_len (line 444) | pub const fn compute_display_len(self, _: FormattingFlags) -> usize {
  constant _ (line 450) | const _: () = {

FILE: const_format/src/wrapper_types/pwrapper/tests.rs
  function get_digits_display (line 11) | fn get_digits_display(n: impl fmt::Display) -> ArrayString<64> {
  function get_hex_digits (line 16) | fn get_hex_digits(n: impl fmt::UpperHex) -> ArrayString<64> {
  function get_lower_hex_digits (line 21) | fn get_lower_hex_digits(n: impl fmt::LowerHex) -> ArrayString<64> {
  function get_binary_digits (line 26) | fn get_binary_digits(n: impl fmt::Binary) -> ArrayString<192> {
  constant DEF_FLAGS (line 32) | const DEF_FLAGS: FormattingFlags = FormattingFlags::DEFAULT;
  function pwrapper_methods (line 148) | fn pwrapper_methods() {
  function wrapped_formatting (line 165) | fn wrapped_formatting() {

FILE: const_format/src/wrapper_types/sliced.rs
  type Sliced (line 30) | pub struct Sliced<T, R>(pub T, pub R);
  function range (line 76) | const fn range(&self) -> Range<usize> {
  function range (line 83) | const fn range(&self) -> Range<usize> {
  function range (line 90) | const fn range(&self) -> Range<usize> {
  constant UM (line 95) | const UM: usize = usize::MAX >> 1;
  function range (line 101) | const fn range(&self) -> Range<usize> {
  function range (line 108) | const fn range(&self) -> Range<usize> {
  function range (line 117) | const fn range(&self) -> Range<usize> {
  constant S (line 151) | const S: &str = "\x00\n\t3456789\x06\x07";
  function str_tests (line 204) | fn str_tests() {
  function asciistr_tests (line 208) | fn asciistr_tests() {

FILE: const_format/tests/fmt_tests/display_formatting.rs
  type DisplayFoo (line 8) | struct DisplayFoo {
    method const_display_fmt (line 16) | pub const fn const_display_fmt(&self, f: &mut Formatter<'_>) -> Result...
  function inner (line 28) | const fn inner(
  function test_display_foo (line 42) | fn test_display_foo() {
  function display_fmt_other_types (line 152) | fn display_fmt_other_types() {

FILE: const_format/tests/fmt_tests/formatted_writing.rs
  type Foo (line 9) | struct Foo {
    method const_debug_fmt (line 16) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(...
  type Bar (line 26) | struct Bar {
    method const_debug_fmt (line 34) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(...
  function check_debug_formatting (line 45) | fn check_debug_formatting() {
  type Set (line 208) | pub struct Set(&'static [Foo]);
    method const_debug_fmt (line 211) | pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(...
  function check_set_formatting (line 221) | fn check_set_formatting() {

FILE: const_format/tests/fmt_tests/formatter_methods.rs
  function write_with_flag (line 20) | fn write_with_flag(flags: FormattingFlags, expected: &str, takes_fmt: &d...
  function write_integers (line 45) | fn write_integers() {
  function write_str_methods (line 119) | fn write_str_methods() {
  function remove_margin (line 148) | fn remove_margin(s: &str) -> String {

FILE: const_format/tests/fmt_tests/formatter_methods/debug_methods.rs
  function format_b_field (line 10) | const fn format_b_field(b: &'static [u32], fmt: &mut Formatter<'_>) -> R...
  type BracedStruct (line 21) | struct BracedStruct {
  function formatting_struct (line 47) | fn formatting_struct() {
  type TupleStruct (line 99) | struct TupleStruct {
  function formatting_tuple (line 125) | fn formatting_tuple() {
  type List (line 177) | struct List {
  function formatting_list (line 203) | fn formatting_list() {
  type Set (line 255) | struct Set {
  function formatting_set (line 281) | fn formatting_set() {

FILE: const_format/tests/fmt_tests/std_impl_tests.rs
  constant FLAGS (line 17) | const FLAGS: &[FormattingFlags] = &[
  function array_impls (line 59) | fn array_impls() {
  function range_impls (line 87) | fn range_impls() {
  function options (line 97) | fn options() {
  function pointers (line 127) | fn pointers() {
  function marker (line 134) | fn marker() {
  function miscelaneous_enums (line 141) | fn miscelaneous_enums() {
  function chars (line 156) | fn chars() {

FILE: const_format/tests/fmt_tests/str_writer_methods.rs
  type Formatting (line 18) | enum Formatting {
  function test_write_ints (line 114) | fn test_write_ints() {
  function basic (line 132) | fn basic() {
  function saturate_range_tests (line 140) | fn saturate_range_tests() {
  type WriteArgs (line 157) | struct WriteArgs<'sw, 's> {
  function test_unescaped_str_fn (line 164) | fn test_unescaped_str_fn(
  function write_str (line 246) | fn write_str() {
  function write_ascii (line 264) | fn write_ascii() {
  function is_it_escaped (line 277) | fn is_it_escaped(c: char) -> bool {
  function write_str_debug (line 282) | fn write_str_debug() {
  function returns_error (line 384) | fn returns_error() {
  function remaining_capacity_test (line 423) | fn remaining_capacity_test() {
  function truncation (line 443) | fn truncation() {
  function as_bytes (line 516) | fn as_bytes() {
  function clear (line 532) | fn clear() {
  function write_ascii_debug (line 556) | fn write_ascii_debug() {

FILE: const_format/tests/fmt_tests/str_writer_mut.rs
  function from_custom (line 4) | fn from_custom() -> Result<(), Error> {
  function from_custom_cleared (line 38) | fn from_custom_cleared() -> Result<(), Error> {
  function truncate_no_encoding (line 78) | fn truncate_no_encoding() -> Result<(), Error> {
  function clear_test (line 125) | fn clear_test() {
  function as_bytes (line 153) | fn as_bytes() {

FILE: const_format/tests/fmt_tests_modules.rs
  constant NOT_CF (line 8) | pub const NOT_CF: usize = 13;
  constant _ASSERT_NOT_CF (line 9) | pub const _ASSERT_NOT_CF: [(); 13] = [(); const_format::NOT_CF];

FILE: const_format/tests/misc_tests/assertc_tests.rs
  type Foo (line 7) | struct Foo;
  function assertc_emits_formatting (line 48) | fn assertc_emits_formatting() {
  constant _ (line 62) | const _: () = {

FILE: const_format/tests/misc_tests/assertcp_tests.rs
  type Foo (line 6) | struct Foo;
  function assertcp_emits_formatting (line 33) | fn assertcp_emits_formatting() {
  constant X (line 49) | const X: u8 = 123;
  constant _ (line 52) | const _: () = {

FILE: const_format/tests/misc_tests/call_debug_fmt_macro.rs
  function all_macro_branches (line 7) | fn all_macro_branches() {
  function returns_error (line 51) | fn returns_error() {
  type Hello (line 64) | struct Hello<T>(T);
  type TupleStruct (line 66) | struct TupleStruct(u32);

FILE: const_format/tests/misc_tests/clippy_warnings.rs
  function test_clippy_double_parens_not_triggered (line 3) | fn test_clippy_double_parens_not_triggered() {

FILE: const_format/tests/misc_tests/concatc_macro_tests.rs
  constant STD_TYPES (line 6) | const STD_TYPES: &str = concatc!(
  constant USER_TYPES (line 17) | const USER_TYPES: &str = concatc!(Twice("hello "), ascii_str!("world!"));
  function concatc_test (line 20) | fn concatc_test() {
  type Twice (line 25) | struct Twice(&'static str);

FILE: const_format/tests/misc_tests/derive_tests.rs
  type Dummy (line 12) | struct Dummy;
  type Braced (line 16) | struct Braced {
  type Tupled (line 32) | struct Tupled<T, U>(
  type Unit (line 43) | struct Unit;
  function struct_formatting (line 46) | fn struct_formatting() {
  type Enum (line 100) | enum Enum {
  function enum_formatting (line 121) | fn enum_formatting() {

FILE: const_format/tests/misc_tests/derive_tests/is_a_attributes.rs
  type Bar (line 11) | pub struct Bar(pub u32);
  function fmt_bar_in_hex (line 23) | const fn fmt_bar_in_hex(this: &Bar, f: &mut Formatter<'_>) -> Result<(),...
  type DisplayWrapper (line 30) | pub struct DisplayWrapper<'a, T>(pub &'a T);
  type NotDebug (line 53) | pub struct NotDebug;
  type Option (line 55) | pub struct Option<T>(pub PhantomData<T>);
  type WrapsNamedOption (line 68) | pub(super) struct WrapsNamedOption {
  type Automatic (line 104) | struct Automatic {
  type BarSlice (line 116) | type BarSlice = [Bar];
  type BarArray (line 117) | type BarArray = [Bar; 2];
  type BarOption (line 118) | type BarOption = Option<Bar>;
  type Manual (line 122) | struct Manual {
  function automatic_type_detection (line 159) | fn automatic_type_detection() {
  function manual_type_detection (line 201) | fn manual_type_detection() {
  function opting_out_of_std (line 247) | fn opting_out_of_std() {

FILE: const_format/tests/misc_tests/equality_tests.rs
  function compare_arrays (line 20) | fn compare_arrays() {
  function compare_options (line 67) | fn compare_options() {
  function enums (line 96) | fn enums() {
  function char_cases (line 108) | fn char_cases() {
  function ranges (line 113) | fn ranges() {

FILE: const_format/tests/misc_tests/formatc_macros.rs
  function concat_fmt_strings (line 23) | fn concat_fmt_strings() {
  function positional_and_named_arguments (line 52) | fn positional_and_named_arguments() {
  function debug_formatting (line 75) | fn debug_formatting() {
  function binary_and_hex_formatting (line 255) | fn binary_and_hex_formatting() {
  function other_tests (line 270) | fn other_tests() {
  function escaped_format_string (line 278) | fn escaped_format_string() {
  function raw_literals (line 297) | fn raw_literals() {
  function access_formatter (line 311) | fn access_formatter() {

FILE: const_format/tests/misc_tests/impl_fmt_macro_tests.rs
  type Delegating (line 16) | struct Delegating<T>(T);
  type BracedStruct (line 20) | struct BracedStruct<T: 'static> {
  type TupleStruct (line 26) | struct TupleStruct<T>(T, u32);
  type UnitStruct (line 28) | struct UnitStruct;
  function struct_debug_impl (line 125) | fn struct_debug_impl() {
  type BracedStructNE (line 185) | struct BracedStructNE<T: 'static> {
  type UnDebug (line 194) | struct UnDebug;
  type TupleStructNE (line 196) | struct TupleStructNE<T, U>(T, u32, PhantomData<U>);
  function struct_nonexhaustive_debug_impl (line 230) | fn struct_nonexhaustive_debug_impl() {
  type EnumA (line 254) | enum EnumA<T> {
  function enum_debug_impl (line 293) | fn enum_debug_impl() {
  type EnumA_NE (line 357) | enum EnumA_NE<T> {
  function enum_nonexhaustive_debug_impl (line 399) | fn enum_nonexhaustive_debug_impl() {
  type StructWE (line 435) | struct StructWE<T>(EnumA<T>);
  function enum_inside_struct (line 451) | fn enum_inside_struct() {

FILE: const_format/tests/misc_tests/inline_const_pattern_tests.rs
  function concatc_inline_pat_tests (line 9) | fn concatc_inline_pat_tests() {
  function concatcp_inline_pat_tests (line 15) | fn concatcp_inline_pat_tests() {
  function formatc_inline_pat_tests (line 21) | fn formatc_inline_pat_tests() {
  function formatcp_inline_pat_tests (line 27) | fn formatcp_inline_pat_tests() {
  function map_ascii_case_inline_pat_tests (line 33) | fn map_ascii_case_inline_pat_tests() {
  function str_get_inline_pat_tests (line 42) | fn str_get_inline_pat_tests() {
  function str_splice_out_inline_pat_tests (line 48) | fn str_splice_out_inline_pat_tests() {
  function str_index_inline_pat_tests (line 54) | fn str_index_inline_pat_tests() {
  function str_repeat_inline_pat_tests (line 60) | fn str_repeat_inline_pat_tests() {
  function str_replace_inline_pat_tests (line 66) | fn str_replace_inline_pat_tests() {
  function str_split_pat_inline_pat_tests (line 72) | fn str_split_pat_inline_pat_tests() {

FILE: const_format/tests/misc_tests/shared_cp_macro_tests.rs
  function other_tests (line 81) | fn other_tests() {
  function call_in_braced_macro (line 97) | fn call_in_braced_macro() {

FILE: const_format/tests/misc_tests/type_kind_coercion_macro_tests.rs
  function coercion (line 5) | fn coercion() {
  type UnitStruct (line 37) | struct UnitStruct;

FILE: const_format/tests/misc_tests/writec_macro.rs
  type Foo (line 7) | struct Foo {
  function basic (line 13) | fn basic() {
  function repeated_positional_args (line 36) | fn repeated_positional_args() {
  function write_from_consts (line 62) | fn write_from_consts() {
  function named_parameters (line 84) | fn named_parameters() {
  function write_from_locals (line 104) | fn write_from_locals() {
  function access_formatter (line 129) | fn access_formatter() {

FILE: const_format/tests/misc_tests_modules.rs
  constant NOT_CF (line 7) | pub const NOT_CF: usize = 13;
  constant _ASSERT_NOT_CF (line 8) | pub const _ASSERT_NOT_CF: [(); 13] = [(); const_format::NOT_CF];

FILE: const_format/tests/str_methods_modules/conv_ascii_case.rs
  function test_lowercase (line 22) | fn test_lowercase() {
  function test_uppercase (line 31) | fn test_uppercase() {
  function test_snake_kebab_case (line 40) | fn test_snake_kebab_case() {
  function test_pascal_camel_case (line 58) | fn test_pascal_camel_case() {

FILE: const_format/tests/str_methods_modules/str_replace.rs
  function test_small_pattern (line 23) | fn test_small_pattern() {
  function test_char_pattern (line 35) | fn test_char_pattern() {
  function test_replace_overlapping (line 75) | fn test_replace_overlapping() {
  function test_replace_empty (line 85) | fn test_replace_empty() {

FILE: const_format/tests/str_methods_modules/str_splice.rs
  function ss (line 3) | fn ss(output: &'static str, removed: &'static str) -> SplicedStr {
  constant IN (line 7) | const IN: &str = "abcdefghij";
  constant RW (line 8) | const RW: &str = "_.-";
  function splice_ranges (line 11) | fn splice_ranges() {
  function replacements (line 36) | fn replacements() {
  function splice_out_ranges (line 46) | fn splice_out_ranges() {
  function splice_out_replacements (line 71) | fn splice_out_replacements() {

FILE: const_format/tests/str_methods_modules/str_split_tests.rs
  function test_str_split_pat_basic_equivalence (line 4) | fn test_str_split_pat_basic_equivalence() {
  function test_str_split_with_empty_str_arg (line 19) | fn test_str_split_with_empty_str_arg() {
  function test_str_split_with_space_str_arg (line 32) | fn test_str_split_with_space_str_arg() {
  function test_str_split_with_dash_str_arg (line 41) | fn test_str_split_with_dash_str_arg() {
  function test_str_split_with_word_arg (line 50) | fn test_str_split_with_word_arg() {
  function test_str_split_with_ascii_char_arg (line 59) | fn test_str_split_with_ascii_char_arg() {
  function test_str_split_with_non_ascii_char_arg (line 68) | fn test_str_split_with_non_ascii_char_arg() {

FILE: const_format_proc_macros/src/datastructure.rs
  type DataStructure (line 20) | pub struct DataStructure<'a> {
  function new (line 36) | pub fn new(ast: &'a DeriveInput) -> Self {
  type StructKind (line 98) | pub enum StructKind {
  type DataVariant (line 106) | pub enum DataVariant {
  type FieldIndex (line 113) | pub struct FieldIndex {
  type StructParams (line 121) | struct StructParams<'a> {
  type Struct (line 128) | pub struct Struct<'a> {
  function new (line 141) | fn new(p: StructParams<'a>, fields: &'a SynFields) -> Self {
  function with_fields (line 156) | fn with_fields<I>(p: StructParams<'a>, kind: StructKind, fields: Option<...
  type Field (line 179) | pub struct Field<'a> {
  function new (line 189) | fn new(index: FieldIndex, field: &'a SynField) -> Self {
  function pattern_ident (line 213) | pub fn pattern_ident(&self) -> &Ident {
  function from_iter (line 217) | fn from_iter<I>(p: StructParams<'a>, fields: I) -> Vec<Self>
  type FieldIdent (line 238) | pub enum FieldIdent<'a> {
  method fmt (line 244) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method to_tokens (line 253) | fn to_tokens(&self, tokens: &mut TokenStream) {
  function new_index (line 262) | fn new_index(index: usize) -> Self {

FILE: const_format_proc_macros/src/datastructure/field_map.rs
  type FieldMap (line 13) | pub struct FieldMap<T> {
  function with (line 22) | pub fn with<'a, F>(ds: &'a DataStructure<'a>, mut f: F) -> Self
  function iter (line 36) | pub fn iter(&self) -> impl Iterator<Item = (FieldIndex, &'_ T)> + Clone ...
  function iter_mut (line 49) | pub fn iter_mut(&mut self) -> impl Iterator<Item = (FieldIndex, &'_ mut ...
  type Output (line 63) | type Output = T;
  function index (line 65) | fn index(&self, index: FieldIndex) -> &T {
  function index_mut (line 71) | fn index_mut(&mut self, index: FieldIndex) -> &mut T {
  type Output (line 77) | type Output = T;
  function index (line 79) | fn index(&self, field: &'a Field<'a>) -> &T {
  function index_mut (line 86) | fn index_mut(&mut self, field: &'a Field<'a>) -> &mut T {

FILE: const_format_proc_macros/src/derive_debug.rs
  function derive_constdebug_impl (line 15) | pub(crate) fn derive_constdebug_impl(input: DeriveInput) -> Result<Token...
  function coerce_and_fmt (line 150) | fn coerce_and_fmt(cratep: &TokenStream2, field: &Field<'_>) -> TokenStre...
  function fmt_slice (line 166) | fn fmt_slice(cratep: &TokenStream2, field: &Field<'_>) -> TokenStream2 {
  function fmt_option (line 189) | fn fmt_option(cratep: &TokenStream2, field: &Field<'_>) -> TokenStream2 {
  function fmt_newtype (line 212) | fn fmt_newtype(cratep: &TokenStream2, newtype: &syn::Ident, field: &Fiel...
  function call_with_function (line 233) | fn call_with_function(cratep: &TokenStream2, field: &Field<'_>, func: &s...
  function call_with_macro (line 240) | fn call_with_macro(cratep: &TokenStream2, field: &Field<'_>, macr: &syn:...
  function call_with_wrapper (line 247) | fn call_with_wrapper(
  function call_debug_fmt (line 261) | fn call_debug_fmt(
  function get_where_clause_tokens (line 281) | fn get_where_clause_tokens(where_clause: &Option<syn::WhereClause>) -> T...

FILE: const_format_proc_macros/src/derive_debug/attribute_parsing.rs
  type ConstDebugConfig (line 14) | pub(crate) struct ConstDebugConfig<'a> {
  function new (line 23) | fn new(roa: ConstDebugAttrs<'a>) -> Result<Self, crate::Error> {
  type ConstDebugAttrs (line 43) | struct ConstDebugAttrs<'a> {
  type FieldConfig (line 54) | pub(crate) struct FieldConfig<'a> {
  type HowToFmt (line 58) | pub(crate) enum HowToFmt<'a> {
  type ParseContext (line 83) | enum ParseContext<'a> {
  function parse_attrs_for_derive (line 88) | pub(crate) fn parse_attrs_for_derive<'a>(
  function parse_inner (line 117) | fn parse_inner<'a, I>(
  function parse_attr_list (line 141) | fn parse_attr_list<'a>(
  function make_err (line 157) | fn make_err(tokens: &dyn ToTokens) -> crate::Error {
  function parse_sabi_attr (line 162) | fn parse_sabi_attr<'a>(
  function parse_the_is_a_attribute (line 245) | fn parse_the_is_a_attribute<'a>(
  function parse_lit (line 270) | fn parse_lit<T>(lit: &syn::Lit) -> Result<T, crate::Error>
  function parse_expr (line 284) | fn parse_expr(lit: syn::Lit) -> Result<syn::Expr, crate::Error> {
  function with_nested_meta (line 295) | pub fn with_nested_meta<F>(

FILE: const_format_proc_macros/src/derive_debug/syntax.rs
  type ImplHeader (line 8) | pub(crate) struct ImplHeader {
  method parse (line 14) | fn parse(input: ParseStream) -> Result<Self, syn::Error> {

FILE: const_format_proc_macros/src/derive_debug/type_detection.rs
  function detect_type_formatting (line 5) | pub(super) fn detect_type_formatting(ty: &Type) -> HowToFmt {
  function unwrap_reference (line 17) | fn unwrap_reference(mut ty: &Type) -> &Type {
  function is_path_an_option (line 29) | fn is_path_an_option(path: &syn::Path) -> bool {
  function parse_type_as_ident (line 48) | pub(super) fn parse_type_as_ident(ty: &Type) -> Result<&syn::Ident, crat...

FILE: const_format_proc_macros/src/error.rs
  type Error (line 11) | pub struct Error {
    method new (line 27) | pub fn new<T: Display>(span: Span, msg: T) -> Self {
    method spanned (line 37) | pub fn spanned<T: Display>(spans: Spans, msg: T) -> Self {
    method to_compile_error (line 47) | pub fn to_compile_error(&self) -> TokenStream2 {
    method combine (line 98) | pub fn combine(&mut self, another: Error) {
    method from (line 105) | fn from(err: syn::Error) -> Self {
  type CompileError (line 16) | enum CompileError {

FILE: const_format_proc_macros/src/format_args.rs
  type UncheckedFormatArgs (line 16) | struct UncheckedFormatArgs {
  type UncheckedFormatArg (line 21) | struct UncheckedFormatArg {
  type FormatArgs (line 32) | pub(crate) struct FormatArgs {
  type FormatIfArgs (line 38) | pub(crate) struct FormatIfArgs {
  type WriteArgs (line 43) | pub(crate) struct WriteArgs {
  type ExpandInto (line 49) | pub(crate) enum ExpandInto {
    method fmt_call (line 91) | pub(crate) fn fmt_call(&self, formatter: &Ident) -> TokenStream2 {
  type ExpandFormatted (line 55) | pub(crate) struct ExpandFormatted {
  type ExpandWithFormatter (line 60) | pub(crate) struct ExpandWithFormatter {
  type LocalVariable (line 66) | pub(crate) struct LocalVariable {
  type FormatArg (line 76) | pub(crate) enum FormatArg {

FILE: const_format_proc_macros/src/format_args/parsing.rs
  method parse (line 19) | fn parse(input: ParseStream<'_>) -> Result<Self, crate::Error> {
  function lit_str_to_fmt_lit (line 62) | fn lit_str_to_fmt_lit(lit: &LitStr) -> Result<FormatStr, crate::Error> {
  function parse_fmt_lit (line 69) | fn parse_fmt_lit(this: &mut FormatStr, input: ParseStream<'_>) -> Result...
  method parse (line 98) | fn parse(input: ParseStream<'_>) -> Result<Self, crate::Error> {
  method parse (line 126) | fn parse(input: ParseStream<'_>) -> Result<Self, crate::Error> {
  method parse_with (line 133) | pub fn parse_with(input: ParseStream<'_>, prefix: Ident) -> Result<Forma...
  method parse (line 312) | fn parse(input: ParseStream) -> Result<Self, crate::Error> {
  method parse (line 325) | fn parse(input: ParseStream) -> Result<Self, crate::Error> {

FILE: const_format_proc_macros/src/format_macro.rs
  function concatcp_impl (line 17) | pub(crate) fn concatcp_impl(value: ExprArgs) -> Result<TokenStream2, cra...
  function formatcp_if_macro_impl (line 44) | pub(crate) fn formatcp_if_macro_impl(value: FormatIfArgs) -> Result<Toke...
  function formatcp_impl (line 48) | pub(crate) fn formatcp_impl(fmt_args: FormatArgs) -> Result<TokenStream2...
  function formatc_if_macro_impl (line 127) | pub(crate) fn formatc_if_macro_impl(value: FormatIfArgs) -> Result<Token...
  function formatc_macro_impl (line 133) | pub(crate) fn formatc_macro_impl(fmt_args: FormatArgs) -> Result<TokenSt...
  function writec_macro_impl (line 170) | pub(crate) fn writec_macro_impl(value: WriteArgs) -> Result<TokenStream2...

FILE: const_format_proc_macros/src/format_macro/tests.rs
  function process_str (line 3) | fn process_str(s: &str) -> Result<String, String> {
  function named_argument_followed_by_positional (line 19) | fn named_argument_followed_by_positional() {
  function access_formatter_error (line 27) | fn access_formatter_error() {
  function nonexistent_argument (line 45) | fn nonexistent_argument() {
  function unused_arguments (line 59) | fn unused_arguments() {

FILE: const_format_proc_macros/src/format_str.rs
  type FormatStr (line 13) | pub(crate) struct FormatStr {
  type FmtStrComponent (line 18) | pub(crate) enum FmtStrComponent {
  type FmtArg (line 25) | pub(crate) struct FmtArg {
  type WhichArg (line 32) | pub(crate) enum WhichArg {

FILE: const_format_proc_macros/src/format_str/errors.rs
  type ParseError (line 9) | pub(crate) struct ParseError {
    method error_span (line 61) | fn error_span(&self) -> Range<usize> {
    method into_crate_err (line 73) | pub(crate) fn into_crate_err(self, span: Span, original_str: &str) -> ...
  type ParseErrorKind (line 15) | pub(crate) enum ParseErrorKind {
    method not_a_number (line 35) | pub fn not_a_number(what: &str) -> Self {
    method not_an_ident (line 40) | pub fn not_an_ident(what: &str) -> Self {
    method unknown_formatting (line 45) | pub fn unknown_formatting(what: &str) -> Self {
  type DisplayParseError (line 55) | pub(crate) struct DisplayParseError<'a> {
  method fmt (line 85) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 101) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: const_format_proc_macros/src/format_str/parsing.rs
  method str (line 10) | pub(super) fn str(s: &str) -> Self {
  method arg (line 13) | pub(super) fn arg(which_arg: WhichArg, formatting: FormattingFlags) -> S...
  method new (line 23) | fn new(which_arg: WhichArg, formatting: FormattingFlags, rawness: StrRaw...
  method ident (line 34) | pub(super) fn ident(s: &str) -> Self {
  type Err (line 43) | type Err = ParseError;
  method from_str (line 45) | fn from_str(input: &str) -> Result<FormatStr, ParseError> {
  method parse (line 51) | pub fn parse(input: &str, rawness: StrRawness) -> Result<FormatStr, Pars...
  function parse_format_str (line 56) | fn parse_format_str(input: &str, rawness: StrRawness) -> Result<FormatSt...
  function parse_mid_str (line 95) | fn parse_mid_str(str: &str, starts_at: usize) -> Result<String, ParseErr...
  function parse_fmt_arg (line 121) | fn parse_fmt_arg(input: &str, starts_at: usize, rawness: StrRawness) -> ...
  function parse_which_arg (line 138) | fn parse_which_arg(input: &str, starts_at: usize) -> Result<WhichArg, Pa...
  function parse_formatting (line 159) | fn parse_formatting(input: &str, starts_at: usize) -> Result<FormattingF...
  function parse_ident (line 197) | fn parse_ident(ident_str: &str, starts_at: usize) -> Result<WhichArg, Pa...
  function is_ident (line 212) | fn is_ident(s: &str) -> bool {
  type VecExt (line 228) | trait VecExt {
    method push_arg_str (line 229) | fn push_arg_str(&mut self, str: String, rawness: StrRawness);
    method push_arg_str (line 233) | fn push_arg_str(&mut self, str: String, rawness: StrRawness) {
  type StrExt (line 240) | trait StrExt {
    method find_from (line 241) | fn find_from(&self, c: char, from: usize) -> Option<usize>;
    method find_from (line 245) | fn find_from(&self, c: char, from: usize) -> Option<usize> {

FILE: const_format_proc_macros/src/format_str/tests.rs
  function err (line 11) | fn err(s: &'static str) -> ParseError {
  function ok (line 15) | fn ok(s: &'static str) -> FormatStr {
  constant NOALT (line 19) | const NOALT: IsAlternate = IsAlternate::No;
  constant NFDEC (line 20) | const NFDEC: NumberFormatting = NumberFormatting::Decimal;
  function unclosed_arg (line 23) | fn unclosed_arg() {
  function invalid_closed_arg (line 48) | fn invalid_closed_arg() {
  function not_a_number (line 73) | fn not_a_number() {
  function not_an_ident (line 98) | fn not_an_ident() {
  function unknown_formatting (line 130) | fn unknown_formatting() {
  function ok_cases (line 148) | fn ok_cases() {
  type RngExt (line 198) | trait RngExt {
    method pick (line 202) | fn pick<'a, T>(&self, slice: &'a [T]) -> &'a T;
    method char_ (line 207) | fn char_(&self, bounds: RangeInclusive<char>) -> char;
    method pick (line 211) | fn pick<'a, T>(&self, slice: &'a [T]) -> &'a T {
    method char_ (line 215) | fn char_(&self, bounds: RangeInclusive<char>) -> char {
  function generate_input (line 230) | fn generate_input() -> String {
  function never_panics (line 262) | fn never_panics() {

FILE: const_format_proc_macros/src/formatting.rs
  type Formatting (line 6) | pub(crate) enum Formatting {
  type NumberFormatting (line 12) | pub(crate) enum NumberFormatting {
    method is_regular (line 20) | pub(crate) fn is_regular(self) -> bool {
  method to_tokens (line 26) | fn to_tokens(&self, ts: &mut TokenStream2) {
  type IsAlternate (line 39) | pub(crate) enum IsAlternate {
  type FormattingFlags (line 47) | pub(crate) struct FormattingFlags {
    method display (line 54) | pub(crate) const fn display(is_alternate: IsAlternate) -> Self {
    method debug (line 62) | pub(crate) const fn debug(num_fmt: NumberFormatting, is_alternate: IsA...
    method to_pargument_method_name (line 71) | pub(crate) fn to_pargument_method_name(self) -> Ident {
    method fmt_method_name (line 81) | pub(crate) fn fmt_method_name(self) -> Ident {
    method len_method_name (line 91) | pub(crate) fn len_method_name(self) -> Ident {
  method to_tokens (line 102) | fn to_tokens(&self, ts: &mut TokenStream2) {

FILE: const_format_proc_macros/src/lib.rs
  function compile_err_empty_str (line 44) | fn compile_err_empty_str(e: crate::Error) -> TokenStream2 {
  function __concatcp_impl (line 54) | pub fn __concatcp_impl(input: TokenStream1) -> TokenStream1 {
  function __formatcp_impl (line 70) | pub fn __formatcp_impl(input: TokenStream1) -> TokenStream1 {
  function __formatc_impl (line 79) | pub fn __formatc_impl(input: TokenStream1) -> TokenStream1 {
  function __formatc_if_impl (line 88) | pub fn __formatc_if_impl(input: TokenStream1) -> TokenStream1 {
  function __formatcp_if_impl (line 97) | pub fn __formatcp_if_impl(input: TokenStream1) -> TokenStream1 {
  function __writec_impl (line 106) | pub fn __writec_impl(input: TokenStream1) -> TokenStream1 {
  function derive_const_debug (line 121) | pub fn derive_const_debug(input: TokenStream1) -> TokenStream1 {
  function respan_to (line 132) | pub fn respan_to(input: TokenStream1) -> TokenStream1 {

FILE: const_format_proc_macros/src/parse_utils.rs
  type ParseStream (line 10) | pub type ParseStream<'a> = &'a mut ParseBuffer;
  type ParseBuffer (line 12) | pub struct ParseBuffer {
    method new (line 17) | pub fn new(ts: TokenStream2) -> Self {
    method is_empty (line 22) | pub fn is_empty(&mut self) -> bool {
    method peek (line 26) | pub fn peek(&mut self) -> Option<&TokenTree2> {
    method peek2 (line 29) | pub fn peek2(&mut self) -> Option<&TokenTree2> {
    method parse_punct (line 33) | pub fn parse_punct(&mut self, c: char) -> Result<Punct, crate::Error> {
    method parse_opt_punct (line 43) | pub fn parse_opt_punct(&mut self, c: char) -> Result<Option<Punct>, cr...
    method parse_ident (line 51) | pub fn parse_ident(&mut self) -> Result<Ident, crate::Error> {
    method parse_paren (line 59) | pub fn parse_paren(&mut self) -> Result<Parentheses, crate::Error> {
    method parse_unwrap_paren (line 78) | pub fn parse_unwrap_paren<F, T>(&mut self, f: F) -> Result<T, crate::E...
    method parse_unwrap_group (line 94) | pub fn parse_unwrap_group<F, T>(&mut self, f: F) -> Result<T, crate::E...
    method parse_token_stream_and_span (line 105) | pub fn parse_token_stream_and_span(&mut self) -> (TokenStream2, Spans) {
    method parse_unwrap_tt (line 128) | pub fn parse_unwrap_tt<F, T>(&mut self, f: F) -> Result<T, crate::Error>
  type Item (line 145) | type Item = TokenTree2;
  method next (line 147) | fn next(&mut self) -> Option<TokenTree2> {
  method size_hint (line 151) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Parentheses (line 158) | pub struct Parentheses {
  type LitStr (line 166) | pub struct LitStr {
    method value (line 174) | pub fn value(&self) -> &str {
    method parse_from_literal (line 177) | pub(crate) fn parse_from_literal(literal: &proc_macro2::Literal) -> Re...
  type StrRawness (line 240) | pub struct StrRawness {
    method dummy (line 253) | pub fn dummy() -> Self {
    method span (line 260) | pub fn span(&self) -> Span {
    method tokenize_sub (line 265) | pub fn tokenize_sub(&self, str: &str) -> TokenStream2 {
  method eq (line 246) | fn eq(&self, other: &Self) -> bool {
  type TokenTreeExt (line 296) | pub trait TokenTreeExt: Sized {
    method as_token_tree (line 297) | fn as_token_tree(&self) -> &TokenTree2;
    method into_token_tree (line 298) | fn into_token_tree(self) -> TokenTree2;
    method is_punct (line 300) | fn is_punct(&self, c: char) -> bool {
    method is_paren (line 305) | fn is_paren(&self) -> bool {
    method is_ident (line 313) | fn is_ident(&self, ident: &str) -> bool {
    method set_span_recursive (line 317) | fn set_span_recursive(self, span: Span) -> TokenTree2 {
    method as_token_tree (line 332) | fn as_token_tree(&self) -> &TokenTree2 {
    method into_token_tree (line 336) | fn into_token_tree(self) -> TokenTree2 {
  type TokenStream2Ext (line 343) | pub trait TokenStream2Ext: Sized {
    method into_token_stream (line 344) | fn into_token_stream(self) -> TokenStream2;
    method set_span_recursive (line 346) | fn set_span_recursive(self, span: Span) -> TokenStream2 {
    method into_token_stream (line 355) | fn into_token_stream(self) -> TokenStream2 {
  type MyParse (line 362) | pub trait MyParse: Sized {
    method parse (line 363) | fn parse(input: ParseStream<'_>) -> Result<Self, crate::Error>;
    method parse_token_stream_1 (line 365) | fn parse_token_stream_1(input: proc_macro::TokenStream) -> Result<Self...
    method parse_token_stream_2 (line 370) | fn parse_token_stream_2(input: TokenStream2) -> Result<Self, crate::Er...

FILE: const_format_proc_macros/src/respan_to_macro.rs
  constant MSG (line 5) | const MSG: &str = "Expected the macro to be called as `respan_to!((token...
  function parse_paren (line 7) | fn parse_paren(tt: TokenTree2) -> TokenStream2 {
  function get_span (line 14) | fn get_span(ts: TokenStream2) -> Span {
  function implementation (line 33) | pub(crate) fn implementation(ts: TokenStream2) -> TokenStream2 {

FILE: const_format_proc_macros/src/shared_arg_parsing.rs
  type ExprArg (line 15) | pub(crate) struct ExprArg {
  method to_tokens (line 23) | fn to_tokens(&self, ts: &mut TokenStream2) {
  type ExprArgs (line 29) | pub(crate) struct ExprArgs {
  method parse (line 36) | fn parse(input: ParseStream<'_>) -> Result<Self, crate::Error> {
  method parse (line 52) | fn parse(input: ParseStream<'_>) -> Result<Self, crate::Error> {

FILE: const_format_proc_macros/src/spanned.rs
  type Spans (line 4) | pub struct Spans {
    method joined (line 10) | pub fn joined(self) -> Span {

FILE: const_format_proc_macros/src/test_utils.rs
  type StrExt (line 1) | pub trait StrExt {
    method as_str (line 2) | fn as_str(&self) -> &str;
    method consecutive_in_self (line 8) | fn consecutive_in_self(&self, needles: &[&str]) -> bool {
    method as_str (line 22) | fn as_str(&self) -> &str {
    method as_str (line 29) | fn as_str(&self) -> &str {

FILE: const_format_proc_macros/src/utils.rs
  function dummy_ident (line 13) | pub(crate) fn dummy_ident() -> proc_macro2::Ident {
  function spanned_err (line 20) | pub fn spanned_err(tokens: &dyn ToTokens, display: &dyn std::fmt::Displa...
  type Peekable2 (line 28) | pub struct Peekable2<I: Iterator> {
  function new (line 35) | pub fn new<I: IntoIterator>(iter: I) -> Peekable2<I::IntoIter> {
  function is_empty (line 44) | pub fn is_empty(&mut self) -> bool {
  function peek (line 48) | pub fn peek(&mut self) -> Option<&I::Item> {
  function peek2 (line 54) | pub fn peek2(&mut self) -> Option<&I::Item> {
  type Item (line 66) | type Item = I::Item;
  method next (line 68) | fn next(&mut self) -> Option<I::Item> {
  method size_hint (line 76) | fn size_hint(&self) -> (usize, Option<usize>) {
  type LinearResult (line 88) | pub struct LinearResult {
    method new (line 100) | pub fn new(res: Result<(), crate::Error>) -> Self {
    method ok (line 105) | pub fn ok() -> Self {
    method from (line 112) | fn from(res: Result<(), crate::Error>) -> Self {
    method into_result (line 134) | pub fn into_result(mut self) -> Result<(), crate::Error> {
    method take (line 139) | pub fn take(&mut self) -> Result<(), crate::Error> {
    method replace (line 144) | pub fn replace(&mut self, other: Result<(), crate::Error>) -> Result<(...
    method push_err (line 149) | pub fn push_err<E>(&mut self, err: E)
    method combine_err (line 161) | pub fn combine_err<E>(&mut self, res: Result<(), E>)
  method drop (line 93) | fn drop(&mut self) {
  type Target (line 118) | type Target = Result<(), crate::Error>;
  method deref (line 120) | fn deref(&self) -> &Result<(), crate::Error> {
  method deref_mut (line 126) | fn deref_mut(&mut self) -> &mut Result<(), crate::Error> {

FILE: print_errors/src/formatc_macros.rs
  constant _ (line 5) | const _: &str = formatcp!("{}");
  constant _ (line 7) | const _: &str = formatcp!("{}", foo = "", 100u8 + 0);
  constant _ (line 9) | const _: &str = formatcp!("{}", 0 + 0);
  constant _ (line 11) | const _: &str = formatcp!("{}", 0u8, 0u8 + 1);
  constant _ (line 13) | const _: &str = formatcp!("{}", |fmt| 0 + 0);
  constant _ (line 15) | const _: () = {

FILE: print_errors/src/lib.rs
  constant _ (line 5) | const _: &str = cfmt::concatcp!(0, 1, ());
  constant _ (line 7) | const _: &str = cfmt::concatc!(0, 1, ());

FILE: print_errors/src/using_writec_macro.rs
  function using_writec (line 3) | fn using_writec(writer: &mut StrWriter) -> cfmt::Result {

FILE: print_warnings/src/main.rs
  constant TWO (line 11) | pub const TWO: u32 = 2;
  constant TEN (line 12) | pub const TEN: u32 = 10;
  constant CONCATC_A (line 18) | pub const CONCATC_A: &str = concatc!("hello", "world");
  constant CONCATC_B (line 19) | pub const CONCATC_B: &str = concatc!(10u8, TWO);
  constant FORMATC_A (line 21) | pub const FORMATC_A: &str = formatc!("{}hello{}{:?}", "foo", 100u8, Unit);
  function as_str_ctor (line 23) | const fn as_str_ctor() -> StrWriter<[u8; 100]> {
  constant __AS_STR (line 35) | pub const __AS_STR: &StrWriter = &as_str_ctor();
  constant AS_STR (line 36) | pub const AS_STR: &str = __AS_STR.as_str();
  constant CONCATCP_A (line 39) | pub const CONCATCP_A: &str = concatcp!("hello", "world");
  constant CONCATCP_B (line 40) | pub const CONCATCP_B: &str = concatcp!(10u8, 20u8);
  constant FORMATCP_A (line 42) | pub const FORMATCP_A: &str = formatcp!("{}hello{:x?}", "foo", 100u8);
  function main (line 46) | fn main() {}