mod eval;
use crate::value::Value;
use std::collections::HashMap;
#[derive(Clone, Debug, PartialEq)]
pub enum Expr {
Value(Value),
Reference(String),
Function(String, Box<Expr>),
Index(Box<Expr>, Box<Expr>),
If(Box<Expr>, Box<Expr>, Box<Expr>),
Map(HashMap<String, Expr>),
Vec(Vec<Expr>),
Not(Box<Expr>),
Neg(Box<Expr>),
Int(Box<Expr>),
Float(Box<Expr>),
Dec(Box<Expr>),
Mult(Box<Expr>, Box<Expr>),
Div(Box<Expr>, Box<Expr>),
Add(Box<Expr>, Box<Expr>),
Sub(Box<Expr>, Box<Expr>),
Equals(Box<Expr>, Box<Expr>),
NotEquals(Box<Expr>, Box<Expr>),
GreaterThan(Box<Expr>, Box<Expr>),
GreaterThanEquals(Box<Expr>, Box<Expr>),
LessThan(Box<Expr>, Box<Expr>),
LessThanEquals(Box<Expr>, Box<Expr>),
And(Box<Expr>, Box<Expr>),
Or(Box<Expr>, Box<Expr>),
}
impl Expr {
pub fn value(value: impl Into<Value>) -> Self {
Expr::Value(value.into())
}
pub fn func(name: String, param: Expr) -> Self {
Expr::Function(name, Box::new(param))
}
pub fn reff(name: impl ToString) -> Self {
Expr::Reference(name.to_string())
}
pub fn index(value: Expr, index: Expr) -> Self {
Expr::Index(Box::new(value), Box::new(index))
}
pub fn iif(swith: impl Into<Expr>, yes: Expr, no: Expr) -> Self {
Expr::If(Box::new(swith.into()), Box::new(yes), Box::new(no))
}
#[allow(clippy::should_implement_trait)]
pub fn not(expr: Expr) -> Self {
Expr::Not(Box::new(expr))
}
#[allow(clippy::should_implement_trait)]
pub fn neg(expr: Expr) -> Self {
Expr::Neg(Box::new(expr))
}
pub fn int(expr: Expr) -> Self {
Expr::Int(Box::new(expr))
}
pub fn float(expr: Expr) -> Self {
Expr::Float(Box::new(expr))
}
pub fn dec(expr: Expr) -> Self {
Expr::Dec(Box::new(expr))
}
pub fn mult(left: Expr, right: Expr) -> Self {
Expr::Mult(Box::new(left), Box::new(right))
}
#[allow(clippy::should_implement_trait)]
pub fn div(left: Expr, right: Expr) -> Self {
Expr::Div(Box::new(left), Box::new(right))
}
#[allow(clippy::should_implement_trait)]
pub fn add(left: Expr, right: Expr) -> Self {
Expr::Add(Box::new(left), Box::new(right))
}
#[allow(clippy::should_implement_trait)]
pub fn sub(left: Expr, right: Expr) -> Self {
Expr::Sub(Box::new(left), Box::new(right))
}
pub fn eq(left: Expr, right: Expr) -> Self {
Expr::Equals(Box::new(left), Box::new(right))
}
pub fn neq(left: Expr, right: Expr) -> Self {
Expr::NotEquals(Box::new(left), Box::new(right))
}
pub fn gt(left: Expr, right: Expr) -> Self {
Expr::GreaterThan(Box::new(left), Box::new(right))
}
pub fn gte(left: Expr, right: Expr) -> Self {
Expr::GreaterThanEquals(Box::new(left), Box::new(right))
}
pub fn lt(left: Expr, right: Expr) -> Self {
Expr::LessThan(Box::new(left), Box::new(right))
}
pub fn lte(left: Expr, right: Expr) -> Self {
Expr::LessThanEquals(Box::new(left), Box::new(right))
}
pub fn and(left: Expr, right: Expr) -> Self {
Expr::And(Box::new(left), Box::new(right))
}
pub fn or(left: Expr, right: Expr) -> Self {
Expr::Or(Box::new(left), Box::new(right))
}
}
impl From<Value> for Expr {
fn from(value: Value) -> Self {
Expr::Value(value)
}
}