refactor repr/transpile names

1 files changed, 0 insertions, 99 deletions

diff --git a/src/transpile_latex.rs b/src/transpile_latex.rs
deleted file mode 100644
index 1c777d2..0000000
--- a/src/transpile_latex.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-
-extern crate modelica_parser;
-
-use self::modelica_parser::*;
-use errors::Result;
-
-pub trait TranspileLaTeX {
-    fn repr_latex(&self) -> Result<String>;
-}
-
-
-impl TranspileLaTeX for ModelicaModel {
-    fn repr_latex(&self) -> Result<String> {
-
-        let mut result = r#"\begin{array}{rcl}"#.to_string() + "\n";
-
-        for eq in &self.equations {
-            result += &format!("  {} & = & {} \\\\\n",
-                try!(eq.lhs.repr_latex()),
-                try!(eq.rhs.repr_latex()));
-        }
-        result += "\n";
-        result += r#"\end{array}"#;
-        Ok(result)
-    }
-}
-
-fn is_latexy_ident(s: &str) -> bool {
-    let latexy_idents = [
-        "alpha", "Alpha", "beta", "gamma", "Gamma", "delta", "Delta",
-        "epsilon", "zeta", "eta", "theta", "Theta", "iota", "kappa", "lambda",
-        "Lambda", "mu", "nu", "xi", "Xi", "omicron", "pi", "Pi", "rho",
-        "sigma", "Sigma", "tau", "upsilon", "phi", "Phi", "chi", "psi", "Psi",
-        "omega", "Omega"];
-    latexy_idents.contains(&s)
-}
-
-impl TranspileLaTeX for Expr {
-    fn repr_latex(&self) -> Result<String> {
-        use modelica_parser::Expr::*;
-        use modelica_parser::MathUnaryFunc::*;
-        use modelica_parser::BinOperator::*;
-        match *self {
-            Integer(e) => Ok(format!("{}", e)),
-            Float(e) => Ok(format!("{}", e)),
-            Boolean(true) => Ok(format!("true")),
-            Boolean(false) => Ok(format!("false")),
-            StringLiteral(ref s) => Ok(format!("\\text{{ {} }}", s)),
-            // Tries to do script for simple cases ("M_1")
-            Ident(ref e) => {
-                if e.contains('_') {
-                    let split: Vec<&str> = e.splitn(2, '_').collect();
-                    Ok(format!(r"{}{}_{{ {}{} }}",
-                        if is_latexy_ident(split[0]) { "\\" } else { "" },
-                        split[0],
-                        if is_latexy_ident(split[1]) { "\\" } else { "" },
-                        split[1]))
-                } else {
-                    Ok(format!("{}{}",
-                        if is_latexy_ident(e) { "\\" } else { "" },
-                        e))
-                }
-            },
-            // Treate simple derivatives (common case) differently from complex
-            // (destructuring with 'box' keyword is still unstable)
-            Der(ref e) =>
-                if let &Ident(_) = e.as_ref() {
-                    Ok(format!("\\frac{{ d {} }}{{ dt }}", try!(e.repr_latex())))
-                } else {
-                    Ok(format!("\\frac{{ d }}{{ dt }} {}", try!(e.repr_latex())))
-                },
-            Sign(ref e) => Ok(format!("\\sign{{ {} }}", try!(e.repr_latex()))),
-            // LaTeX depends on the unary
-            MathUnaryExpr(Abs, ref e) => Ok(format!("\\left\\|{}\\right\\|", try!(e.repr_latex()))),
-            MathUnaryExpr(Sqrt, ref e) => Ok(format!("\\sqrt{{ {} }}", try!(e.repr_latex()))),
-            MathUnaryExpr(Log10, ref e) => Ok(format!("\\log_{{10}}{{ {} }} ", try!(e.repr_latex()))),
-            MathUnaryExpr(func, ref e) => Ok(format!("\\{:?}{{ {} }}", func, try!(e.repr_latex()))),
-            // LaTeX depends on binexpr
-            BinExpr(Divide, ref l, ref r) => 
-                Ok(format!("\\frac{{ {} }}{{ {} }}",
-                        try!(l.repr_latex()),
-                        try!(r.repr_latex()))),
-            BinExpr(Multiply, ref l, ref r) =>
-                Ok(format!("{} \\cdot {}",
-                        try!(l.repr_latex()),
-                        try!(r.repr_latex()))),
-            BinExpr(Exponentiate, ref l, ref r) =>
-                Ok(format!("{}^{{ {} }}",
-                        try!(l.repr_latex()),
-                        try!(r.repr_latex()))),
-            BinExpr(op, ref l, ref r) =>
-                Ok(format!("\\left({} {:?} {}\\right)",
-                        try!(l.repr_latex()),
-                        op,
-                        try!(r.repr_latex()))),
-            Array(_) => unimplemented!(),
-        }
-    }
-}