Problem with generics and bare functions

[brson]

fn main() {
    fn# foo<T>() { }

    // This wants to build a closure over type int,
    // but there's no way to do that while still being a bare function
    let f: fn#() = foo::<int>;
}

As a result we can't do bare-fn spawn for generic functions, which is pretty important:

#[test]
fn spawn_polymorphic() {
    fn# foo<~T>(x: T) { log_err x; }

    task::spawn2(true, foo);
    task::spawn2(42, foo);
}

[marijnh]

(I'm assuming safe spawning is the primary motivation for bare functions. If it is actually 'saving a word of storage', ignore what comes after---)

What if we support 'unique functions' (terrible term) instead of bare functions? They'd be closures that own all the values in their environment (the environment being a unique pointer as well). They'd be more compatible with regular blocks (you could pass a fn~ to a function expecting a block), and for real bare functions the environment field can simply be a null pointer, so no extra malloc is required.

[brson]

Spawning is the primary motivation for having some sort of typesafe function that can cross tasks.

The reasons for preferring bare functions to unique functions are somewhat murky to me, but pcwalton and dherman have both expressed doubts. One tangible issue is that type descriptors are not unique-kinded so putting them into unique closures and passing them between tasks presents obstacles.

I'm going to make it so you can't take the value of generic bare functions. It doesn't bring me joy.

For reference, graydon's notes on function types are here: https://github.com/graydon/rust/wiki/Function-types

[brson]

Also, the plan is to turn function items into bare functions, which means that anywhere we are taking the value of a generic function currently will have to become a bind.