如何在Expr::apply闭包中使用带生命周期的类型？

问题描述 #

这段Rust代码无法编译，原因是foo需要满足'static生命周期才能在闭包中使用，但实际上foo的生命周期完全覆盖了整个聚合操作的执行周期。由于这里无法使用作用域线程，有没有办法通过安全或不安全的Rust代码实现这类场景？

use polars::prelude::*;

struct Foo<'a> {
    a: &'a str,
}

fn process<'a>(df: DataFrame, foo: Foo<'a>) -> DataFrame {
    let foo = Arc::new(foo);

    df.lazy()
        .group_by(["idx"])
        .agg([col("col1").apply(move |s| agg_fn(s, foo.clone()), Default::default())])
        .collect()
        .unwrap()
}

fn agg_fn(_s: Series, _foo: Arc<Foo>) -> PolarsResult<Option<Series>> {
    unimplemented!()
}

fn main() {
    let foo = Foo { a: "hello" };
    let df = df!(
        "idx" => [1, 1, 3],
        "col1" => [5.0, 3.0, 1.0],
    )
    .unwrap();

    let result = process(df, foo);
    println!("Result: {result:#}");
}

解决方案 #

方案1：安全重构——改为拥有所有权的类型

最稳妥的解决方式是移除Foo的生命周期依赖，将引用类型替换为拥有所有权的类型（比如把&'a str改成String），这样Foo自然满足'static生命周期要求：

use polars::prelude::*;
use std::sync::Arc;

struct Foo {
    a: String,
}

fn process(df: DataFrame, foo: Foo) -> DataFrame {
    let foo = Arc::new(foo);

    df.lazy()
        .group_by(["idx"])
        .agg([col("col1").apply(move |s| agg_fn(s, foo.clone()), Default::default())])
        .collect()
        .unwrap()
}

fn agg_fn(_s: Series, _foo: Arc<Foo>) -> PolarsResult<Option<Series>> {
    unimplemented!()
}

fn main() {
    let foo = Foo { a: "hello".to_string() };
    let df = df!(
        "idx" => [1, 1, 3],
        "col1" => [5.0, 3.0, 1.0],
    )
    .unwrap();

    let result = process(df, foo);
    println!("Result: {result:#}");
}

方案2：不安全绕过——生命周期转换（谨慎使用）

如果必须保留Foo的引用结构，可以通过std::mem::transmute强制将Arc<Foo<'a>>转换为Arc<Foo<'static>>。但这种方法存在内存安全风险，必须严格保证foo的引用在process函数执行期间始终有效，且转换后的Arc不会泄露到函数外部，否则会引发悬垂引用和未定义行为：

use polars::prelude::*;
use std::sync::Arc;
use std::mem;

struct Foo<'a> {
    a: &'a str,
}

fn process<'a>(df: DataFrame, foo: Foo<'a>) -> DataFrame {
    let foo = Arc::new(foo);
    // 强制转换生命周期为'static
    let foo_static: Arc<Foo<'static>> = unsafe { mem::transmute(foo) };

    df.lazy()
        .group_by(["idx"])
        .agg([col("col1").apply(move |s| agg_fn(s, foo_static.clone()), Default::default())])
        .collect()
        .unwrap()
}

fn agg_fn(_s: Series, _foo: Arc<Foo<'static>>) -> PolarsResult<Option<Series>> {
    unimplemented!()
}

fn main() {
    let foo = Foo { a: "hello" };
    let df = df!(
        "idx" => [1, 1, 3],
        "col1" => [5.0, 3.0, 1.0],
    )
    .unwrap();

    let result = process(df, foo);
    println!("Result: {result:#}");
}

注意事项 #

• 优先选择安全重构方案，这是Rust推荐的实践，能从根源避免内存安全风险。
• 不安全方案仅在你能100%把控引用有效性的场景下使用，任何疏忽都可能导致程序崩溃或数据损坏。

内容的提问来源于stack exchange，提问作者user20738613