fin prob

1 files changed, 186 insertions, 0 deletions

diff --git a/matrix-lang/src/value/fmt.rs b/matrix-lang/src/value/fmt.rs
new file mode 100644
index 0000000..f276bf1
--- /dev/null
+++ b/matrix-lang/src/value/fmt.rs
@@ -0,0 +1,186 @@
+use std::fmt::{Debug, Display};
+use crate::prelude::*;
+
+use Value as V;
+
+impl Debug for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            V::Nil => write!(f, "[Nil]"),
+            V::Int(i) => write!(f, "[Int {i}]"),
+            V::Bool(b) => write!(f, "[Bool {b}]"),
+            V::Float(vf) => write!(f, "[Float {vf}]"),
+            V::Ratio(r) => write!(f, "[Ratio {r}]"),
+            V::Complex(c) => write!(f, "[Complex {c}]"),
+            V::Regex(r) => write!(f, "[Regex /{r}/]"),
+            V::String(s) => write!(f, "[String '{s}']"),
+            V::List(l) => write!(f, "[List {}]", l.len()),
+            V::Matrix(m) => write!(f, "[Matirx {}x{}]", m.domain, m.codomain),
+            V::Table(t) => write!(f, "[Table {}]", t.len()),
+            V::Function(vf) => write!(f, "[Function {}]", vf.name),
+            V::Range(r) => write!(f, "[Range {:?}..{:?}]", r.0, r.1),
+            V::Iter(_) => write!(f, "[Iterator]"),
+            V::Exception(_) => write!(f, "[Error]"),
+            V::File(_) => write!(f, "[File]"),
+        }
+    }
+}
+
+impl Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let red;
+        let green;
+        let yellow;
+        let blue;
+        let pink;
+        let cyan;
+        let clear;
+
+        if f.alternate() {
+            red = "\x1b[31m";
+            green = "\x1b[32m";
+            yellow = "\x1b[33m";
+            blue = "\x1b[34m";
+            pink = "\x1b[35m";
+            cyan = "\x1b[36m";
+            clear = "\x1b[0m";
+        } else {
+            red = "";
+            green = "";
+            yellow = "";
+            blue = "";
+            pink = "";
+            cyan = "";
+            clear = "";
+        }
+
+        match self {
+            V::Nil => {write!(f, "{blue}nil{clear}")?;},
+            V::Bool(b) => {write!(f, "{yellow}{b}{clear}")?;},
+            V::Int(i) => {write!(f, "{yellow}{i}{clear}")?;},
+            V::Float(l) => {write!(f, "{yellow}{l}{clear}")?;},
+            V::Ratio(r) => {write!(f, "{yellow}{r}{clear}")?;},
+            V::Complex(c) => {write!(f, "{yellow}{c}{clear}")?;},
+            V::Regex(r) => {write!(f, "/{red}{r}{clear}/")?;},
+            V::String(s) => {
+                if f.alternate() {
+                    write!(f, "{green}'{s}'{clear}")?;
+                } else {
+                    write!(f, "{s}")?;
+                }
+            }
+            V::List(l) => {
+                if l.len() < 1 {
+                    write!(f, "[]")?;
+                    return Ok(())
+                }
+                write!(f, "[ ")?;
+                for (i, el) in l.iter().enumerate() {
+                    if i != 0 {
+                        write!(f, " ")?;
+                    }
+                    if f.alternate() {
+                        write!(f, "{el:#}")?;
+                    } else {
+                        write!(f, "{el}")?;
+                    }
+                }
+                write!(f, " ]")?;
+            },
+            V::Matrix(m) => {
+                if f.alternate() {
+                    write!(f, "{m:#}")?;
+                } else {
+                    write!(f, "{m}")?;
+                }
+            },
+            V::Table(t) => {
+                if f.alternate() {
+                    write!(f, "{t:#}")?;
+                } else {
+                    write!(f, "{t}")?;
+                }
+            },
+            V::Function(fun) => {
+                write!(f, "{cyan}{fun}{clear}")?;
+            }
+            V::Range(r) => {
+                if f.alternate() {
+                    write!(f, "{:#}..{:#}", r.0, r.1)?;
+                } else {
+                    write!(f, "{}..{}", r.0, r.1)?;
+                }
+            }
+            V::Iter(_) => {write!(f, "{pink}[Iterator]{clear}")?;},
+            V::File(_) => {write!(f, "{pink}[File]{clear}")?;},
+            V::Exception(e) => {write!(f, "{red}{e}{clear}")?;},
+        };
+        Ok(())
+    }
+}
+
+impl Debug for Matrix {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[Matrix {}x{}]", self.domain, self.codomain)
+    }
+}
+
+impl Display for Matrix {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut max_cols = vec![0; self.domain];
+        let mut vals: Vec<String> = Vec::with_capacity(self.domain * self.codomain);
+        for row in 0..self.codomain {
+            for col in 0..self.domain {
+                let idx = col + row * self.domain;
+                let el = &self.values[idx];
+                let s = match f.alternate() {
+                    true => format!("{:#}", el),
+                    false => format!("{}", el)
+                };
+                max_cols[col] = max_cols[col].max(s.len());
+                vals.push(s);
+            }
+        }
+
+        write!(f, "\n")?;
+        for row in 0..self.codomain {
+            for col in 0..self.domain {
+                let idx = col + row * self.domain;
+                let s = vals[idx].as_str();
+                let width = max_cols[col];
+                write!(f, " {s:>width$}")?;
+            }
+            write!(f, "\n")?;
+        }
+
+        Ok(())
+    }
+}
+
+impl Debug for ValueMap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[Table {}]", self.len())
+    }
+}
+
+impl Display for ValueMap {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.len() < 1 {
+            write!(f, "{{}}")?;
+            return Ok(())
+        }
+        write!(f, "{{ ")?;
+        for (i, (key, value)) in self.entries().enumerate() {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+            if f.alternate() {
+                write!(f, "{key:#} = {value:#}")?
+            } else {
+                write!(f, "{key} = {value}")?
+            }
+        }
+        write!(f, " }}")?;
+        Ok(())
+    }
+}