oxilean_codegen/haskell_backend/
haskellexpr_traits.rs

1//! # HaskellExpr - Trait Implementations
2//!
3//! This module contains trait implementations for `HaskellExpr`.
4//!
5//! ## Implemented Traits
6//!
7//! - `Display`
8//!
9//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
10
11use crate::lcnf::*;
12
13use super::types::{HaskellDoStmt, HaskellExpr, HsListQual};
14use std::fmt;
15
16impl fmt::Display for HaskellExpr {
17    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18        match self {
19            HaskellExpr::Lit(lit) => write!(f, "{}", lit),
20            HaskellExpr::Var(v) => write!(f, "{}", v),
21            HaskellExpr::App(func, args) => {
22                write!(f, "({}", func)?;
23                for a in args {
24                    write!(f, " {}", a)?;
25                }
26                write!(f, ")")
27            }
28            HaskellExpr::Lambda(pats, body) => {
29                write!(f, "(\\")?;
30                for (i, p) in pats.iter().enumerate() {
31                    if i > 0 {
32                        write!(f, " ")?;
33                    }
34                    write!(f, "{}", p)?;
35                }
36                write!(f, " -> {})", body)
37            }
38            HaskellExpr::Let(name, val, body) => {
39                write!(f, "(let {} = {} in {})", name, val, body)
40            }
41            HaskellExpr::Where(expr, _defs) => write!(f, "{}", expr),
42            HaskellExpr::If(cond, then_e, else_e) => {
43                write!(f, "(if {} then {} else {})", cond, then_e, else_e)
44            }
45            HaskellExpr::Case(scrut, alts) => {
46                write!(f, "(case {} of {{ ", scrut)?;
47                for (i, alt) in alts.iter().enumerate() {
48                    if i > 0 {
49                        write!(f, "; ")?;
50                    }
51                    write!(f, "{}", alt.pattern)?;
52                    if let Some(body) = &alt.body {
53                        write!(f, " -> {}", body)?;
54                    }
55                }
56                write!(f, " }})")
57            }
58            HaskellExpr::Do(stmts) => {
59                write!(f, "do {{ ")?;
60                for (i, stmt) in stmts.iter().enumerate() {
61                    if i > 0 {
62                        write!(f, "; ")?;
63                    }
64                    match stmt {
65                        HaskellDoStmt::Bind(name, expr) => write!(f, "{} <- {}", name, expr)?,
66                        HaskellDoStmt::Stmt(expr) => write!(f, "{}", expr)?,
67                        HaskellDoStmt::LetBind(name, expr) => write!(f, "let {} = {}", name, expr)?,
68                    }
69                }
70                write!(f, " }}")
71            }
72            HaskellExpr::ListComp(body, quals) => {
73                write!(f, "[ {} | ", body)?;
74                for (i, q) in quals.iter().enumerate() {
75                    if i > 0 {
76                        write!(f, ", ")?;
77                    }
78                    match q {
79                        HsListQual::Generator(v, e) => write!(f, "{} <- {}", v, e)?,
80                        HsListQual::Guard(e) => write!(f, "{}", e)?,
81                        HsListQual::LetBind(v, e) => write!(f, "let {} = {}", v, e)?,
82                    }
83                }
84                write!(f, " ]")
85            }
86            HaskellExpr::Tuple(elems) => {
87                write!(f, "(")?;
88                for (i, e) in elems.iter().enumerate() {
89                    if i > 0 {
90                        write!(f, ", ")?;
91                    }
92                    write!(f, "{}", e)?;
93                }
94                write!(f, ")")
95            }
96            HaskellExpr::List(elems) => {
97                write!(f, "[")?;
98                for (i, e) in elems.iter().enumerate() {
99                    if i > 0 {
100                        write!(f, ", ")?;
101                    }
102                    write!(f, "{}", e)?;
103                }
104                write!(f, "]")
105            }
106            HaskellExpr::Neg(e) => write!(f, "(negate {})", e),
107            HaskellExpr::InfixApp(lhs, op, rhs) => write!(f, "({} {} {})", lhs, op, rhs),
108            HaskellExpr::Operator(op) => write!(f, "({})", op),
109            HaskellExpr::TypeAnnotation(expr, ty) => write!(f, "({} :: {})", expr, ty),
110        }
111    }
112}
oxilean_codegen/haskell_backend/haskellexpr_traits.rs

oxilean_codegen/haskell_backend/
haskellexpr_traits.rs
