12 releases

0.2.4-rc2 Apr 16, 2021
0.2.3 Apr 22, 2020
0.2.2 Nov 3, 2019
0.1.4 Aug 4, 2019
0.0.1 Jul 27, 2019

#1286 in Procedural macros

Download history 416/week @ 2022-08-12 312/week @ 2022-08-19 418/week @ 2022-08-26 443/week @ 2022-09-02 466/week @ 2022-09-09 299/week @ 2022-09-16 426/week @ 2022-09-23 462/week @ 2022-09-30 600/week @ 2022-10-07 209/week @ 2022-10-14 321/week @ 2022-10-21 483/week @ 2022-10-28 408/week @ 2022-11-04 456/week @ 2022-11-11 449/week @ 2022-11-18 432/week @ 2022-11-25

1,831 downloads per month
Used in 10 crates (via fstrings)

MIT license

11KB
284 lines

::fstrings

Repository Latest version Documentation MSRV License

  • Note, this crate has been rendered obsolete as of 1.58.0, wherein let x = 42; println!("{x}"); acts as let x = 42; println_f!("{x}"); here.

    A precursor/pioneer crate, for sure, and one which now has been subsumed by RFC 2795, which successfully championed the ideas behind this crate! 🏆

Basic fstring interpolation in Rust

The interpolation works as follows:

  1. if the (template) string literal contains a named parameter (e.g. {name})

  2. and no name = value argument is fed to the formatting call,

  3. then an automatic name = name argument is added, so that the variable is effectively interpolated from the current scope.

Example

#[macro_use]
extern crate fstrings;

fn main ()
{
    let name = "World";

    // Usage is simple: just append `_f` to the name of any formatting macro
    println_f!("Hello, {name}!");

    assert_eq!(
        f!("Hello, {name}!"), // shorthand for String creation (Python-like)
        String::from("Hello, World!"),
    );

    // ## Advanced cases:
    {
        // It remains compatible with classic formatting parameters
        assert_eq!(
            f!("{hi}, {name}!", hi = "Hello"),
            "Hello, World!",
        );

        // You can override / shadow the named arguments
        assert_eq!(
            f!("Hello, {name}!", name = "Earth"),
            "Hello, Earth!",
        );

        // You can use field access (but no method calls!)
        let foo = Foo { name }; /* where */ struct Foo<T> { name: T }
        assert_eq!(
            f!("Hello, {foo.name}!"),
            "Hello, World!",
        );

        // This also works with tuple indexing.
        let ft_and_name = (42, name);
        assert_eq!(
            f!("Hello, {ft_and_name.1}!"),
            "Hello, World!",
        );

        // You can use fstrings to debug by appending a `=` after the
        // interpolated expression.
        let x = 0b_101010;
        assert_eq!(
            f!("In this context {x=}"),
            "In this context x = 42",
        );
    }
}

Dependencies

~210–620KB
~15K SLoC