9 files changed, 12 insertions(+), 20 deletions(-)

M src/abase.rs
M src/ast.rs
M src/base.rs
M src/desugar.rs
M src/eval.rs
M src/fem.rs
M src/main.rs
M src/parse.rs
M src/resolve.rs

@@ 4,7 4,6 @@ use crate::fem;
 pub fn abase(expr: &fem::Expr) -> anyhow::Result<Expr> {
     Ok(match *expr {
         fem::Expr::F64(x) => Expr::F64(x),
-        fem::Expr::I64(x) => Expr::I64(x),
         fem::Expr::App(ref f, ref xs) => match **f {
             fem::Expr::Var(ref x) if x.to_string() == "+.builtin." =>
                 Expr::Add(Box::new(abase(&xs[0])?), Box::new(abase(&xs[1])?)),

@@ 17,7 17,6 @@ pub struct Module<N> {
 #[derive(Debug, PartialEq)]
 pub enum Expr<N> {
     F64(f64),
-    I64(i64),
     App(Box<Expr<N>>, Vec<Expr<N>>),
     Var(N),
 }

@@ 3,7 3,6 @@
 #[derive(Clone)]
 pub enum Expr {
     F64(f64),
-    I64(i64),
     Add(Box<Expr>, Box<Expr>),
     Mul(Box<Expr>, Box<Expr>),
 }

@@ 4,7 4,6 @@ use crate::fem::*;
 pub fn desugar(expr: &ast::RExpr) -> anyhow::Result<Expr> {
     Ok(match expr {
         ast::Expr::F64(x) => Expr::F64(*x),
-        ast::Expr::I64(x) => Expr::I64(*x),
         ast::Expr::Var(x) => Expr::Var(x.clone()),
         ast::Expr::App(f, xs) =>
             Expr::App(Box::new(desugar(f)?), xs.iter().map(|x| desugar(x)).collect::<Result<_, _>>()?),

@@ 7,7 7,6 @@ pub fn run<'c>(cache: &'c mut Cache, entrypoint: &FullQualName) -> anyhow::Resul
 pub fn interpret(cache: &mut Cache, expr: &base::Expr) -> anyhow::Result<Val> {
     Ok(match *expr {
         base::Expr::F64(x) => Val::F64(x),
-        base::Expr::I64(x) => Val::F64(x as f64),
         base::Expr::Add(ref x, ref y) => match (interpret(cache, x)?, interpret(cache, y)?) {
             (Val::F64(x), Val::F64(y)) => Val::F64(x + y),
         },

@@ 11,7 11,6 @@ pub struct Module {
 #[derive(Clone, Debug, PartialEq)]
 pub enum Expr {
     F64(f64),
-    I64(i64),
     Var(FullQualName),
     App(Box<Expr>, Vec<Expr>),
 }

@@ 55,11 55,11 @@ mod test {
 
     #[test]
     fn test_main_arithm1() {
-        assert_eq!(run_tmp("(def main (+ 1 2))").unwrap(), Val::F64(3.0))
+        assert_eq!(run_tmp("(def main (+ 1.0 2.0))").unwrap(), Val::F64(3.0))
     }
 
     #[test]
     fn test_main_arithm2() {
-        assert_eq!(run_tmp("(def main (+ (* 13 100) 37))").unwrap(), Val::F64(1337.0))
+        assert_eq!(run_tmp("(def main (+ (* 13.0 100.0) 37.0))").unwrap(), Val::F64(1337.0))
     }
 }

@@ 89,9 89,8 @@ fn def<'s: 't, 't>(inp: Inp<'s, 't>) -> Res<'s, 't, (ItemName, PExpr)> {
 
 fn expr<'s: 't, 't>(inp: Inp<'s, 't>) -> Res<'s, 't, PExpr> {
     // TODO
-    alt4(
+    alt3(
         map(lit_float, Expr::F64),
-        map(lit_int, Expr::I64),
         map(name, Expr::Var),
         map(parens(pair(expr, rest(expr))), |(f, xs)| Expr::App(Box::new(f), xs)),
     )(inp)


@@ 127,12 126,12 @@ fn lit_float<'s: 't, 't>(inp: Inp<'s, 't>) -> Res<'s, 't, f64> {
     })
 }
 
-fn lit_int<'s: 't, 't>(inp: Inp<'s, 't>) -> Res<'s, 't, i64> {
-    inp.filter_next(|tok| match *tok {
-        Tok::Int(x) => Ok(x),
-        _ => Err("*integer literal*"),
-    })
-}
+// fn lit_int<'s: 't, 't>(inp: Inp<'s, 't>) -> Res<'s, 't, i64> {
+//     inp.filter_next(|tok| match *tok {
+//         Tok::Int(x) => Ok(x),
+//         _ => Err("*integer literal*"),
+//     })
+// }
 
 fn parens<'s: 't, 't, A>(mut f: impl Parser<'s, 't, A>) -> impl Parser<'s, 't, A> {
     move |inp| {


@@ 263,12 262,12 @@ mod test {
 
     #[test]
     fn test_arithm() {
-        let m = parse(None, &lex(None, "(def x (+ 1 2))").unwrap()).unwrap();
+        let m = parse(None, &lex(None, "(def x (+ 1.0 2.0))").unwrap()).unwrap();
         assert_matches!(
             &m.defs["x"],
             Expr::App(f, xs) if **f == Expr::Var(ParsedName::unqualified("+"))
-                             && xs[0] == Expr::I64(1)
-                             && xs[1] == Expr::I64(2)
+                             && xs[0] == Expr::F64(1.0)
+                             && xs[1] == Expr::F64(2.0)
         )
     }
 }

@@ 14,7 14,6 @@ pub fn resolve_expr(expr: PExpr) -> anyhow::Result<RExpr> {
     use Expr::*;
     Ok(match expr {
         F64(x) => F64(x),
-        I64(x) => I64(x),
         Var(x) => Var(match x {
             // FIXME
             ParsedName { root: None, prefix, name } => FullQualName {