Skip to main content

oxilean_codegen/ocaml_backend/
ocamlpattern_traits.rs

1//! # OcamlPattern - Trait Implementations
2//!
3//! This module contains trait implementations for `OcamlPattern`.
4//!
5//! ## Implemented Traits
6//!
7//! - `Display`
8//!
9//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
10
11use super::functions::format_ocaml_expr;
12use super::types::OcamlPattern;
13use std::fmt;
14
15impl fmt::Display for OcamlPattern {
16    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17        match self {
18            OcamlPattern::Wildcard => write!(f, "_"),
19            OcamlPattern::Var(name) => write!(f, "{}", name),
20            OcamlPattern::Const(lit) => write!(f, "{}", lit),
21            OcamlPattern::Tuple(pats) => {
22                write!(f, "(")?;
23                for (i, p) in pats.iter().enumerate() {
24                    if i > 0 {
25                        write!(f, ", ")?;
26                    }
27                    write!(f, "{}", p)?;
28                }
29                write!(f, ")")
30            }
31            OcamlPattern::Cons(head, tail) => write!(f, "{} :: {}", head, tail),
32            OcamlPattern::List(pats) => {
33                write!(f, "[")?;
34                for (i, p) in pats.iter().enumerate() {
35                    if i > 0 {
36                        write!(f, "; ")?;
37                    }
38                    write!(f, "{}", p)?;
39                }
40                write!(f, "]")
41            }
42            OcamlPattern::Ctor(name, args) => {
43                write!(f, "{}", name)?;
44                if !args.is_empty() {
45                    if args.len() == 1 {
46                        write!(f, " {}", args[0])?;
47                    } else {
48                        write!(f, " (")?;
49                        for (i, a) in args.iter().enumerate() {
50                            if i > 0 {
51                                write!(f, ", ")?;
52                            }
53                            write!(f, "{}", a)?;
54                        }
55                        write!(f, ")")?;
56                    }
57                }
58                Ok(())
59            }
60            OcamlPattern::Record(fields) => {
61                write!(f, "{{ ")?;
62                for (i, (name, pat)) in fields.iter().enumerate() {
63                    if i > 0 {
64                        write!(f, "; ")?;
65                    }
66                    write!(f, "{} = {}", name, pat)?;
67                }
68                write!(f, " }}")
69            }
70            OcamlPattern::Or(p1, p2) => write!(f, "{} | {}", p1, p2),
71            OcamlPattern::As(pat, name) => write!(f, "({} as {})", pat, name),
72        }
73    }
74}