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
fn format_into(self, tokens: &mut Tokens<L>)
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
sourceimpl<L, T> FormatInto<L> for Vec<T> where
L: Lang,
T: FormatInto<L>,
impl<L, T> FormatInto<L> for Vec<T> where
L: Lang,
T: FormatInto<L>,
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!(#<space>bar));
let result = quote!(#vec baz);
assert_eq!("foo bar baz", result.to_string()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<'a, L, T> FormatInto<L> for &'a [T] where
L: Lang,
T: Clone + FormatInto<L>,
impl<'a, L, T> FormatInto<L> for &'a [T] where
L: Lang,
T: Clone + FormatInto<L>,
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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<'a, L> FormatInto<L> for &'a str where
L: Lang,
impl<'a, L> FormatInto<L> for &'a 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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<'a, L> FormatInto<L> for &'a String where
L: Lang,
impl<'a, L> FormatInto<L> for &'a 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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for String where
L: Lang,
impl<L> FormatInto<L> for String where
L: Lang,
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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for Rc<String> where
L: Lang,
impl<L> FormatInto<L> for Rc<String> where
L: Lang,
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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<'a, L> FormatInto<L> for &'a Rc<String> where
L: Lang,
impl<'a, L> FormatInto<L> for &'a Rc<String> where
L: Lang,
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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L, T> FormatInto<L> for Option<T> where
L: Lang,
T: FormatInto<L>,
impl<L, T> FormatInto<L> for Option<T> where
L: Lang,
T: FormatInto<L>,
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()?);
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for u8 where
L: Lang,
impl<L> FormatInto<L> for u8 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for u16 where
L: Lang,
impl<L> FormatInto<L> for u16 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for u32 where
L: Lang,
impl<L> FormatInto<L> for u32 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for u64 where
L: Lang,
impl<L> FormatInto<L> for u64 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for u128 where
L: Lang,
impl<L> FormatInto<L> for u128 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for i8 where
L: Lang,
impl<L> FormatInto<L> for i8 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for i16 where
L: Lang,
impl<L> FormatInto<L> for i16 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for i32 where
L: Lang,
impl<L> FormatInto<L> for i32 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for i64 where
L: Lang,
impl<L> FormatInto<L> for i64 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for i128 where
L: Lang,
impl<L> FormatInto<L> for i128 where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for isize where
L: Lang,
impl<L> FormatInto<L> for isize where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
sourceimpl<L> FormatInto<L> for usize where
L: Lang,
impl<L> FormatInto<L> for usize where
L: Lang,
Implementation for primitive type. Uses the corresponding Display implementation for the primitive type.
fn format_into(self, tokens: &mut Tokens<L>)
Implementors
impl FormatInto<Csharp> for genco::lang::csharp::Import
impl FormatInto<Dart> for genco::lang::dart::Import
impl FormatInto<Go> for genco::lang::go::Import
impl FormatInto<Java> for genco::lang::java::Import
impl FormatInto<JavaScript> for genco::lang::js::Import
impl FormatInto<Python> for genco::lang::python::Import
impl FormatInto<Python> for ImportModule
impl FormatInto<Rust> for genco::lang::rust::Import
impl FormatInto<Swift> for genco::lang::swift::Import
impl<'a> FormatInto<Csharp> for &'a genco::lang::csharp::Import
impl<'a> FormatInto<Dart> for &'a genco::lang::dart::Import
impl<'a> FormatInto<Go> for &'a genco::lang::go::Import
impl<'a> FormatInto<Java> for &'a genco::lang::java::Import
impl<'a> FormatInto<JavaScript> for &'a genco::lang::js::Import
impl<'a> FormatInto<Python> for &'a genco::lang::python::Import
impl<'a> FormatInto<Python> for &'a ImportModule
impl<'a> FormatInto<Rust> for &'a genco::lang::rust::Import
impl<'a> FormatInto<Swift> for &'a genco::lang::swift::Import
impl<'a, L> FormatInto<L> for &'a ItemStr where
L: Lang,
impl<'a, L> FormatInto<L> for &'a Tokens<L> where
L: Lang,
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 = "e!(foo bar);
let result = quote!(#a baz);
assert_eq!("foo bar baz", result.to_string()?);
impl<L> FormatInto<L> for Item<L> where
L: Lang,
Formatting an item is the same as adding said item to the token stream through item().
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,
};
impl<L> FormatInto<L> for ItemStr where
L: Lang,
Convert stringy things.