How do I tell the compiler not to evaluate an argument? - rust

Question

I'd like to instruct the Rust compiler to not evaluate an argument under any circumstance. Here is an example:
#![allow(dead_code)]
trait CheckTrait {
fn check(b : bool);
}
struct CheckStructA {}
struct CheckStructB {}
impl CheckTrait for CheckStructA {
fn check(_b : bool) {
println!("CheckStructA");
}
}
impl CheckTrait for CheckStructB {
// compiler: do not evaluate the argument _b
fn check(_b : bool) {
}
}
fn show_stuff_a() -> bool {
println!("Show stuff A");
true
}
fn show_stuff_b() -> bool {
println!("Show stuff B");
true
}
fn test_a<T : CheckTrait>(_ : T) {
T::check(show_stuff_a());
}
fn test_b<T : CheckTrait>(_ : T) {
T::check(show_stuff_b());
}
fn main() {
test_a(CheckStructA{});
test_b(CheckStructB{});
}
Here CheckStructB is effectively a disabled version of CheckStructA. Where the comment is, I would like to be able to instruct the compiler not to evaluate whatever expression computes _b for CheckStructB::check, but still evaluate whatever expression would compute _b for CheckStructA::check. The consequence on this code is that it would still output "Show Stuff A" to the console, but not output "Show Stuff B" to the console.
In C# this can be done by replacing the comment with [System.Diagnostics.Conditional("DoNotEverTurnThisOn")] . I do not want to define the types inside a macro because that breaks intellisense.
How do I do it in Rust?

Answer 1

Only evaluating arguments as necessary is called Lazy Evaluation.
In languages like Haskell, for which Lazy Evaluation is the default, an argument or variable of type bool is not actually represented as a bool immediately, instead it is represented as a "thunk" which contains the function to call and its own arguments (potentially thunks).
In Rust, since Eager Evaluation is the default, you need to explicitly represent laziness in the type of the argument or valuable. This is generally done by asking not for T but for FnOnce() -> T instead.
Therefore, you would rewrite check as:
fn check<F: FnOnce() -> bool>(condition: F);
Then, it's up to the implementation to either evaluate F or not, and if not evaluated nothing is executed.
Note: if you do not want a generic check, you can take Box<FnOnce() -> bool> as an argument; it will however require a heap allocation... just like in Haskell.
Let's see some code! Playground link
trait CheckTrait {
fn check<F: FnOnce() -> bool>(b: F);
}
struct CheckStructA {}
struct CheckStructB {}
impl CheckTrait for CheckStructA {
fn check<F: FnOnce() -> bool>(b: F) {
b();
println!("CheckStructA");
}
}
impl CheckTrait for CheckStructB {
fn check<F: FnOnce() -> bool>(_b: F) {
println!("CheckStructB");
}
}
fn show_stuff_a() -> bool {
println!("Show stuff A");
true
}
fn show_stuff_b() -> bool {
println!("Show stuff B");
true
}
fn test_a<T : CheckTrait>(_ : T) {
T::check(|| show_stuff_a());
}
fn test_b<T : CheckTrait>(_ : T) {
T::check(|| show_stuff_b());
}
fn main() {
test_a(CheckStructA{});
test_b(CheckStructB{});
}