Trait FormatInto

Source

pub trait FormatInto<L>where
    L: Lang,{
    // Required method
    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§

Source

fn format_into(self, tokens: &mut Tokens<L>)

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§

Source §

impl<'a, L> FormatInto<L> for &Cow<'a, str>
where L: Lang,

Cow strings are formatted by either borrowing or cloning the string.

§Examples

use std::borrow::Cow;
use genco::prelude::*;

let foo = &Cow::<str>::Borrowed("foo");
let bar = &Cow::<str>::Owned(String::from("bar"));

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

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

Source §

fn format_into(self, tokens: &mut Tokens<L>)

Source §

impl<'a, L> FormatInto<L> for Cow<'a, str>
where L: Lang,

Cow strings are formatted by either borrowing or cloning the string.

§Examples

use std::borrow::Cow;
use genco::prelude::*;

let foo = Cow::<str>::Borrowed("foo");
let bar = Cow::<str>::Owned(String::from("bar"));

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

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

Source §

fn format_into(self, tokens: &mut Tokens<L>)

Source §

impl<'a, L, T> FormatInto<L> for &Cow<'a, [T]>
where L: Lang, T: FormatInto<L> + Clone,

Cow slices are formatted by either borrowing or cloning the slice.

§Examples

use std::borrow::Cow;
use genco::prelude::*;

let foo = &Cow::<[&str]>::Borrowed(&["foo", "bar"]);
let bar = &Cow::<[&str]>::Owned(vec!["baz"]);

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

assert_eq!("foobar baz biz", result.to_string()?);

Source §

fn format_into(self, tokens: &mut Tokens<L>)

Source §

impl<'a, L, T> FormatInto<L> for Cow<'a, [T]>
where L: Lang, T: FormatInto<L> + Clone,

Cow slices are formatted by either borrowing or cloning the slice.

§Examples

use std::borrow::Cow;
use genco::prelude::*;

let foo = Cow::<[&str]>::Borrowed(&["foo", "bar"]);
let bar = Cow::<[&str]>::Owned(vec!["baz"]);

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

assert_eq!("foobar baz biz", result.to_string()?);

Source §

fn format_into(self, tokens: &mut Tokens<L>)

Source §

impl<L> FormatInto<L> for &str
where L: Lang,

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()?);

Source §

fn format_into(self, tokens: &mut Tokens<L>)

Source §

impl<L> FormatInto<L> for &Rc<String>
where L: Lang,

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

§Examples

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

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()?);

Source §

fn format_into(self, tokens: &mut Tokens<L>)

Source §

impl<L> FormatInto<L> for &String
where L: Lang,

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()?);

Source §