right = |_a| 的 Rust 泛型类型实现 |b| 乙

Question

In TypeScript, I do:

const right = <T>(a: T) => <U>(b: U) => b;

const log = (msg: unknown) =>
  right
    (console.log(msg))
    (msg);

log(1); // 1
log("hello"); // "hello"
log(right(1)(2)); // 2

Now, I want to implement the same code in Rust with generic types.

let right = |_a| |b| b;

let log = |msg| right(println!("{:?}", msg))(msg);

log(1); // 1   
log("hello"); // compile error  
log(right(1)(2)); // compile error

So far, the compile error is like this, and I know why and how the error occurs, and I know this is not a code using generic.

So my question is what would be a proper code to implement this in Rust using generic types to closure ?

Answer 1

The problem here is that your closures are not generic. They are in fact fixed to a specific type and those types are inferred. The compiler assigns them once with your first use, and then they don't match for subsequent uses.

If you want to use generic types, it's going to be better to use an explicit function instead of a closure:

fn right<T, U>(_x: T) -> impl Fn(U) -> U {
    |b| b
}

fn log<T: std::fmt::Debug>(msg: T) {
    right(println!("{:?}", msg))(msg);
}

fn main() {
    log(1); // 1
    log("hello"); // hello
    log(right(1)(2)); // 2
}

Those functions are explicitly generic and appropriately typed, so they'll be monomorphized as appropriate for each instantiation. If you're unhappy with the increased scope of those functions, you can push them into main , and they'll be visible only from there, just like your closures.