Trying implement builder function with slice in rust - rust

Question

I'm trying implement builder function:
extern crate debug;
use std::mem::size_of_val;
#[deriving(Show, PartialEq)]
pub struct A<'a> {
pub a: &'a [i64],
pub b: &'a str,
}
fn build<'a>() -> A<'a> {
return A { a: &[1,2,3], b: "test" };
}
fn main() {
let a = build();
println!("{} - {} - `{:?}`", a, size_of_val(&a), a);
}
But this give me next compile error:
/prsrc/main.rs:16:20: 16:27 error: borrowed value does not live long enough
/prsrc/main.rs:16 return A { a: &[1,2,3], b: "test" };
^~~~~~~
/prsrc/main.rs:15:25: 17:2 note: reference must be valid for the lifetime 'a as defined on the block at 15:24...
/prsrc/main.rs:15 fn build<'a>() -> A<'a> {
/prsrc/main.rs:16 return A { a: &[1,2,3], b: "test" };
/prsrc/main.rs:17 }
/prsrc/main.rs:16:5: 16:41 note: ...but borrowed value is only valid for the statement at 16:4; consider using a `let` binding to increase its lifetime
/prsrc/main.rs:16 return A { a: &[1,2,3], b: "test" };
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
I even try A { a: [1,2,3], b: "test" }, A { a: &'a [1,2,3], b: "test" } and std:rc:Rc::new(A { a: &[1,2,3], b: "test" }) but it still not work.
When I replace &[i64] to Vec<i64>:
fn build<'a>() -> A<'a> {
return A { a: vec![1,2,3], b: "test" };
}
all work right:
A { a: [1, 2, 3], b: test } - 40 - `A<'static>{a: collections::vec::Vec<i64>{len: 3u, cap: 4u, ptr: (0x7f1097426000 as *mut ())}, b: "test"}`
I little confused because as I understand &[i64] implementation should be similar to &str and str work when I replace &[i64] to Vec<i64>.
So how can I implement builder function for slice?

Answer 1

The hint that something is wrong with your lifetimes is here :
fn build<'a>() -> A<'a> { /* ... */ }
You have an output lifetime, but no input lifetime.
The only way this is possible is if your lifetime is in fact 'static, as otherwise it must be linked to at least one of the arguments, which defines it.
So your function should in fact be of type :
fn build() -> A<'static>
But here comes the problem : your two references must thus link to static storage. You are lucky, &str is a special case here. String literals ("test" in your case) are always in static storage. So far so good.
But &[1,2,3] is not in static storage. In fact, this shortcut is equivalent to :
let temp = [1,2,3];
return A { a: &temp, b: "test" };
and now, the lifetime issue becomes obvious.
The fix is quite simple : make the temporary variable explicitly 'static, like this :
fn build() -> A<'static> { //'
static temp: [i64, ..3] = [1,2,3];
return A { a: &temp, b: "test" };
}