Merge remote-tracking branch 'origin/main' into operators

Use custom operators
Caching was a bad idea
2026-02-10 22:23:52 +01:00 · 2026-02-10 22:18:51 +01:00 · 2026-02-10 21:48:58 +01:00 · 2026-02-10 18:11:50 +01:00 · 2026-02-10 17:21:06 +01:00 · 2026-02-10 15:41:56 +01:00
10 changed files with 452 additions and 86 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -0,0 +1,4 @@
+[submodule "winnow"]
+	path = winnow
+	url = git@github.com:supersurviveur/winnow.git
+	branch = operator-in-expression
--- a/Cargo.lock
+++ b/Cargo.lock
@ -11,6 +11,12 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "anstream"
 version = "0.6.21"
@ -61,6 +67,12 @@ dependencies = [
 "windows-sys",
 ]

+[[package]]
+name = "bimap"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "230c5f1ca6a325a32553f8640d31ac9b49f2411e901e427570154868b46da4f7"
+
 [[package]]
 name = "colorchoice"
 version = "1.0.4"
@ -90,6 +102,29 @@ dependencies = [
 "log",
 ]

+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
@ -120,18 +155,21 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "litemap"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
-
 [[package]]
 name = "log"
 version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"

+[[package]]
+name = "lru"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593"
+dependencies = [
+ "hashbrown",
+]
+
 [[package]]
 name = "memchr"
 version = "2.8.0"
@ -154,9 +192,10 @@ checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"
 name = "picolog"
 version = "0.1.0"
 dependencies = [
+ "bimap",
 "env_logger",
- "litemap",
 "log",
+ "lru",
 "owo-colors",
 "winnow",
 ]
@ -284,8 +323,6 @@ dependencies = [
 [[package]]
 name = "winnow"
 version = "0.7.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 dependencies = [
 "memchr",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@ -4,8 +4,9 @@ version = "0.1.0"
 edition = "2024"

 [dependencies]
+bimap = "0.6.3"
 env_logger = "0.11.8"
-litemap = "0.8.1"
 log = "0.4.29"
+winnow = { version = "0.7.14", path = "./winnow" }
+lru = "0.16.3"
 owo-colors = "4.2.3"
-winnow = "0.7.14"
--- a/src/ast.rs
+++ b/src/ast.rs
@ -1,7 +1,9 @@
-use crate::prover::tracing::colored_var;
+use owo_colors::{OwoColorize, colors::css::Gray};
+
 use std::fmt::Display;

-pub type Variable = String;
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+pub struct Variable(pub String, pub Option<usize>);

 #[derive(Clone, Debug)]
 pub struct Module
@ -16,7 +18,7 @@ pub struct Clause
    pub body: Option<Body>,
 }

-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Body
 {
    Term(Predicate),
@ -24,11 +26,47 @@ pub enum Body
    Or(Vec<Body>),
 }

