As a bonus, here's how to do what you wanted originally using traits:
use std::io::{Read, Cursor};
use std::fs::{File};
trait ReadFn {
fn read<T : Read>(&mut self, T) -> ();
}
fn read_test<G>(mut g : G, pred : bool) where G : ReadFn {
if pred {
g.read(File::open("foo").unwrap());
} else {
g.read(Cursor::new(b"foo"));
}
}
fn main() {
struct MyFn<'a> {
buf : &'a mut String
}
impl<'a> ReadFn for MyFn<'a> {
fn read<T : Read>(&mut self, mut a : T) -> () {
println!("{}", a.read_to_string(self.buf).ok().unwrap());
}
}
let mut s = String::from("");
read_test(MyFn{buf : &mut s}, false); // passing mutable 'closure' variable
println!("{}", s);
}
We use the unit struct 'MyFn' as an argument to the generic function to select the trait implementation to use. Instead of a closure you implement ReadFn for as many different unit-structs as you like, so the unit-struct is effectively a type-level name for the function you want to pass. Now you just pass 'MyFn' to the generic function and it can apply it to all the different readable types you like in that generic function.
Edit: I actually find this solution quite elegant, and the use of traits to pass polymorphic functions makes me wonder it adding higher-kinded-types is complicating the type system unnecessarily. I would be interested to see any motivating examples for HKT, and see how they look using a trait encoding (but let's do that in a different topic).