Judging whether fend did any "actual calculations"

[happenslol]

Hey, thanks for this awesome cli/library!

I'm writing an app-launcher style application, and I want to include the ability to do quick inline calculations while typing. Fend seems perfectly suited to that. However, I only want to show the result if the user was actually attempting to do any calculations, and it seems hard to judge that.

As an example, when I enter "1", I get the following result from fend:

FendResult {
    plain_result: "1",
    span_result: [
        Span {
            string: "1",
            kind: Number,
        },
        Span {
            string: "",
            kind: Ident,
        },
    ],
    attrs: Attrs {
        debug: false,
        show_approx: true,
        plain_number: false,
        trailing_newline: true,
    },
},

Essentially fend just parsed the term successfully, but didn't resolve anything. I could prepare the query with the plain_result, but that breaks as soon as the user enters something like 1kmh which gets parsed as 1 kmh.

Is there any way (or could I help implement a way) to check whether any actual calculations were done? I understand the definition for that is probably fuzzy, but I think a reasonable threshold could be found 🙂

[happenslol]

So, I've spent some time on this and came up with the following 2 options:

1. We could do recursive AST analysis to find out if calculation is going to happen. This has a few edge cases (especially when it comes to unit conversions) and is probably not 100% accurate, but very easy to implement. Here's a quick sketch:

fn contains_computation(expr: &Expr) -> bool {
	match expr {
		Expr::Literal(_) => false,
		Expr::Ident(_) => false,
		Expr::Parens(inner) => compute_contains_computation(inner),
		Expr::UnaryMinus(_) | Expr::UnaryPlus(_) | Expr::UnaryDiv(_) | Expr::Factorial(_) => true,
		Expr::Bop(_, _, _) => true,
		Expr::Apply(_, _) | Expr::ApplyFunctionCall(_, _) | Expr::ApplyMul(_, _) => true,
		Expr::As(_, _) => true,
		Expr::Fn(_, _) => true,
		Expr::Of(_, _) => true,
		Expr::Assign(_, _) => true,
		Expr::Statements(a, b) => compute_contains_computation(a) || compute_contains_computation(b),
		Expr::Equality(_, _, _) => true,
	}
}

This would even be possible outside of fend if it was possible to get the AST from the library.

2. Save did_compute in FendResult, and just pass down a context through all actual computation that gets mutated. This is completely accurate since the flag would only be set in the actual evaluation, but has the downside that we have to evaluate.

I think I'd prefer 1, it's way less invasive and we can get the info without doing any evaluation. What do you think?