-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub enum Predicate
 {
    Variable(Variable), // Upercase variable like X
-    Fixed(String, Vec<Predicate>),
+    Fixed(Functor, Vec<Predicate>),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Functor
+{
+    Operator(Operator),
+    Functor(String),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Operator
+{
+    pub op: String,
+    pub precedence: usize,
+    pub op_type: OperatorType,
+}
+
+impl Operator
+{
+    pub fn new(op: String, precedence: usize, op_type: OperatorType) -> Self
+    {
+        Self {
+            op,
+            precedence,
+            op_type,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum OperatorType
+{
+    Prefix,
+    Postfix,
+    LeftInfix,
+    RightInfix,
 }

 impl Display for Body
@ -55,13 +93,26 @@ impl Display for Body
    }
 }

+impl Display for Variable
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+    {
+        write!(f, "{}", self.0)?;
+        if let Some(num) = self.1
+        {
+            write!(f, "{}", format!("[{}]", num).fg::<Gray>())?;
+        }
+        Ok(())
+    }
+}
+
 impl Display for Predicate
 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
    {
        match self
        {
-            Predicate::Variable(variable) => write!(f, "{}", colored_var(variable)),
+            Predicate::Variable(variable) => write!(f, "{}", variable),
            Predicate::Fixed(name, predicates) =>
            {
                write!(f, "{}", name)?;
@ -111,3 +162,22 @@ impl Display for Module
        Ok(())
    }
 }
+
+impl Display for Functor
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+    {
+        match self
+        {
+            Functor::Operator(op) => write!(f, "{}", op),
+            Functor::Functor(name) => write!(f, "{}", name),
+        }
+    }
+}
+impl Display for Operator
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+    {
+        write!(f, "{}", self.op)
+    }
+}
--- a/src/main.rs
+++ b/src/main.rs
@ -17,11 +17,26 @@ fn main()

        mult(zero, X, zero).
        mult(s(Y), X, Z) :- mult(Y, X, W), add(W, X, Z).
+
+        op(10, yfx, +).
+        op(8, yfx, ^).
+        op(6, xfy, ::).
+        op(2, fx, [).
+        op(2, xf, ]).
+        op(3, yfx, |).
+
+        A + B :- test.
+
+        A ^ B + C :- test.
+        A::B::C :- A.
+        [Hd|Tl] :- Hd::Tl.
    "
    .into();

+    // println!("{}", module);
+    // let prop: Body = "mult(X, s(s(s(zero))), s(s(s(s(s(s(s(s(s(zero))))))))))".into();
    //let prop: Body = "integer(s(X))".into();
-    let prop: Body = "mult(X, s(zero), s(zero))".into();
+    let prop: Body = "mult(X, s(s(zero)), s(s(s(s(zero)))))".into();
    //let prop: Body = "mult(X, Y, Z)".into();
    //let prop: Body = "mult(s(s(zero)), s(s(zero)), X)".into();
    for c in module.prove(&prop)
--- a/src/parsing.rs
+++ b/src/parsing.rs
@ -1,29 +1,210 @@
-use std::path::Path;
+use std::{collections::HashMap, path::Path};

-use winnow::Parser;
-use winnow::Result;
-use winnow::ascii::alphanumeric0;
-use winnow::ascii::multispace0;
-use winnow::combinator::alt;
-use winnow::combinator::delimited;
-use winnow::combinator::opt;
-use winnow::combinator::separated;
-use winnow::combinator::seq;
-use winnow::error::ContextError;
+use winnow::{
+    ascii::{self, alphanumeric1, multispace0},
+    combinator::{
+        alt, delimited, expression, opt, preceded, repeat, separated, seq, terminated, Infix,
+        Postfix, Prefix,
+    },
+    error::ContextError,
+    Parser, Result, Stateful,
+};

-use crate::ast::Body;
 use crate::ast::Clause;
+use crate::ast::Functor;
 use crate::ast::Module;
+use crate::ast::Operator;
 use crate::ast::Predicate;
+use crate::ast::{Body, OperatorType};
+use crate::ast::Variable;

-pub fn predicate_parse(input: &mut &str) -> Result<Predicate>
+impl Operator
 {
-    let ident = alphanumeric0.parse_next(input)?;
+    pub fn get_precedence(&self) -> usize
+    {
+        self.precedence
+    }
+    pub fn make_infix_operator<'a>(self) -> Infix<Stream<'a>, Predicate, Operator, ContextError>
+    {
+        fn make_predicate(
+            _: &mut Stream,
+            a: Predicate,
+            op: Operator,
+            b: Predicate,
+        ) -> Result<Predicate>
+        {
+            Ok(Predicate::Fixed(Functor::Operator(op), vec![a, b]))
+        }
+        let precedence = self.get_precedence() as i64;
+        match self.op_type
+        {
+            OperatorType::LeftInfix => Infix::Left(precedence, self, make_predicate),
+            OperatorType::RightInfix => Infix::Right(precedence, self, make_predicate),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl Operator
+{
+    fn infix(value: String, state: &State) -> Result<Self>
+    {
+        state
+            .custom_operators
+            .get(&(value.clone(), OperatorType::RightInfix))
+            .or_else(|| {
+                state
+                    .custom_operators
+                    .get(&(value, OperatorType::LeftInfix))
+            })
+            .ok_or(ContextError::new())
+            .cloned()
+    }
+    fn prefix(value: String, state: &State) -> Result<Self>
+    {
+        state
+            .custom_operators
+            .get(&(value, OperatorType::Prefix))
+            .ok_or(ContextError::new())
+            .cloned()
+    }
+    fn postfix(value: String, state: &State) -> Result<Self>
+    {
+        state
+            .custom_operators
+            .get(&(value, OperatorType::Postfix))
+            .ok_or(ContextError::new())
+            .cloned()
+    }
+}
+
+const OPERATORS: [&str; 9] = [":", "-", "+", "|", "/", "*", "[", "]", "^"];
+
+#[derive(Debug)]
+pub struct State
+{
+    custom_operators: HashMap<(String, OperatorType), Operator>,
+}
+
+impl Default for State
+{
+    fn default() -> Self
+    {
+        Self::new()
+    }
+}
+
+impl State
+{
+    pub fn new() -> Self
+    {
+        Self {
+            custom_operators: HashMap::new(),
+        }
+    }
+}
+
+type Stream<'is> = Stateful<&'is str, State>;
+
+pub fn operator_parse(input: &mut Stream) -> Result<String>
+{
+    delimited(multispace0, repeat(1.., alt(OPERATORS)), multispace0)
+        .map(|op: String| Ok(op))
+        .parse_next(input)?
+}
+
+pub fn operator_parse_infix(input: &mut Stream) -> Result<Operator>
+{
+    operator_parse(input).map(|op| Operator::infix(op, &input.state))?
+}
+pub fn operator_parse_postfix(input: &mut Stream) -> Result<Operator>
+{
+    operator_parse(input).map(|op| Operator::postfix(op, &input.state))?
+}
+pub fn operator_parse_prefix(input: &mut Stream) -> Result<Operator>
+{
+    operator_parse(input).map(|op| Operator::prefix(op, &input.state))?
+}
+
+pub fn operator_definition_parse(input: &mut Stream) -> Result<()>
+{
+    let (precedence, op_type, op) = preceded(
+        "op",
+        delimited(
+            ("(", multispace0),
+            seq! {
+                ascii::dec_uint,
+                _: (multispace0, ",", multispace0),
+                alt(("xfx", "xfy", "yfx", "xf", "yf", "fy", "fx")),
+                _: (multispace0, ",", multispace0),
+                operator_parse,
+            },
+            (multispace0, ")", multispace0, "."),
+        ),
+    )
+    .parse_next(input)?;
+    let op_type = match op_type
+    {
+        "xf" | "yf" => OperatorType::Postfix,
+        "fx" | "fy" => OperatorType::Prefix,
+        "xfx" => unimplemented!(),
+        "yfx" => OperatorType::LeftInfix,
+        "xfy" => OperatorType::RightInfix,
+        _ => unreachable!(),
+    };
+    input.state.custom_operators.insert(
+        (op.clone(), op_type.clone()),
+        Operator::new(op, precedence, op_type),
+    );
+    Ok(())
+}
+
+pub fn predicate_parse_infix_expression<'a>(
+    input: &mut Stream<'a>,
+) -> Result<Infix<Stream<'a>, Predicate, Operator, ContextError>>
+{
+    let op = operator_parse_infix.parse_next(input)?;
+    Ok(op.make_infix_operator())
+}
+
+pub fn predicate_parse_prefix_expression<'a>(
+    input: &mut Stream<'a>,
+) -> Result<Prefix<Stream<'a>, Predicate, Operator, ContextError>>
+{
+    let op = operator_parse_prefix.parse_next(input)?;
+    let precedence = op.get_precedence() as i64;
+    Ok(Prefix(precedence, op, |_, op, a| {
+        Ok(Predicate::Fixed(Functor::Operator(op), vec![a]))
+    }))
+}
+pub fn predicate_parse_postfix_expression<'a>(
+    input: &mut Stream<'a>,
+) -> Result<Postfix<Stream<'a>, Predicate, Operator, ContextError>>
+{
+    let op = operator_parse_postfix.parse_next(input)?;
+    let precedence = op.get_precedence() as i64;
+    Ok(Postfix(precedence, op, |_, a, op| {
+        Ok(Predicate::Fixed(Functor::Operator(op), vec![a]))
+    }))
+}
+
+pub fn predicate_parse_expression(input: &mut Stream) -> Result<Predicate>
+{
+    expression(predicate_parse_recursive)
+        .infix(predicate_parse_infix_expression)
+        .postfix(predicate_parse_postfix_expression)
+        .prefix(predicate_parse_prefix_expression)
+        .parse_next(input)
+}
+
+pub fn predicate_parse_variable_or_functor(input: &mut Stream) -> Result<Predicate>
+{
+    let ident = alphanumeric1.parse_next(input)?;

    // Check if output is a variable
    if ident.chars().next().is_some_and(|char| char.is_uppercase())
    {
-        Ok(Predicate::Variable(String::from(ident)))
+        Ok(Predicate::Variable(Variable(String::from(ident), None)))
    }
    else
    {
@ -34,11 +215,28 @@ pub fn predicate_parse(input: &mut &str) -> Result<Predicate>
        )
        .parse_next(input)
        .unwrap_or(Vec::new());
-        Ok(Predicate::Fixed(String::from(ident), arguments))
+        Ok(Predicate::Fixed(
+            Functor::Functor(String::from(ident)),
+            arguments,
+        ))
    }
 }

