```

首先, A得具有ownership，像切片这种类型本身是另外一个类型的片段数据，没有ownership，就没法用into_string这个方法
切片的传值、传参，只能是将自己指向的地址传递过去，让另外一个变量指向自己指向的地址，所有切片传参一定是这样的 aaa(&name)，有一个&

```
    

 
```
let B = A.into_string();
调用之后，A就不能再用了，以后生效的只有B
```

它们的方法定义
```
to_string：
fn to_string(&self) -> String;

into_string：
fn into_string(self) -> String;

```
    

identity_cols列表要重复很多次的to_string方法

 
```
impl Default for FeatureConfig {
    fn default() -> Self {
        Self {
            time_col: "DT_TIME".to_string(),
            price_col: "AMT".to_string(),
            balance_col: "ACCBAL".to_string(),
            amount_col: "CNY_AMT".to_string(),
            identity_cols: vec![
                "ACCT_NUM".to_string(),
                "PARTY_ID".to_string(),
                "OPP_PARTY_ID".to_string(),
                "ACCT".to_string(),
                "TCAC".to_string(),
                "TSTM".to_string(),
            ],
        }
    }
}
```

使用 map 和 collect

 
```
identity_cols: vec!["ACCT_NUM", "PARTY_ID", "OPP_PARTY_ID", "ACCT", "TCAC", "TSTM"]
    .iter()
    .map(|s| s.to_string())
    .collect(),
```

定义辅助函数

 
```
fn str_vec_to_string(strings: &[&str]) -> Vec<String> {
    strings.iter().map(|s| s.to_string()).collect()
}

// 使用
identity_cols: str_vec_to_string(&["ACCT_NUM", "PARTY_ID", "OPP_PARTY_ID", "ACCT", "TCAC", "TSTM"]),
```

使用宏（更灵活）

 
```
macro_rules! str_vec {
    ($($s:expr),*) => {
        vec![$($s.to_string()),*]
    };
}

// 使用
identity_cols: str_vec!["ACCT_NUM", "PARTY_ID", "OPP_PARTY_ID", "ACCT", "TCAC", "TSTM"],
```

如果使用 const 或 static

 
```
const IDENTITY_COLS: &[&str] = &["ACCT_NUM", "PARTY_ID", "OPP_PARTY_ID", "ACCT", "TCAC", "TSTM"];

// 使用时
identity_cols: IDENTITY_COLS.iter().map(|s| s.to_string()).collect(),
```

- 推荐使用方法1（map + collect），因为它最简洁且不需要额外的定义。宏方式虽然最简洁，但可能影响代码可读性。

 
```
fn  add_one_v1   (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x|             { x + 1 };
let add_one_v4 = |x|               x + 1  ;

```
    

参数默认为同一类型

 
```
pub fn test3() {
    let example_closure = |x| x;

    let s = example_closure(String::from("hello"));
    let n = example_closure(5);
}
```

```
--> src/base/k_closure.rs:53:29
|
53 |     let n = example_closure(5);
|                             ^
|                             |
|                             expected struct `String`, found integer
|                             help: try using a conversion method: `5.to_string()`
```
    
The first time we call example_closure with the String value, 
the compiler infers the type of x and the return type of the closure to be String. 
Those types are then locked into the closure in example_closure, 
and we get a type error if we try to use a different type with the same closure.

不换数据类型,下面的是正确的

 
```
pub fn test3() {
    let example_closure = |x| x;

    let s = example_closure(6);
    println!("{}",s);
    let n = example_closure(5);
    println!("{}",n);
}
```
    

Capturing the Environment with Closures

Closures默认是引用或只使用一次,不具有ownership，因此后面还可以用x

 
```
pub fn test1() {
    let x = 4;
    let equal_to_x = |z| z == x;
    let y = 4;

    assert!(equal_to_x(y));
    println!("{}", x);  //4
}
```

move:让Closures获取所有相关变量的ownership,后续不可再用

 
If you want to force the closure to take ownership of the values it uses in the environment, 
you can use the move keyword before the parameter list. 
This technique is mostly useful when passing a closure to a new thread to move the data 
so it’s owned by the new thread.

Note: move closures may still implement Fn or FnMut, even though they capture variables by move. 
This is because the traits implemented by a closure type 
are determined by what the closure does with captured values, not how it captures them. 
The move keyword only specifies the latter.

Traits: Defining Shared Behavior