a.hlm

@@ -1,9 +1,5 @@
-func add x: num -> num = x + 1;
+println({
-
-println(
-    {
     println("Hello");
     return let x: num = 17 * 2 in
-            add(x);
+        x + 1;
-    } + 34
+} + 34);
-);

src/asts/mod.rs

@@ -1,3 +0,0 @@
-pub mod past;
-pub mod ast;
-pub mod js;

src/main.rs

@@ -1,5 +1,4 @@
 #![feature(trait_alias)]
-pub mod asts;
 pub mod read;
 pub mod trans;
 pub mod args;
@@ -8,7 +7,7 @@ use std::io::Write;
 use args::Options;
 use read::parse::{lex, parse};
 use structopt::StructOpt;
-use trans::low::{translate_stmt, translate_js_stmt};
+use trans::low::{translate_expr, translate_js};
 
 fn main() {
     let opt = Options::from_args();
@@ -17,15 +16,15 @@ fn main() {
     let (tokens, lex_errs) = lex(src.to_owned());
 
     let parse_errs = if let Some(tokens) = tokens {
-        let (past, parse_errs) = parse(tokens, src.len());
+        let (ast, parse_errs) = parse(tokens, src.len());
 
-        if let Some(past) = past {
+        if let Some(ast) = ast {
-            let ast = past.into_iter().map(|(e, _)| translate_stmt(e)).collect::<Vec<_>>();
+            let nexprs = ast.into_iter().map(|(e, _)| translate_expr(e)).collect::<Vec<_>>();
-            let js = ast.into_iter().map(translate_js_stmt).collect::<Vec<_>>();
+            let jsexprs = nexprs.into_iter().map(translate_js).collect::<Vec<_>>();
 
             let mut file = std::fs::File::create(opt.output.unwrap_or("out.js".into()))
                 .expect("Failed to create file");
-            let s = js
+            let s = jsexprs
                 .into_iter()
                 .map(|e| {
                     let s = format!("{}", e);

src/read/mod.rs

@@ -1 +1,2 @@
 pub mod parse;
+pub mod past;

src/read/parse.rs

@@ -3,7 +3,7 @@ use chumsky::{prelude::*, Stream};
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use crate::trans::ty::Type;
 
-use crate::asts::past::*;
+use super::past::*;
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Delim { Paren, Brack, Brace }
@@ -442,44 +442,11 @@ pub fn exprs_parser() -> impl P<Vec<Spanned<PExpr>>> {
         .repeated()
 }
 
-pub fn stmt_parser() -> impl P<Spanned<PStmt>> {
-    let func = just(Token::Func)
-        .ignore_then(symbol_parser())
-        .then(
-            symbol_parser()
-            .then_ignore(just(Token::Colon))
-            .then(type_parser())
-            .separated_by(just(Token::Comma))
-        )
-        .then_ignore(just(Token::Arrow))
-        .then(type_parser())
-        .then_ignore(just(Token::Assign))
-        .then(expr_parser().map(Box::new))
-        .map(|(((name, args), ret), body)| PStmt::Func {
-            name,
-            args,
-            ret,
-            body,
-        });
-
-    let expr = expr_parser().map(PStmt::Expr);
-
-    func
-    .or(expr)
-    .map_with_span(|s, span| (s, span))
-}
-
-pub fn stmts_parser() -> impl P<Vec<Spanned<PStmt>>> {
-    stmt_parser()
-        .then_ignore(just(Token::Semicolon))
-        .repeated()
-}
-
 pub fn parse(
     tokens: Vec<Spanned<Token>>,
     len: usize,
-) -> (Option<Vec<Spanned<PStmt>>>, Vec<Simple<Token>>) {
+) -> (Option<Vec<Spanned<PExpr>>>, Vec<Simple<Token>>) {
-    let (ast, parse_error) = stmts_parser()
+    let (ast, parse_error) = exprs_parser()
     .then_ignore(end())
     .parse_recovery(Stream::from_iter(len..len + 1, tokens.into_iter()));
 

src/read/past.rs

@@ -1,6 +1,6 @@
 use crate::trans::ty::*;
 
-use crate::read::parse::Spanned;
+use super::parse::Spanned;
 
 #[derive(Clone, Debug)]
 pub enum PUnaryOp {
@@ -49,7 +49,6 @@ pub enum PStmt {
     Func {
         name: String,
         args: Vec<(String, Type)>,
-        ret: Type,
         body: Box<Spanned<PExpr>>,
     },
 }

src/trans/ast.rs

@@ -1,5 +1,5 @@
 use std::fmt::{Display, Formatter, Result as FmtResult};
-use crate::trans::ty::Type;
+use super::ty::Type;
 
 #[derive(Clone, Debug)]
 pub enum UnaryOp {
@@ -37,18 +37,6 @@ pub enum Expr {
     Return(Box<Self>),
 }
 
-#[derive(Clone, Debug)]
-pub enum Stmt {
-    Expr(Expr),
-    Let(Vec<(String, Type, Expr)>),
-    Func {
-        name: String,
-        args: Vec<(String, Type)>,
-        ret: Type,
-        body: Expr,
-    },
-}
-
 impl Display for Expr {
     fn fmt(&self, f: &mut Formatter) -> FmtResult {
         match self {
@@ -96,25 +84,3 @@ impl Display for Expr {
         }
     }
 }
-
-impl Display for Stmt {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
-        match self {
-            Stmt::Expr(e) => write!(f, "{}", e),
-            Stmt::Let(vars) => {
-                write!(f, "(let")?;
-                for (name, ty, e) in vars {
-                    write!(f, " [{} {} {}]", name, ty, e)?;
-                }
-                write!(f, ")")
-            },
-            Stmt::Func { name, args, ret, body } => {
-                write!(f, "(defn {} [", name)?;
-                for (name, ty) in args {
-                    write!(f, "[{} {}]", name, ty)?;
-                }
-                write!(f, "] {} {})", ret, body)
-            },
-        }
-    }
-}

src/trans/js.rs

@@ -1,5 +1,5 @@
 use std::fmt::{Display, Formatter, Result as FmtResult};
-use crate::trans::ty::Type;
+use super::ty::Type;
 
 #[derive(Clone, Debug)]
 pub enum JSLiteral { Num(i64), Str(String), Bool(bool) }
@@ -22,18 +22,6 @@ pub enum JSExpr {
     Return(Box<Self>),
 }
 
-#[derive(Clone, Debug)]
-pub enum JSStmt {
-    Expr(JSExpr),
-    Let(Vec<(String, Type, JSExpr)>),
-    Func {
-        name: String,
-        args: Vec<(String, Type)>,
-        ret: Type,
-        body: JSExpr,
-    },
-}
-
 impl Display for JSExpr {
     fn fmt(&self, f: &mut Formatter) -> FmtResult {
         match self {
@@ -102,32 +90,3 @@ impl Display for JSExpr {
         }
     }
 }
-
-impl Display for JSStmt {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
-        match self {
-            JSStmt::Expr(e) => write!(f, "{}", e),
-            JSStmt::Let(vars) => {
-                write!(f, "let ")?;
-                for (i, (name, _ty, e)) in vars.iter().enumerate() {
-                    if i > 0 {
-                        write!(f, ", ")?;
-                    }
-                    write!(f, "{} = {}", name, e)?;
-                }
-                write!(f, ";")
-            },
-            JSStmt::Func { name, args, ret: _, body } => {
-                // const name = (args) => body;
-                write!(f, "const {} = (", name)?;
-                for (i, (name, _ty)) in args.iter().enumerate() {
-                    if i > 0 {
-                        write!(f, ", ")?;
-                    }
-                    write!(f, "{}", name)?;
-                }
-                write!(f, ") => {};", body)
-            },
-        }
-    }
-}

src/trans/low.rs

@@ -1,22 +1,9 @@
-use crate::asts::{
+use crate::read::past::{PExpr, PLiteral, PBinaryOp, PUnaryOp};
-    past::*,
+use super::{
-    ast::*,
+    ast::{Expr, Literal, BinaryOp, UnaryOp},
-    js::*,
+    js::{JSExpr, JSLiteral},
 };
 
-pub fn translate_stmt(stmt: PStmt) -> Stmt {
-    match stmt {
-        PStmt::Expr(e) => Stmt::Expr(translate_expr(e.0)),
-        PStmt::Let(vars) => todo!(),
-        PStmt::Func { name, args, ret, body } => Stmt::Func {
-            name,
-            args,
-            ret,
-            body: translate_expr(body.0),
-        },
-    }
-}
-
 pub fn translate_expr(expr: PExpr) -> Expr {
     match expr {
         PExpr::Error => panic!("Error in expression!"),
@@ -90,20 +77,7 @@ pub fn translate_expr(expr: PExpr) -> Expr {
     }
 }
 
-pub fn translate_js_stmt(stmt: Stmt) -> JSStmt {
+pub fn translate_js(expr: Expr) -> JSExpr {
-    match stmt {
-        Stmt::Expr(e) => JSStmt::Expr(translate_js_expr(e)),
-        Stmt::Let(vars) => todo!(),
-        Stmt::Func { name, args, ret, body } => JSStmt::Func {
-            name,
-            args,
-            ret,
-            body: translate_js_expr(body),
-        },
-    }
-}
-
-pub fn translate_js_expr(expr: Expr) -> JSExpr {
     match expr {
         Expr::Lit(l) => match l {
             Literal::Num(n)  => JSExpr::Lit(JSLiteral::Num(n)),
@@ -111,12 +85,12 @@ pub fn translate_js_expr(expr: Expr) -> JSExpr {
             Literal::Bool(b) => JSExpr::Lit(JSLiteral::Bool(b)),
         },
         Expr::Sym(s) => JSExpr::Sym(s),
-        Expr::Vec(v) => JSExpr::Array(v.into_iter().map(translate_js_expr).collect()),
+        Expr::Vec(v) => JSExpr::Array(v.into_iter().map(translate_js).collect()),
 
         Expr::UnaryOp(op, e) => JSExpr::Op(match op {
             UnaryOp::Neg => "-",
             UnaryOp::Not => "!",
-        }, Box::new(translate_js_expr(*e)), None),
+        }, Box::new(translate_js(*e)), None),
         Expr::BinaryOp(op, e1, e2) => JSExpr::Op(match op {
             BinaryOp::Add => "+",
             BinaryOp::Sub => "-",
@@ -133,7 +107,7 @@ pub fn translate_js_expr(expr: Expr) -> JSExpr {
 
             BinaryOp::And => "&&",
             BinaryOp::Or  => "||",
-        }, Box::new(translate_js_expr(*e1)), Some(Box::new(translate_js_expr(*e2)))),
+        }, Box::new(translate_js(*e1)), Some(Box::new(translate_js(*e2)))),
 
         Expr::Call(f, args) => {
             match *f {
@@ -143,25 +117,25 @@ pub fn translate_js_expr(expr: Expr) -> JSExpr {
                             JSExpr::Method(
                                 Box::new(JSExpr::Sym("console".to_string())),
                                 "log".to_string(),
-                                args.into_iter().map(translate_js_expr).collect(),
+                                args.into_iter().map(translate_js).collect(),
                             )
                         },
                         _ => JSExpr::Call(
-                            Box::new(translate_js_expr(*f)),
+                            Box::new(translate_js(*f)),
-                            args.into_iter().map(translate_js_expr).collect(),
+                            args.into_iter().map(translate_js).collect(),
                         ),
                     }
                 },
                 _ => JSExpr::Call(
-                    Box::new(translate_js_expr(*f)),
+                    Box::new(translate_js(*f)),
-                    args.into_iter().map(translate_js_expr).collect(),
+                    args.into_iter().map(translate_js).collect(),
                 ),
             }
         }
         Expr::Lambda { args, body } => JSExpr::Lambda {
             args,
-            body: body.into_iter().map(translate_js_expr).collect(),
+            body: body.into_iter().map(translate_js).collect(),
         },
-        Expr::Return(e) => JSExpr::Return(Box::new(translate_js_expr(*e))),
+        Expr::Return(e) => JSExpr::Return(Box::new(translate_js(*e))),
     }
 }

src/trans/mod.rs

@@ -1,2 +1,4 @@
 pub mod ty;
+pub mod ast;
+pub mod js;
 pub mod low;