-fn body_parse_or(input: &mut &str) -> Result<Body>
+pub fn predicate_parse_recursive(input: &mut Stream) -> Result<Predicate>
+{
+    alt((
+        delimited("(", predicate_parse, ")"),
+        predicate_parse_variable_or_functor,
+    ))
+    .parse_next(input)
+}
+
+pub fn predicate_parse(input: &mut Stream) -> Result<Predicate>
+{
+    alt((predicate_parse_expression, predicate_parse_recursive)).parse_next(input)
+}
+
+fn body_parse_or(input: &mut Stream) -> Result<Body>
 {
    separated(
        1..,
@ -52,7 +250,7 @@ fn body_parse_or(input: &mut &str) -> Result<Body>
    .parse_next(input)
 }

-pub fn body_parse(input: &mut &str) -> Result<Body>
+pub fn body_parse(input: &mut Stream) -> Result<Body>
 {
    // Parse and
    separated(1.., body_parse_or, (multispace0, ",", multispace0))
@ -60,7 +258,7 @@ pub fn body_parse(input: &mut &str) -> Result<Body>
        .parse_next(input)
 }

-pub fn clause_parse(input: &mut &str) -> Result<Clause>
+pub fn clause_parse(input: &mut Stream) -> Result<Clause>
 {
    seq! {
        Clause
@ -74,12 +272,19 @@ pub fn clause_parse(input: &mut &str) -> Result<Clause>
    .parse_next(input)
 }

-pub fn module_parse(input: &mut &str) -> Result<Module>
+pub fn module_parse(input: &mut Stream) -> Result<Module>
 {
    let _: Result<&str, ContextError> = multispace0.parse_next(input);
-    separated(0.., clause_parse, multispace0)
-        .map(|clauses| Module { clauses })
-        .parse_next(input)
+    separated(
+        0..,
+        preceded::<_, (), _, _, _, _>(
+            repeat(0.., terminated(operator_definition_parse, multispace0)),
+            clause_parse,
+        ),
+        multispace0,
+    )
+    .map(|clauses| Module { clauses })
+    .parse_next(input)
 }

 impl<T> From<T> for Module
@ -88,8 +293,13 @@ where
 {
    fn from(value: T) -> Self
    {
-        let mut str: &str = value.as_ref();
-        module_parse.parse_next(&mut str).unwrap()
+        let str: &str = value.as_ref();
+        module_parse
+            .parse_next(&mut Stream {
+                input: str,
+                state: State::new(),
+            })
+            .unwrap()
    }
 }

@ -107,8 +317,13 @@ where
 {
    fn from(value: T) -> Self
    {
-        let mut str: &str = value.as_ref();
-        predicate_parse.parse_next(&mut str).unwrap()
+        let str: &str = value.as_ref();
+        predicate_parse
+            .parse_next(&mut Stream {
+                input: str,
+                state: State::new(),
+            })
+            .unwrap()
    }
 }

@ -118,7 +333,12 @@ where
 {
    fn from(value: T) -> Self
    {
-        let mut str: &str = value.as_ref();
-        body_parse.parse_next(&mut str).unwrap()
+        let str: &str = value.as_ref();
+        body_parse
+            .parse_next(&mut Stream {
+                input: str,
+                state: State::new(),
+            })
+            .unwrap()
    }
 }
--- a/src/prover.rs
+++ b/src/prover.rs
@ -8,14 +8,15 @@ pub mod tracing;
 pub mod unification;

 use std::cell::Cell;
+use std::collections::HashMap;
 use std::rc::Rc;

-use litemap::LiteMap;
-
 use crate::ast::Body;
 use crate::ast::Clause;
 use crate::ast::Module;
 use crate::ast::Predicate;
+use crate::ast::Variable;
+use crate::prover::body::BodyProver;
 use crate::prover::constraints::Constraints;
 use crate::prover::tracing::IndentedTracer;

@ -29,7 +30,12 @@ impl GlobalCounter
 {
    pub fn new() -> GlobalCounter
    {
-        GlobalCounter(Rc::new(Cell::new(0)))
+        Self::with(0)
+    }
+
+    pub fn with(n: usize) -> GlobalCounter
+    {
+        GlobalCounter(Rc::new(Cell::new(n)))
    }

    pub fn get(&self) -> usize
@ -59,6 +65,7 @@ impl Module
            GlobalCounter::new(),
            body.clone(),
            Constraints::none(),
+            //&mut EmptyTracer,
            &mut IndentedTracer::new(),
            //&SimpleTracer::new(ProofType::Body),
        )
@ -69,7 +76,7 @@ impl Clause
 {
    pub fn make_unique(&self, counter: GlobalCounter) -> Clause
    {
-        let mut unique_map = LiteMap::new();
+        let mut unique_map = HashMap::new();
        Clause {
            head: self.head.make_unique(counter.clone(), &mut unique_map),
            body: self
@ -85,7 +92,7 @@ impl Body
    pub fn make_unique(
        &self,
        counter: GlobalCounter,
-        unique_map: &mut LiteMap<String, usize>,
+        unique_map: &mut HashMap<Variable, usize>,
    ) -> Body
    {
        match self
@ -112,18 +119,15 @@ impl Predicate
    pub fn make_unique(
        &self,
        counter: GlobalCounter,
-        unique_map: &mut LiteMap<String, usize>,
+        unique_map: &mut HashMap<Variable, usize>,
    ) -> Self
    {
        match self
        {
-            Predicate::Variable(name) => Predicate::Variable(format!(
-                "_{}[{}]",
-                name,
-                unique_map
-                    .entry(name.clone())
-                    .or_insert_with(|| counter.get())
-            )),
+            Predicate::Variable(var) =>
+            {
+                Predicate::Variable(var.make_unique(counter.clone(), unique_map))
+            }
            Predicate::Fixed(name, predicates) => Predicate::Fixed(
                name.clone(),
                predicates
@ -134,3 +138,22 @@ impl Predicate
        }
    }
 }
+
+impl Variable
+{
+    pub fn make_unique(
+        &self,
+        counter: GlobalCounter,
+        unique_map: &mut HashMap<Variable, usize>,
+    ) -> Self
+    {
+        Variable(
+            self.0.clone(),
+            Some(
+                *unique_map
+                    .entry(self.clone())
+                    .or_insert_with(|| counter.get()),
+            ),
+        )
+    }
+}
--- a/src/prover/constraints.rs
+++ b/src/prover/constraints.rs
@ -1,16 +1,14 @@
+use std::collections::HashMap;
 use std::fmt::Display;

-use litemap::LiteMap;
-
 use crate::ast::Body;
 use crate::ast::Predicate;
 use crate::ast::Variable;
-use crate::prover::tracing::colored_var;

 #[derive(Clone, Debug)]
 pub struct Constraints
 {
-    set: LiteMap<Variable, Predicate>,
+    pub(crate) set: HashMap<Variable, Predicate>,
 }

 impl Constraints
@ -18,7 +16,7 @@ impl Constraints
    pub fn none() -> Self
    {
        Constraints {
-            set: LiteMap::new(),
+            set: HashMap::new(),
        }
    }

@ -103,7 +101,7 @@ impl Constraints
        let mut stripped = max_sub.clone();
        'outer: for (var, _) in max_sub.set.iter()
        {
-            if var.chars().next().is_some_and(|x| x == '_')
+            if var.0.chars().next().is_some_and(|x| x == '_') || var.1.is_some()
            {
                for (_, other_pred) in max_sub.set.iter()
                {
@ -147,7 +145,7 @@ impl Predicate
        }
    }

-    pub fn contains_variable(&self, name: &String) -> bool
+    pub fn contains_variable(&self, name: &Variable) -> bool
    {
        match self
        {
@ -188,7 +186,7 @@ impl Display for Constraints
        let len = self.set.len();
        for (i, (var, pred)) in self.set.iter().enumerate()
        {
-            write!(f, "{} = {}", colored_var(var), pred)?;
+            write!(f, "{} = {}", var, pred)?;
            if i != len - 1
            {
                write!(f, ", ")?;
--- a/src/prover/tracing.rs
+++ b/src/prover/tracing.rs
@ -1,12 +1,10 @@
 use log::info;
-use owo_colors::{
-    OwoColorize, Style,
-    colors::css::{DarkGray, Gray},
-};
+use owo_colors::colors::css::DarkGray;
+use owo_colors::colors::css::Gray;
+use owo_colors::OwoColorize;
+use owo_colors::Style;
 use std::fmt::Display;

-use crate::ast::Variable;
-
 #[derive(Clone, Copy)]
 pub enum ProofType
 {
@ -110,8 +108,8 @@ impl Tracer for IndentedTracer
        }
        self.first = false;
        println!("{}", show);
-        let _ = std::io::stdin().read_line(&mut String::new());
-        println!("\x1b[2A");
+        // let _ = std::io::stdin().read_line(&mut String::new());
+        // println!("\x1b[2A");
    }

    fn end_proof(self)
@ -133,17 +131,16 @@ impl Default for IndentedTracer
    }
 }

-pub fn colored_var(var: &Variable) -> String
+pub struct EmptyTracer;
+
+impl Tracer for EmptyTracer
 {
-    let mut idx = None;
-    for (i, char) in var.chars().enumerate()
+    fn begin_proof(&mut self, _proof_type: ProofType) -> Self
    {
-        if char == '['
-        {
-            idx = Some(i);
-        }
+        EmptyTracer
    }
-    let (var, unique) = var.split_at(idx.unwrap_or(var.len()));
-    let unique = unique.fg::<Gray>();
-    format!("{}{}", var, unique)
+
+    fn print_step<T: Display>(&mut self, _show: T) {}
+
+    fn end_proof(self) {}
 }
--- a/1
+++ b/1
Author	SHA1	Message	Date
supersurviveur	27af8c9263	Merge remote-tracking branch 'origin/main' into operators	2026-02-10 22:23:52 +01:00
supersurviveur	c82384764c	Use custom operators	2026-02-10 22:18:51 +01:00
Albin Chaboissier	54724c2f4c	Caching was a bad idea	2026-02-10 21:48:58 +01:00
Albin Chaboissier	d8180a982e	Finishes cache	2026-02-10 18:11:50 +01:00
Albin Chaboissier	1c17aa20c2	Starts proof cache infra	2026-02-10 17:21:06 +01:00
supersurviveur	21414f75db	Adds operators	2026-02-10 15:41:56 +01:00