haskell_match 0.1.0

data/ext/haskell_match/src/core/hs/ast.rs

@@ -0,0 +1,256 @@
+//! AST of the Haskell subset, plus rendering of patterns back to text (the
+//! Ruby code generator hands patterns to the pattern compiler as strings).
+
+use crate::core::ast::{Lit, RawPat};
+use crate::core::parser::DataDecl;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Literal {
+    Int(String),
+    Float(String),
+    Char(char),
+    Str(String),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Expr {
+    Var(String),
+    Con(String),
+    Lit(Literal),
+    App(Box<Expr>, Vec<Expr>),
+    BinOp(String, Box<Expr>, Box<Expr>),
+    Neg(Box<Expr>),
+    If(Box<Expr>, Box<Expr>, Box<Expr>),
+    Case(Box<Expr>, Vec<Alt>),
+    Let(Vec<Decl>, Box<Expr>),
+    Lambda(Vec<RawPat>, Box<Expr>),
+    List(Vec<Expr>),
+    Tuple(Vec<Expr>),
+    Range {
+        from: Box<Expr>,
+        then: Option<Box<Expr>>,
+        to: Option<Box<Expr>>,
+    },
+    Comp(Box<Expr>, Vec<Qual>),
+    /// `(e op)`
+    SectionL(String, Box<Expr>),
+    /// `(op e)`
+    SectionR(String, Box<Expr>),
+    /// `(op)`
+    OpFun(String),
+    /// MultiWayIf: `if | quals -> e | quals -> e`
+    MultiIf(Vec<(Vec<Qual>, Expr)>),
+    /// Record construction `Con { f = e, ... }`
+    RecCon(String, Vec<(String, Expr)>),
+    /// Record update `e { f = e, ... }`
+    RecUpdate(Box<Expr>, Vec<(String, Expr)>),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Qual {
+    Gen(RawPat, Expr),
+    Guard(Expr),
+    Let(Vec<Decl>),
+}
+
+/// A guarded right-hand side: each alternative is a list of qualifiers (a
+/// boolean guard, a pattern guard `p <- e`, or `let` bindings) and a body.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Rhs {
+    Plain(Expr),
+    Guarded(Vec<(Vec<Qual>, Expr)>),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Alt {
+    pub pat: RawPat,
+    pub rhs: Rhs,
+    pub wheres: Vec<Decl>,
+    pub line: usize,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Equation {
+    pub name: String,
+    pub pats: Vec<RawPat>,
+    pub rhs: Rhs,
+    pub wheres: Vec<Decl>,
+    pub line: usize,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Decl {
+    Data {
+        decl: DataDecl,
+        deriving: Vec<String>,
+        line: usize,
+    },
+    Sig {
+        names: Vec<String>,
+        arity: usize,
+        line: usize,
+    },
+    Fun(Vec<Equation>),
+    PatBind {
+        pat: RawPat,
+        rhs: Rhs,
+        wheres: Vec<Decl>,
+        line: usize,
+    },
+    /// `import [qualified] M [as A] [hiding] [(items)]`
+    Import {
+        module: String,
+        qualified: bool,
+        alias: Option<String>,
+        hiding: bool,
+        /// Named items (functions, operators, types); `None` imports everything.
+        items: Option<Vec<String>>,
+        line: usize,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Module {
+    pub name: Option<String>,
+    /// Names in the export list (functions, operators, types); `None` when
+    /// there is no list, meaning everything is exported.
+    pub exports: Option<Vec<String>>,
+    pub decls: Vec<Decl>,
+}
+
+/// Mangle a Haskell identifier into a name that is a valid Haskell *and* Ruby
+/// identifier and cannot clash with Ruby keywords or methods: `x'` → `hs_x_q`.
+pub fn mangle(name: &str) -> String {
+    let mut s = String::from("hs_");
+    for c in name.chars() {
+        if c == '\'' {
+            s.push_str("_q");
+        } else {
+            s.push(c);
+        }
+    }
+    s
+}
+
+/// Render a pattern as Haskell text with variables mangled, for the pattern
+/// compiler.
+pub fn render_pat(p: &RawPat) -> String {
+    render(p, false)
+}
+
+fn render(p: &RawPat, atomic: bool) -> String {
+    match p {
+        RawPat::Wild => "_".into(),
+        RawPat::Var(v) => mangle(v),
+        RawPat::As(v, inner) => format!("{}@{}", mangle(v), render(inner, true)),
+        RawPat::Lazy(inner) => format!("~{}", render(inner, true)),
+        RawPat::Bang(inner) => format!("!{}", render(inner, true)),
+        RawPat::Lit(l) => render_lit(l, atomic),
+        RawPat::Tuple(items) => format!(
+            "({})",
+            items
+                .iter()
+                .map(|i| render(i, false))
+                .collect::<Vec<_>>()
+                .join(", ")
+        ),
+        RawPat::List(items) => format!(
+            "[{}]",
+            items
+                .iter()
+                .map(|i| render(i, false))
+                .collect::<Vec<_>>()
+                .join(", ")
+        ),
+        RawPat::Cons(h, t) => format!("({}:{})", render(h, true), render(t, true)),
+        RawPat::Hash(fields) => format!(
+            "{{{}}}",
+            fields
+                .iter()
+                .map(|(k, p)| format!("{} = {}", k, render(p, false)))
+                .collect::<Vec<_>>()
+                .join(", ")
+        ),
+        RawPat::Con(name, args) if name.starts_with(':') => {
+            if args.len() == 2 {
+                format!(
+                    "({} {} {})",
+                    render(&args[0], true),
+                    name,
+                    render(&args[1], true)
+                )
+            } else if args.is_empty() {
+                format!("({})", name)
+            } else {
+                format!(
+                    "(({}) {})",
+                    name,
+                    args.iter()
+                        .map(|a| render(a, true))
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                )
+            }
+        }
+        RawPat::Con(name, args) => {
+            if args.is_empty() {
+                name.clone()
+            } else {
+                let s = format!(
+                    "{} {}",
+                    name,
+                    args.iter()
+                        .map(|a| render(a, true))
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                );
+                if atomic {
+                    format!("({})", s)
+                } else {
+                    s
+                }
+            }
+        }
+        RawPat::Record(name, fields, rest) => {
+            let mut parts: Vec<String> = fields
+                .iter()
+                .map(|(f, p)| format!("{} = {}", f, render(p, false)))
+                .collect();
+            if *rest {
+                parts.push("..".into());
+            }
+            format!("{} {{{}}}", name, parts.join(", "))
+        }
+    }
+}
+
+fn render_lit(l: &Lit, atomic: bool) -> String {
+    let s = l.to_string();
+    let negative = s.starts_with('-');
+    if negative && atomic {
+        format!("({})", s)
+    } else {
+        s
+    }
+}
+
+/// Variables bound by a pattern, in order of appearance (unmangled).
+pub fn pat_vars(p: &RawPat, out: &mut Vec<String>) {
+    match p {
+        RawPat::Wild | RawPat::Lit(_) => {}
+        RawPat::Var(v) => out.push(v.clone()),
+        RawPat::As(v, inner) => {
+            out.push(v.clone());
+            pat_vars(inner, out);
+        }
+        RawPat::Lazy(inner) | RawPat::Bang(inner) => pat_vars(inner, out),
+        RawPat::Tuple(items) | RawPat::List(items) => items.iter().for_each(|i| pat_vars(i, out)),
+        RawPat::Cons(h, t) => {
+            pat_vars(h, out);
+            pat_vars(t, out);
+        }
+        RawPat::Con(_, args) => args.iter().for_each(|a| pat_vars(a, out)),
+        RawPat::Record(_, fields, _) => fields.iter().for_each(|(_, p)| pat_vars(p, out)),
+        RawPat::Hash(fields) => fields.iter().for_each(|(_, p)| pat_vars(p, out)),
+    }
+}

data/ext/haskell_match/src/core/hs/json.rs

@@ -0,0 +1,225 @@
+//! JSON serialisation of the AST for the Ruby code generator.
+
+use super::ast::*;
+use crate::core::ast::RawPat;
+
+fn esc(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() + 2);
+    out.push('"');
+    for c in s.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+    out
+}
+
+fn arr(items: Vec<String>) -> String {
+    format!("[{}]", items.join(","))
+}
+
+fn pat(p: &RawPat) -> String {
+    let mut vars = Vec::new();
+    pat_vars(p, &mut vars);
+    format!(
+        "{{\"text\":{},\"vars\":{}}}",
+        esc(&render_pat(p)),
+        arr(vars.iter().map(|v| esc(v)).collect())
+    )
+}
+
+fn literal(l: &Literal) -> String {
+    match l {
+        Literal::Int(s) => format!("[\"int\",{}]", esc(s)),
+        Literal::Float(s) => format!("[\"float\",{}]", esc(s)),
+        Literal::Char(c) => format!("[\"char\",{}]", esc(&c.to_string())),
+        Literal::Str(s) => format!("[\"str\",{}]", esc(s)),
+    }
+}
+
+pub fn expr(e: &Expr) -> String {
+    match e {
+        Expr::Var(v) => format!("[\"var\",{}]", esc(v)),
+        Expr::RecCon(c, fields) => format!(
+            "[\"reccon\",{},{}]",
+            esc(c),
+            arr(fields.iter().map(field_bind).collect())
+        ),
+        Expr::RecUpdate(e, fields) => format!(
+            "[\"recupd\",{},{}]",
+            expr(e),
+            arr(fields.iter().map(field_bind).collect())
+        ),
+        Expr::Con(c) => format!("[\"con\",{}]", esc(c)),
+        Expr::Lit(l) => format!("[\"lit\",{}]", literal(l)),
+        Expr::App(f, args) => format!(
+            "[\"app\",{},{}]",
+            expr(f),
+            arr(args.iter().map(expr).collect())
+        ),
+        Expr::BinOp(op, l, r) => format!("[\"op\",{},{},{}]", esc(op), expr(l), expr(r)),
+        Expr::Neg(x) => format!("[\"neg\",{}]", expr(x)),
+        Expr::If(c, t, f) => format!("[\"if\",{},{},{}]", expr(c), expr(t), expr(f)),
+        Expr::Case(s, alts) => format!(
+            "[\"case\",{},{}]",
+            expr(s),
+            arr(alts.iter().map(alt).collect())
+        ),
+        Expr::Let(decls, body) => format!(
+            "[\"let\",{},{}]",
+            arr(decls.iter().map(decl).collect()),
+            expr(body)
+        ),
+        Expr::Lambda(pats, body) => format!(
+            "[\"lam\",{},{}]",
+            arr(pats.iter().map(pat).collect()),
+            expr(body)
+        ),
+        Expr::List(items) => format!("[\"list\",{}]", arr(items.iter().map(expr).collect())),
+        Expr::Tuple(items) => format!("[\"tuple\",{}]", arr(items.iter().map(expr).collect())),
+        Expr::Range { from, then, to } => format!(
+            "[\"range\",{},{},{}]",
+            expr(from),
+            then.as_ref()
+                .map(|t| expr(t))
+                .unwrap_or_else(|| "null".into()),
+            to.as_ref()
+                .map(|t| expr(t))
+                .unwrap_or_else(|| "null".into())
+        ),
+        Expr::Comp(body, quals) => format!(
+            "[\"comp\",{},{}]",
+            expr(body),
+            arr(quals.iter().map(qual).collect())
+        ),
+        Expr::SectionL(op, x) => format!("[\"section_l\",{},{}]", esc(op), expr(x)),
+        Expr::SectionR(op, x) => format!("[\"section_r\",{},{}]", esc(op), expr(x)),
+        Expr::OpFun(op) => format!("[\"opfun\",{}]", esc(op)),
+        Expr::MultiIf(arms) => format!(
+            "[\"multiif\",{}]",
+            arr(arms.iter().map(guarded_arm).collect())
+        ),
+    }
+}
+
+fn field_bind((f, e): &(String, Expr)) -> String {
+    format!("[{},{}]", esc(f), expr(e))
+}
+
+fn guarded_arm((quals, e): &(Vec<Qual>, Expr)) -> String {
+    format!("[{},{}]", arr(quals.iter().map(qual).collect()), expr(e))
+}
+
+fn qual(q: &Qual) -> String {
+    match q {
+        Qual::Gen(p, e) => format!("[\"gen\",{},{}]", pat(p), expr(e)),
+        Qual::Guard(e) => format!("[\"guard\",{}]", expr(e)),
+        Qual::Let(ds) => format!("[\"let\",{}]", arr(ds.iter().map(decl).collect())),
+    }
+}
+
+fn rhs(r: &Rhs) -> String {
+    match r {
+        Rhs::Plain(e) => format!("{{\"body\":{}}}", expr(e)),
+        Rhs::Guarded(gs) => format!(
+            "{{\"guards\":{}}}",
+            arr(gs.iter().map(guarded_arm).collect())
+        ),
+    }
+}
+
+fn alt(a: &Alt) -> String {
+    format!(
+        "{{\"pat\":{},\"rhs\":{},\"where\":{},\"line\":{}}}",
+        pat(&a.pat),
+        rhs(&a.rhs),
+        arr(a.wheres.iter().map(decl).collect()),
+        a.line
+    )
+}
+
+fn equation(e: &Equation) -> String {
+    format!(
+        "{{\"pats\":{},\"rhs\":{},\"where\":{},\"line\":{}}}",
+        arr(e.pats.iter().map(pat).collect()),
+        rhs(&e.rhs),
+        arr(e.wheres.iter().map(decl).collect()),
+        e.line
+    )
+}
+
+pub fn decl(d: &Decl) -> String {
+    match d {
+        Decl::Data { decl, deriving, line } => format!(
+            "{{\"kind\":\"data\",\"name\":{},\"tyvars\":{},\"cons\":{},\"deriving\":{},\"line\":{}}}",
+            esc(&decl.name),
+            arr(decl.tyvars.iter().map(|v| esc(v)).collect()),
+            arr(decl
+                .cons
+                .iter()
+                .map(|c| format!(
+                    "{{\"name\":{},\"arity\":{},\"fields\":{}}}",
+                    esc(&c.name),
+                    c.arity,
+                    c.fields.as_ref().map(|fs| arr(fs.iter().map(|f| esc(f)).collect())).unwrap_or_else(|| "null".into())
+                ))
+                .collect()),
+            arr(deriving.iter().map(|v| esc(v)).collect()),
+            line
+        ),
+        Decl::Sig { names, arity, line } => format!(
+            "{{\"kind\":\"sig\",\"names\":{},\"arity\":{},\"line\":{}}}",
+            arr(names.iter().map(|v| esc(v)).collect()),
+            arity,
+            line
+        ),
+        Decl::Fun(eqs) => format!(
+            "{{\"kind\":\"fun\",\"name\":{},\"arity\":{},\"equations\":{},\"line\":{}}}",
+            esc(&eqs[0].name),
+            eqs[0].pats.len(),
+            arr(eqs.iter().map(equation).collect()),
+            eqs[0].line
+        ),
+        Decl::PatBind { pat: p, rhs: r, wheres, line } => format!(
+            "{{\"kind\":\"bind\",\"pat\":{},\"rhs\":{},\"where\":{},\"line\":{}}}",
+            pat(p),
+            rhs(r),
+            arr(wheres.iter().map(decl).collect()),
+            line
+        ),
+        Decl::Import { module, qualified, alias, hiding, items, line } => format!(
+            "{{\"kind\":\"import\",\"module\":{},\"qualified\":{},\"as\":{},\"hiding\":{},\"items\":{},\"line\":{}}}",
+            esc(module),
+            qualified,
+            alias.as_ref().map(|a| esc(a)).unwrap_or_else(|| "null".into()),
+            hiding,
+            items
+                .as_ref()
+                .map(|is| arr(is.iter().map(|i| esc(i)).collect()))
+                .unwrap_or_else(|| "null".into()),
+            line
+        ),
+    }
+}
+
+pub fn module(m: &Module) -> String {
+    format!(
+        "{{\"name\":{},\"exports\":{},\"decls\":{}}}",
+        m.name
+            .as_ref()
+            .map(|n| esc(n))
+            .unwrap_or_else(|| "null".into()),
+        m.exports
+            .as_ref()
+            .map(|es| arr(es.iter().map(|e| esc(e)).collect()))
+            .unwrap_or_else(|| "null".into()),
+        arr(m.decls.iter().map(decl).collect())
+    )
+}