Seems weird but what happens when you provide a typo hint inside of the lambda?

Seems weird but what happens when you provide a typo hint inside of the lambda?

It works:

pub unconstrained fn call_lambda_on_vec<Env>(
    foo: BoundedVec<Field, 5>,
    lambda: fn[Env](BoundedVec<Field, 5>) -> ()
) {
    lambda(foo);
}

unconstrained fn main(param: BoundedVec<Field, 5>) {
    call_lambda_on_vec(param, |vec:BoundedVec<Field, 5>| {
        // I try to call random BoundedVec methods, but they don't work
        assert(vec.len() > 2);
        assert_eq(vec.get(0), vec.storage()[1]);
    });
}

It seems what's happening is that vec in the lambda doesn't have a type (it's an unbound type variable) when then len method is searched, so it's not found. But type-checking continues and eventually the compiler figures out that vec is a BoundedVec. Once the error is shown, the type variable is bound so the type is BoundedVec and that's why the error is "No method named 'len' for 'BoundedVec'".

@asterite is right, we don't "push down" types at all during type checking. We only infer from the bottom up. This often means lambda arguments in particular will need type annotations if you're calling methods or accessing fields in the lambda.

I was wondering how Rust solves this, because it works in Rust.

But if you have this:

pub struct Foo {}

impl Foo {
    fn foo(self) {}
}

fn main() {
    let lambda = |foo| foo.foo();
    lambda(Foo {});
}

then it doesn't compile (it asks you to put a type annotation on |foo|).

If you have this it compiles fine:

pub struct Foo {}

impl Foo {
    fn foo(self) {}
}

pub fn call(_f: fn(Foo) -> ()) {}

fn main() {
    call(|foo| foo.foo());
}

So I can imagine Rust sees that call's argument has a function type, and uses that to give a type to foo in |foo|. But it gets tricky because this also works in Rust:

pub struct Foo {}

impl Foo {
    fn foo(self) {}
}

pub fn call<T>(_t: T, _f: fn(T) -> ()) {}

fn main() {
    call(Foo {}, |foo| foo.foo());
}

and even this:

pub fn call<T>(_f: fn(T) -> (), _t: T) {}

fn main() {
    call(|foo| foo.foo(), Foo {});
}

but not this:

pub fn call<T>(_f: fn(T) -> (), _g: fn() -> T) {}

fn main() {
    call(|foo| foo.foo(), || Foo {});
}

Rust uses bidirectional type checking, so it pushes types down as well