1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
//! Macros for concatenating and formatting constants into `&'static str` constants. //! //! # Examples //! //! ### Concatenation //! //! ```rust //! use const_format::concatcp; //! //! const NAME: &str = "Bob"; //! const FOO: &str = concatcp!(NAME, ", age ", 21u8,"!"); //! //! assert_eq!(FOO, "Bob, age 21!"); //! ``` //! //! ### Formatting //! //! ```rust //! use const_format::formatcp; //! //! const NAME: &str = "John"; //! //! const FOO: &str = formatcp!("{NAME}, age {}!", compute_age(NAME)); //! //! assert_eq!(FOO, "John, age 24!"); //! //! # const fn compute_age(s: &str) -> usize { s.len() * 6 } //! //! ``` //! //! //! <div id="macro-limitations"></div> //! //! # Limitations //! //! All of the macros from `const_format` have these limitations: //! //! - They cannot take constants that *use* generic parameters, //! so while `Type::<u8>::FOO` is fine `Type::<T>::FOO` is not (`T` being a type parameter). //! //! - Integer arguments must have a type inferrable from context, //! [more details in the Integer arguments section](#integer-args). //! //! - They cannot be used places that take string literals. //! So `#[doc = "foobar"]` cannot be replaced with `#[doc = concatcp!("foo", "bar") ]`. //! //! <span id="integer-args"></span> //! ### Integer arguments //! //! Integer arguments must have a type inferrable from context. //! so if you only pass an integer literal it must have a suffix. //! //! Example of what does compile: //! //! ```rust //! const N: u32 = 1; //! assert_eq!(const_format::concatcp!(N + 1, 2 + N), "23"); //! //! assert_eq!(const_format::concatcp!(2u32, 2 + 1u8, 3u8 + 1), "234"); //! ``` //! //! Example of what does not compile: //! ```compile_fail //! assert_eq!(const_format::concatcp!(1 + 1, 2 + 1), "23"); //! ``` //! //! # Cargo features //! //! None yet. //! //! # No-std support //! //! `const_format` is unconditionally `#![no_std]`, so it can be used anywhere Rust can be used. //! //! # Minimum Supported Rust Version //! //! `const_format` requires Rust 1.46.0, because it uses looping an branching in const contexts. //! //! Features that require versions of Rust, or the nightly compiler, //! need to be explicitly enabled with cargo features. //! #![no_std] #[macro_use] mod helper_macros; mod formatting; #[macro_use] mod fmt_macros; mod pargument; mod pwrapper; mod utils; #[cfg(test)] mod misc_tests; #[doc(hidden)] pub mod pmr { pub use const_format_proc_macros::__formatcp_impl; pub use core::ops::Range; pub use crate::{ formatting::{is_escaped_simple, Formatting, LenAndArray, StartAndArray}, pargument::{PArgument, PConvWrapper, PVariant}, pwrapper::PWrapper, utils::Transmute, }; }