I have an open PR with documentation for just Iterator alone that has a diff so big github can't expand it. Hope they help.

Note that anytime you see a closure in any language that just takes a single argument, calls a single function with that argument, and returns the value of that function, then you can eliminate the closure entirely by just passing the function instead.

So `filter_map(|x| foo(x))` can be written more simply as just `filter_map(foo)`.

I know this but I can never get my code to compile when doing this. I always seem to get huge type errors even when I know the code is correct.

     map(|x|foo(x)) //clean compile
     map(foo) //type error

The number of times I've had this happen has just lead to me giving up on simply just passing the lambda as a variable instead of wrapping it in another.

Curious. Can you provide a full code example so that I can try to determine what's causing that error?

Usually in these cases the culprit is autoderef/deref coercions.

I don't see anything in `|x| foo(x)` that could be causing `x` to be deref'd.

A deref coercion can happen there

https://github.com/Manishearth/rust-clippy/issues/116

Just make an issue?

I don't think it necessarily warrants an issue on the Rust repo, this is just for my own edification.