pub trait Lex {
// Required method
fn to_tokens(&self, output: &mut TokenStream);
// Provided methods
fn to_token_stream(&self) -> TokenStream { ... }
fn to_m2(&self) -> String { ... }
}Expand description
Emits a typed or raw syntax value into the shared token representation.
Required Methods§
Sourcefn to_tokens(&self, output: &mut TokenStream)
fn to_tokens(&self, output: &mut TokenStream)
Appends this value’s token trees to output.
Provided Methods§
Sourcefn to_token_stream(&self) -> TokenStream
fn to_token_stream(&self) -> TokenStream
Emits this value into a fresh token stream.
Examples found in repository?
examples/parse_emit_walkthrough.rs (line 55)
54 fn to_tokens(&self, output: &mut TokenStream) {
55 output.extend(self.left.to_token_stream());
56 output.extend(self.operator.to_token_stream());
57 output.extend(self.right.to_token_stream());
58 }
59}
60
61fn main() -> Result<(), TokenParseError> {
62 let quoted = quote_m2!(left + right);
63 println!("1. quote_m2! produced:\n{quoted:#?}\n");
64
65 let parsed: Addition = parse2(quoted)?;
66 println!("2. Parse produced:\n{parsed:#?}\n");
67
68 let emitted = parsed.to_token_stream();
69 println!("3. Lex produced:\n{emitted:#?}\n");
70 println!("4. Display merged those tokens as: {emitted}");
71
72 let reparsed: Addition = parse2(emitted)?;
73 assert_eq!(reparsed, parsed);
74
75 Ok(())
76}Sourcefn to_m2(&self) -> String
fn to_m2(&self) -> String
Renders this value as normalized Macaulay2 source.
Examples found in repository?
examples/hierarchy_visit_emit.rs (line 28)
16fn main() -> Result<(), ParseError> {
17 let quoted = quote_m2! {
18 left + right 2
19 };
20 let source_file = parse_tokens("ed)?;
21 let _cell = &source_file.cells[0];
22
23 let mut collector = SymbolCollector::default();
24 collector.visit_source_file(&source_file);
25
26 println!("hierarchy: Component -> ExprPack -> Cell -> SourceFile");
27 println!("visited: {}", collector.symbols.join(", "));
28 print!("generated: {}", source_file.to_m2());
29 Ok(())
30}Dyn Compatibility§
This trait is dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".