Rust 由于需求冲突，无法推断自动强制的适当生存期

我得到了这个错误——“由于需求冲突，无法推断自动强制的适当生存期”。然而，我已经尝试明确地强制执行

start\u duty

要求

error.rs:45:1: 55:2 note: consider using an explicit lifetime parameter as shown: fn start_duty<'dutylife>(duty: &'dutylife Duty) -> &'dutylife Job<'dutylife>
error.rs:45 fn start_duty<'dutylife> (duty: &'dutylife Duty) -> &'dutylife Job {
error.rs:46 
error.rs:47     let j : Job = Job {
error.rs:48         duty: duty,
error.rs:49         output: "".to_string(),
error.rs:50         success: JobNotDone
            ...
error.rs:48:15: 48:19 error: cannot infer an appropriate lifetime for automatic coercion due to conflicting requirements
error.rs:48         duty: duty,
                          ^~~~
error: aborting due to previous error

<代码> >错误：RS:45∶:55∶2注释：考虑使用显式生命周期参数，如：fn StastRealTevice和DutyLealWork（职责：& dutyLealthCurvivices）->和'dutyLealsPosivi] 错误。rs:46 错误。rs:47设j:Job=Job{ 错误。rs:48职责：职责， 错误。rs:49输出：“”。到_字符串（）， 错误。rs:50成功：作业未完成 ... 错误。rs:48:15:48:19错误：由于需求冲突，无法推断自动强制的适当生存期 错误。rs:48职责：职责， ^~~~ 错误：由于上一个错误而中止 导致错误的代码的某种删除版本。从概念上讲，我试图做的是生成一个引用职责的新作业。作业只能在职责的生命周期内存在；当职责消失时，该作业也应该存在

enum Source {
    Nothing,                        // Nothing
    Git(String, String),            // reponame, refname
    Hg(String, String),             // reponame, csid
    Url(String)                     // curl down what's here
}

enum JobResult {
    JobNotDone,
    JobSuccess,
    JobFailure,
    JobError
}

/*
Jobs

Jobs are always attached to the Duty that spawned them; there can be
no Job without the duty. So we take a lifetime param of the duty reference
*/
struct Job<'r> {
    duty:  &'r Duty,            // pointer back to
    output: String,             // no output = ""
    success: JobResult
}

enum Action {
    BashScript(String)
}

struct Duty {
    name: String,
    source: Source,
    action: Action,
    comment: Option<String>
}

struct Agent<'r> {
    hostname : String,
    uid : u64,
    job : Option<Job<'r>>,                  // mutable, agents
}

// returns new Job, but with duty referenced.
fn start_duty<'dutylife> (duty: &'dutylife Duty) -> &'dutylife Job {

    let j : Job = Job {
        duty: duty,
        output: "".to_string(),
        success: JobNotDone

    };

    return &j;
}


fn main () {
}

枚举源{
没什么，//没什么
Git（String，String），//reponame，refname
Hg（String，String），//reponame，csid
Url（字符串）//向下卷曲此处的内容
}
枚举作业结果{
作业未完成，
工作成功，
工作失败，
作业错误
}
/*
乔布斯
工作总是附加在产生它们的职责上；可能有
没有工作就没有责任，所以我们把责任作为终身的参照
*/
结构作业>，//可变，代理
}
//返回新作业，但引用了职责。
fn开始工作和终身工作{
让j:Job=Job{
职责:职责,，
输出：“.to_字符串（），
成功：未完成任务
};
return&j；
}
fn main（）{
}

此函数签名承诺返回对作业的引用

fn start_duty<'dutylife> (duty: &'dutylife Duty) -> &'dutylife Job

还有另一个错误，代码试图返回对此函数中创建的作业的引用。我也修复了该错误，代码现在已编译。请告诉我您是否正试图执行此操作

编辑：回应“工作只能在职责的生命周期内存在；当职责消失时，工作也应该存在。”部分

这不能以您尝试过的方式完成，因为当函数结束时，作业对象将不再存在，对它的任何引用都将变得无效

---

最简单的方法是让

职责

拥有在其上工作的

作业

（通过给它一个

选项

或

选项

字段）。这是一种单一所有者的方法。多个所有者要复杂得多，并且会涉及引用计数指针或原始指针。

Hm，我试图返回一个引用，我不想到处传输副本（尽管tbh，不确定最终结果会是什么）.我在考虑你的所有权评论。无论如何，我会去的，当我搞砸的时候，借书人会对我大喊大叫。：）

fn start_duty<'dutylife> (duty: &'dutylife Duty) -> Job<'dutylife> {

    Job {
        duty: duty,
        output: "".to_string(),
        success: JobNotDone
    }

}