///////////////////  Expression Trees in Rust, Again  //////////
#![allow(dead_code)]
#![allow(non_snake_case)]
#![allow(unused_variables)]
#![allow(unused_parens)]
#![allow(non_camel_case_types)]
use crate::E2::*;    
//use std::rc::Rc;
use std::ops::Deref;
use std::fmt::{Display,Formatter,Result};

#[derive(Clone)]
enum E2<'t>
{
   Val(i32),
   Plus(&'t E2<'t>,&'t E2<'t>),
   Times(&'t E2<'t>,&'t E2<'t>),
   Neg(&'t E2<'t>),
}

const MAXSIZE:usize = 4096*1024; // 4M nodes
const Nodes:Vec<E2> = Vec::new(); // const is for pointer

fn newval(x:i32) -> usize
  {
     Nodes.push(Val(x));
     Nodes.len()-1
  }
/*
fn newplus(l:usize, r:usize) -> usize
  {
    Nodes.push(Plus(lf,rt));
    Nodes.len()-1
  }

  fn newtimes(&'static mut self, l:usize, r:usize) -> usize
  {
    self.nodes.push(Times(&self.nodes[l],&self.nodes[r]));
    self.nodes.len()-1
  }
  fn newneg(&'static mut self, s:usize) -> usize
  {
    self.nodes.push(Neg(&self.nodes[s]));
    self.nodes.len()-1
  }
*/



struct Exprtree<'t>
{
   nodes:Vec<E2<'t>>
}
impl<'t> Exprtree<'t>
{
  fn new() -> Exprtree<'t>
  { Exprtree { nodes:Vec::new() } }
  fn newcap(n:usize) -> Exprtree<'t>
  {
    let vn = Vec::with_capacity(n);
    Exprtree { nodes:vn }
  }

}// imple Exprtree


/*
impl Deref for Expr
{
   type Target = Expr;
   fn deref(&self) -> &Target
   {
      match self {
         Plus(x,y) => Plus(
         _ => self
      }
   }//deref
}// imple Deref
*/

fn eval(e:&E2) -> i32
{
   match *e {
     Val(x) => x,  // x is a ref because e is
     Plus(x,y) => eval(x) + eval(y), // deref coercion works nicely here
     Times(x,y) => eval(x) * eval(y),
     Neg(x) => -1 * eval(x),
   }//match
}//eval


impl<'t> Display for E2<'t>
{
    fn fmt(&self, f: &mut Formatter<'_>) -> Result  // required by trait
    {
       match self {
         Val(x) => write!(f,"{}",x),
	 Plus(x,y) => write!(f,"({}+{})",x,y),
	 Times(x,y) => write!(f,"{}*{}",x,y),
         Neg(Neg(x)) => write!(f,"{}",x),
	 Neg(x) => write!(f,"-{}",x),
       }//match
    }
}// impl Display for E2



/////////////////////// main
fn main()
{
    // keep in global vector?
    let (v1,v2,v3) = (&Val(2), &Val(3), &Val(5));
    let ref e1 = Times(v2,v3);
    let ref e2 = Plus(v1,e1);
    let ref e3 = Neg(e2);
    let ref e4 = Neg(e3);
    println!("value of {} is {}",e3,eval(e3));
    println!("value of {} is {}",e4,eval(e4));
}//main