Change:
We do not expect to completely "unfeature-gate" unboxed closures for 1.0. We wish to reserve the flexibility to change a few aspects: to variadic generics in place of auto-tupling. the and arguments from input types to (possibly) associated types. (cc ) the coherence story with respect to fn-trait hierarchy. (cc ) To this end we will adjust the features to: [ ] Disallow references to the traits using angle bracket notation [x] Disallow user impls of the traits [x] Disallow direct calls to [x] Disallow parenthetical notation () from being used with anything other than the traits In short, we permit unboxed closures to be used as if they are a language builtin, but disallow (for now) a lot of the more generic uses. We should be able to drop this feature gate shortly after 1.0. cc
Nominating for 1.0 or something. :)
P-backcompat-lang, 1.0.
Note that some of this works today though it ought not, e.g. manually implementing traits.
To expand on comment, the following code fails to compile due to the lack of a feature that should be gated: The current solution is to put on the function.
This was done, or done enough.
Oops, I totally overlooked that is still considered legal. It's important to adjust that too!

Discussion:
let (regions, types, assoc_bindings) = match path.segments.last().unwrap().parameters { ast::AngleBracketedParameters(ref data) => { <ins> // For now, require that parenthetical notation be used // only with `Fn()` etc. if !this.tcx().sess.features.borrow().unboxed_closures && this.tcx().lang_items.fn_trait_kind(trait_def_id).is_some() { this.tcx().sess.span_err(path.span, "angle-bracket notation is not stable when  used with the `Fn` family of traits, use parentheses"); span_help!(this.tcx().sess, path.span, "add `#![feature(unboxed_closures)]` to  the crate attributes to enable"); } </ins> convert_angle_bracketed_parameters(this, &shifted_rscope, data) } ast::ParenthesizedParameters(ref data) => {

#![allow(dead_code)] struct Foo; <del> impl Fn<(), ()> for Foo { //~ ERROR manual implementations of `Fn` are experimental </del> <ins> impl Fn() for Foo { //~ ERROR manual implementations of `Fn` are experimental </ins> extern "rust-call" fn call(&self, args: ()) -> () {} } struct Bar; <del> impl FnMut<(), ()> for Bar { //~ ERROR manual implementations of `FnMut` are experimental </del> <ins> impl FnMut() for Bar { //~ ERROR manual implementations of `FnMut` are experimental </ins> extern "rust-call" fn call_mut(&self, args: ()) -> () {} } struct Baz; <del> impl FnOnce<(), ()> for Baz { //~ ERROR manual implementations of `FnOnce` are experimental </del> <ins> impl FnOnce() for Baz { //~ ERROR manual implementations of `FnOnce` are experimental </ins> extern "rust-call" fn call_once(&self, args: ()) -> () {} }

#![allow(dead_code)] <del> fn foo<F: Fn<(), ()>>(mut f: F) { </del> <ins> fn foo<F: Fn()>(mut f: F) { </ins> f.call(()); //~ ERROR explicit use of unboxed closure method `call` f.call_mut(()); //~ ERROR explicit use of unboxed closure method `call_mut` f.call_once(()); //~ ERROR explicit use of unboxed closure method `call_once`

#![allow(dead_code)] <del> fn foo<F: Fn<(), ()>>(mut f: F, mut g: F) { </del> <ins> fn foo<F: Fn()>(mut f: F, mut g: F) { </ins> Fn::call(&g, ()); //~ ERROR explicit use of unboxed closure method `call` FnMut::call_mut(&mut g, ()); //~ ERROR explicit use of unboxed closure method `call_mut` FnOnce::call_once(g, ()); //~ ERROR explicit use of unboxed closure method `call_once`

<ins> // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // Test that the `Fn` traits require `()` form without a feature gate. fn bar1(x: &Fn<(),()>) { //~^ ERROR angle-bracket notation is not stable when used with the `Fn` family } fn bar2<T>(x: &T) where T: Fn<(),()> { //~^ ERROR angle-bracket notation is not stable when used with the `Fn` family } fn main() { } </ins>