Trait genco::prelude::FormatInto

source · [−]
pub trait FormatInto<L> where
    L: Lang, {
    fn format_into(self, tokens: &mut Tokens<L>);
}
Expand description

Trait for types that can be formatted in-place into a token stream.

Things implementing FormatInto can be used as arguments for interpolation in the quote! macro.

from_fn() is a helper function which simplifies the task of creating a FormatInto implementation on the fly.

Examples

use genco::quote_in;
use genco::tokens::{ItemStr, FormatInto, from_fn, static_literal};
use genco::lang::Lang;

fn comment<L>(s: impl Into<ItemStr>) -> impl FormatInto<L>
where
    L: Lang
{
    from_fn(move |tokens| {
        let s = s.into();
        quote_in!(*tokens => $(static_literal("//")) $s);
    })
}

Required Methods

Convert the type into tokens in-place.

A simple way to build ad-hoc format_into implementations is by using the from_fn() function.

Implementations on Foreign Types

Formatting a vector of token streams is like formatting each, one after another.

Examples

use genco::prelude::*;

let mut vec = Vec::<Tokens>::new();
vec.push(quote!(foo));
vec.push(quote!($[' ']bar));

let result = quote!($vec baz);

assert_eq!("foo bar baz", result.to_string()?);

Formatting a slice of token streams is like formatting each, one after another.

This will cause each token stream to be cloned into the destination stream.

Examples

use genco::prelude::*;

let vec = vec!["foo", " ", "bar"];
let slice = &vec[..];

let result: Tokens = quote!($slice baz);

assert_eq!("foo bar baz", result.to_string()?);

Formatting borrowed string boxed them on the heap.

Examples

use genco::prelude::*;

let foo = "foo";
let bar = "bar";

let result: Tokens = quote!($foo $bar baz);

assert_eq!("foo bar baz", result.to_string()?);

Formatting borrowed string boxed them on the heap.

Examples

use genco::prelude::*;

let foo = String::from("foo");
let bar = String::from("bar");

let result: Tokens = quote!($(&foo) $(&bar) baz);

assert_eq!("foo bar baz", result.to_string()?);

Formatting owned strings takes ownership of the string directly from the heap.

Examples

use genco::prelude::*;

let foo = String::from("foo");
let bar = String::from("bar");

let result: Tokens = quote!($foo $bar baz);

assert_eq!("foo bar baz", result.to_string()?);

Refcounted strings are moved into the token stream without copying.

Examples

use genco::prelude::*;
use std::rc::Rc;

let foo = Rc::new(String::from("foo"));
let bar = Rc::new(String::from("bar"));

let result: Tokens = quote!($foo $bar baz);

assert_eq!("foo bar baz", result.to_string()?);

Refcounted strings are cloned and moved into the token stream without copying.

Examples

use genco::prelude::*;
use std::rc::Rc;

let foo = Rc::new(String::from("foo"));
let bar = Rc::new(String::from("bar"));

let result: Tokens = quote!($(&foo) $(&bar) baz);

assert_eq!("foo bar baz", result.to_string()?);

Implementation for Arguments which allows for arbitrary and efficient literal formatting.

Examples

use genco::prelude::*;

let name = "John";
let result: Tokens = quote!($(format_args!("Hello {name}")));

assert_eq!("Hello John", result.to_string()?);

Optional items are formatted if they are present.

Examples

use genco::prelude::*;
use std::rc::Rc;

let foo = Some("foo");
let bar = Some("bar");
let biz = None::<&str>;

let result: Tokens = quote!($foo $bar baz $biz);

assert_eq!("foo bar baz", result.to_string()?);

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.

Implementors

Formatting a reference to a token stream is exactly the same as extending the token stream with a copy of the stream being formatted.

Examples

use genco::prelude::*;

let a: &Tokens = &quote!(foo bar);

let result = quote!($a baz);

assert_eq!("foo bar baz", result.to_string()?);

Formatting an item is the same as simply adding that item to the token stream.

Examples

use genco::prelude::*;
use genco::tokens::{Item, ItemStr};

let foo = Item::Literal(ItemStr::Static("foo"));
let bar = Item::Literal(ItemStr::Box("bar".into()));

let result: Tokens = quote!($foo $bar baz);

assert_eq!("foo bar baz", result.to_string()?);

assert_eq!{
    vec![
        Item::Literal(ItemStr::Static("foo")),
        Item::Space,
        Item::Literal(ItemStr::Box("bar".into())),
        Item::Space,
        Item::Literal(ItemStr::Static("baz")),
    ] as Vec<Item<()>>,
    result,
};

Convert stringy things.