Struct Expression

pub struct Expression<'a, T> {
    pub on: T,
    pub arguments: Vec<Expression<'a, T>, &'a Allocator>,
}

Fields

on: T

arguments: Vec<Expression<'a, T>, &'a Allocator>

Implementations

impl<'a, T> Expression<'a, T>

where T: Literal<'a>,

pub fn from_string( source: &'a str, configuration: &'a Configuration<'_>, allocator: &'a Allocator, ) -> Self

Examples found in repository

examples/wat.rs (line 16)

fn main() {
	let allocator = bumpalo::Bump::new();

	let expression = r#"(module
  (func (result i32)
    (i32.const 42)
  )
  (export "forty_two" (func 0))
)"#;

	let configuration = Configuration::default();

	let expression: Expression<WASMValue> =
		Expression::from_string(expression, &configuration, &allocator);

	dbg!(expression);
}

examples/operations.rs (line 21)

fn main() {
	let multiply_operator = BinaryOperator { representation: "*", precedence: 4 };
	let sources = &["3xy+rx", "3*x*y+r*x", "(x + t)(x + z)", "sin(-x)"];
	let configuration = Configuration {
		prefix_unary_operators: vec![UnaryOperator { representation: "-", precedence: 2 }],
		binary_operators: vec![
			BinaryOperator { representation: "^", precedence: 5 },
			BinaryOperator { representation: "*", precedence: 4 },
			multiply_operator,
			BinaryOperator { representation: "+", precedence: 3 },
		],
		adjacency: Some(Adjacency { operator: multiply_operator, functions: vec!["sin"] }),
		..Default::default()
	};

	for source in sources {
		let allocator = bumpalo::Bump::new();
		let expression: Expression<&str> =
			Expression::from_string(source, &configuration, &allocator);
		eprintln!("{expression:#?}");
	}
}

examples/parse.rs (line 22)

fn main() {
	let arg = std::env::args().nth(1);

	if let Some("--interactive") = arg.as_deref() {
		run_interactive();
		return;
	}

	if let Some(path) = std::env::args().nth(1) {
		let source = std::fs::read_to_string(&path).unwrap();
		let (configuration, source) = extract_configuration_and_source(&source);

		eprintln!("{configuration:?}");

		let allocator = bumpalo::Bump::new();
		let expression: Expression<&str> =
			Expression::from_string(&source, &configuration, &allocator);

		let expression = ExpressionRepresentation(&expression);
		println!("{source}\n -> {expression}");
	} else {
		let configuration = Configuration {
			binary_operators: vec![
				BinaryOperator { representation: "*", precedence: 4 },
				BinaryOperator { representation: "+", precedence: 3 },
			],
			..Default::default()
		};

		let sources: &[&str] = &["(x (a * b) (d * 2 + e))", "(x (a b) (c d e))"];

		for source in sources {
			let allocator = bumpalo::Bump::new();
			let expression: Expression<&str> =
				Expression::from_string(source, &configuration, &allocator);
			let expression = ExpressionRepresentation(&expression);
			eprintln!("{source}\n -> {expression}");
		}
	}
}

fn run_interactive() {
	use std::io::{BufRead, stdin};
	let stdin = stdin();
	let mut buf = Vec::new();

	println!("start");

	for line in stdin.lock().lines().map_while(Result::ok) {
		if line == "close" {
			if !buf.is_empty() {
				eprintln!("no end to message {buf:?}");
			}
			break;
		}

		if line == "end" {
			let output = String::from_utf8_lossy(&buf);

			let (configuration, source) = extract_configuration_and_source(&output);

			// eprintln!("{configuration:?} {source}");

			{
				let allocator = bumpalo::Bump::new();
				let expression: Expression<&str> =
					Expression::from_string(&source, &configuration, &allocator);
				let expression = ExpressionRepresentation(&expression);
				println!("{expression}");
			}

			// if let Err(error) = out {
			//     println!("Error: {error:?}");
			// }

			println!("end");
			buf.clear();
			continue;
		}

		buf.extend_from_slice(line.as_bytes());
		buf.push(b'\n');
	}
}

pub fn from_reader( reader: &mut Lexer<'a>, configuration: &'a Configuration<'_>, allocator: &'a Allocator, ) -> Self

Trait Implementations

impl<'a, T: Debug> Debug for Expression<'a, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.