let unit: String = call
        .get_flag::<String>(engine_state, stack, "unit")
        .unwrap()
        .unwrap_or("ns".into())
        .clone();

error[E0507]: cannot move out of `unit`, a captured variable in an `FnMut` closure
   --> crates/nu-command/src/conversions/into/duration.rs:152:28
    |
143 |     let unit: String = call
    |         ---- captured outer variable
...
150 |         move |v| {
    |         -------- captured by this `FnMut` closure
151 |             if column_paths.is_empty() {
152 |                 action(&v, unit, span)
    |                            ^^^^ move occurs because `unit` has type `std::string::String`, which does not implement the `Copy` trait

            .named(
                "unit",
                SyntaxShape::String,
                "Unit to convert number into",
                Some('u'),
            )

    let unit = match call.get_flag::<String>(engine_state, stack, "unit")? {
        Some(sep) => {
            if ["ns", "us", "µs", "ms", "sec", "min", "hr", "day", "wk"]
                .iter()
                .any(|d| d == &sep)
            {
                sep
            } else {
                return Err(ShellError::CantConvertToDuration {
                    details: sep,
                    dst_span: span,
                    src_span: span,
                    help: Some(
                        "supported units are ns, us/µs, ms, sec, min, hr, day, and wk".to_string(),
                    ),
                });
            }
        }
        None => "ns".to_string(),
    };

    input.map(
        move |v| {
            if column_paths.is_empty() {
                action(&v, &unit.clone(), span)
            } else {
                let unitclone = &unit.clone();
                let mut ret = v;
                for path in &column_paths {
                    let r = ret.update_cell_path(
                        &path.members,
                        Box::new(move |old| action(old, &unitclone, span)),
                    );
                    if let Err(error) = r {
                        return Value::error(error, span);
                    }
                }

                ret
            }
        },
        engine_state.ctrlc.clone(),
    )

fn action(input: &Value, unit: &str, span: Span) -> Value {