Idea: Types of Closures

[harudagondi]

use std::any::Any;

fn f<T, U>(t: T, u: U)
where
    T: 'static,
    U: 'static,
{
    if t.type_id() == u.type_id() {
        print!("1")
    } else {
        print!("0")
    }
}

fn c() -> impl Fn() {
    || {}
}

fn main() {
    f(|| {}, || {});
    f(c(), c());
}

Answer: 01

Hint

Do closures have the same type? How many types can a function return?

Explanation

According to the Rust Reference Book, "A closure expression produces a closure value with a unique, anonymous type that cannot be written out."

However, functions must always return one singular type, and as such all || {} produced by new_closure() must be of the same type.

Personally this surprised me because I originally thought that all closures are unique from each other, but this assumption can be broken by returning closures from functions (or even closures!).

Another fun exercise:

use std::any::Any;

fn f<T, U>(t: T, u: U)
where
    T: 'static,
    U: 'static,
{
    match t.type_id() == u.type_id() {
        true => print!("1"),
        false => print!("0"),
    }
}

fn eq<T: PartialEq>(t0: T, t1: T) {
    match t0 == t1 {
        true => print!("1"),
        false => print!("0"),
    }
}

fn c() -> impl Fn() {
    || {}
}

fn d(x: i32) -> impl Fn() -> i32 {
    move || x
}

fn main() {
    let x = d(1);
    let y = d(2);

    let a = x();
    let b = y();

    f(|| {}, || {});
    f(c(), c());
    f(x, y);
    eq((|| {})(), (|| {})());
    eq(c()(), c()());
    eq(a, b);
}

Answer: 011110