Having trouble getting HRL working

So it's very possible that what I'm trying to do can't be done, but it all looks like it typechecks and everything, up until the point I try and use it. :smile:

So I have a trait, BatchColumnar<'b>, and its main property is that I can define a method

fn decode<'b, T: BatchColumnar<'b>>(bytes: &'b [u8]) -> &'b [T]

This includes all the usual suspect types, like u64 and i32 and other things that you could obviously just cast the &[u8] to. However, it also includes types like &'c str where 'b: 'c , and &'c [T] where 'b: 'c, T: BatchColumnar<'b>. The whole intended purpose is to allow you to back slices in T with data from bytes.

This is all well and good, and it goes really fast when I use it. For example, the following

#[bench]
fn _batch_bench_u64_str_dec(bencher: &mut Bencher) {

    let test = "hi there, it's me!";
    let vector = (0..256u64).map(|i| (i, test)).collect::<Vec<_>>();
    let mut bytes = Vec::new();
    encode(&vector[..], &mut bytes);

    bencher.bytes = bytes.len() as u64;
    bencher.iter(|| {
        decode::<(u64, &str)>(&bytes[..]);
    });
}

cruises along at 8GB/s, mostly because it isn't really doing anything.

Now, the problem I have is when I want to write something like

fn test<T: BatchColumnar, F:Fn(&[T])>(func: F) {
    // get actual data from somewhere else
    let bytes = vec![0u8; 1024];
    func(decode::<T>(&bytes[..]));
}

clearly BatchColumnar needs a lifetime parameter, the intended lifetime is inside the method, so it seems like it is time for higher-ranked lifetimes. I go and write

fn test<T: for<'r> BatchColumnar<'r>, F:Fn(&[T])>(func: F) {
    // get actual data from somewhere else
    let bytes = vec![0u8; 1024];
    func(decode::<T>(&bytes[..]));
}

and I can't figure out how to call test. For example, writing something like

test(|x: &[&str]| { } );

complains: error: the requirement for<'r> 'r : is not satisfied (expected bound lifetime parameter 'r, found concrete lifetime). Other attempts to use test meet similar fates (or fail to infer the type).

Is this supposed to work? Should I be able to indicate that the lifetime in &str is meant to be flexible in the HRL sense, and I'm just missing the syntax, or is this a no-no, HRL only for closures, etc.

Thanks very much for the help! If all goes well, I'll even show you the implementation, which Mutabah declared to be an "abomonation". I think in a good sense...