Type signature of a Rust HashMap of a function

Question

I create a HashMap which maps strings to functions of type Vec<Expression> -> Expression, where Expression is a type I have defined. The code in question is:

let functions: HashMap<_, _> = vec!(("+", Box::new(plus))).into_iter().collect();

If I let Rust infer the type for me, as in the code above, it compiles and runs fine, as in the code above. However, if I try to specify the type, it doesn't compile:

let functions: HashMap<&str, Box<Fn(Vec<Expression>) -> Expression>> =
    vec!(("+", Box::new(plus))).into_iter().collect();

The compiler error message isn't very helpful:

let functions: HashMap<&str, Box<Fn(Vec<Expression>) -> Expression>> = vec!(("+", Box::new(plus))).into_iter().collect();
^^^^^^^ a collection of type `std::collections::HashMap<&str, std::boxed::Box<std::ops::Fn(std::vec::Vec<Expression>) -> Expression>>` cannot be built from an iterator over elements of type `(&str, std::boxed::Box<fn(std::vec::Vec<Expression>) -> Expression {plus}>)`

What is the actual type of this HashMap?

It seems my google-fu is really weak as I could have sworn there was a duplicate for this :( — Matthieu M., Jul 18 '17 at 06:52

Matthieu M. · Accepted Answer · 2017-07-18T07:54:40.570

If you look closely at the difference you will have your answer, although it can be puzzling.

I expect that plus has been declared as:

fn plus(v: Vec<Expression>) -> Expression;

In this case, the type of plus is fn(Vec<Expression>) -> Expression {plus}, and is actually a Voldemort Type: it cannot be named.

Most notably, it differs from an eventual fn(Vec<Expression>) -> Expression {multiply}.

Those two types can be coerced into a bare fn(Vec<Expression>) -> Expression (without the {plus}/{multiply} denomination).

And this latter type can be transformed into a Fn(Vec<Expression>) -> Expression, which is a trait for any callable which do not modify their environments (such as the closure |v: Vec<Expression>| v[0].clone()).

The problem, however, is that while fn(a) -> b {plus} can be transformed into fn(a) -> b which can be transformed into Fn(a) -> b... the transformation requires a change of memory representation. This is because:

fn(a) -> b {plus} is a zero-sized type,
fn(a) -> b is a pointer to function,
Box<Fn(a) -> b> is a boxed trait object which generally means both a virtual pointer and a data pointer.

And therefore the type ascription doesn't work, because it can only perform cost-free coercions.

The solution is to perform the transformation before it's too late:

// Not strictly necessary, but it does make code shorter.
type FnExpr = Box<Fn(Vec<Expression>) -> Expression>;

let functions: HashMap<_, _> =
    vec!(("+", Box::new(plus) as FnExpr)).into_iter().collect();
               ^~~~~~~~~~~~~~~~~~~~~~~~

Or maybe you'd rather keep unboxed functions:

// Simple functions only
type FnExpr = fn(Vec<Expression>) -> Expression;

let functions: HashMap<_, _> =
    vec!(("+", plus as FnExpr)).into_iter().collect();

BTW, `fn(A) -> B {plus}` is not a pointer. [It is zero-sized.](https://play.rust-lang.org/?gist=0ad4ee6d789294e3af47d0a71dc74940&version=stable) — red75prime, Jul 18 '17 at 07:45
@red75prime: Oh right, I always forget about this neat thing! — Matthieu M., Jul 18 '17 at 07:53
Thanks for the very detailed and comprehensive answer. This perfectly answers my question. — isaacg, Jul 18 '17 at 08:11

red75prime · Answer 2 · 2017-07-18T08:02:40.300

The relevant parts of error message are Box<std::ops::Fn ... > and Box<fn ... {plus}>. The first is a boxed Fn trait object. The second is a boxed function plus. Note that it isn't a boxed pointer to a function, which would be Box<fn ...> with no {plus} part. It is the unique and unnameable type of the function plus itself.

That is you cannot write real type of this HashMap, as the type it contains is unnameable. It's not a big deal though, you can only put plus function into it.

The following code gives compilation error

let functions: HashMap<_, _> =
    vec![("+", Box::new(plus)), 
         ("-", Box::new(minus))].into_iter().collect();
                        ^^^^^ expected fn item, found a different fn item

This works, but it is useless

let functions: HashMap<_, _> =
    vec![("+", Box::new(plus)), 
         ("-", Box::new(plus))].into_iter().collect();

One possible solution is to convert first element of a vector into the required type.

type BoxedFn = Box<Fn(Vec<Expression>) -> Expression>;

let functions: HashMap<&str, BoxedFn> =
    vec![("+", Box::new(plus) as BoxedFn),
         ("_", Box::new(minus))].into_iter().collect();

Another one is type ascription of intermediate variable.

type BoxedFn = Box<Fn(Vec<Expression>) -> Expression>;

let v: Vec<(_, BoxedFn)> = vec![("+", Box::new(plus)), ("_", Box::new(minus))];
let functions: HashMap<&str, BoxedFn> = v.into_iter().collect();

Type signature of a Rust HashMap of a function

2 Answers2

Linked

Related