Rust基础-关于trait之三

Rust中各种约束和限定主要由trait来表达，可以说trait是rust的灵魂。接上两篇，本篇继续介绍关于trait的内容。

1、采用impl a Trait简化函数返回值声明

例如:

pub fn chain<I, J>(i: I, j: J) -> iter::Chain<<I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter>
    where I: IntoIterator,
          J: IntoIterator<Item = I::Item>
{
    i.into_iter().chain(j)
}

pub fn chain1<I, J>(i: I, j: J) -> impl Iterator//<=====here
    where I: IntoIterator,
          J: IntoIterator<Item = I::Item>
{
    i.into_iter().chain(j)
}
fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5];
    let mut v3 = chain(v1, v2);
    for s in v3.into_iter(){
    println!("{}",&s);
}

chain的返回类型用chain1直接就ok了，当然chain的返回类型的写法不是有错，只是更加的精确，但如果在某些不需要那么精确的情况下，完全就可以用impl a trait来替换。

那么原因是啥呢？

两张截图，自己体会 ：）

同一文件内 

再来看下面的代码：

use std::fmt::{self, Display};
struct node{
    x:i8,
}
impl fmt::Display for node{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({})", self.x)
    }
}
fn fun_trait_result(s:node)->impl Display{
    s.x.to_string()+" from Display trait"
}

fn main() {
    println!("{}",fun_trait_result(node { x: 11 }));
}

 输出

 是的，用->impl Display代替->String 和前面的例子一个意思。

 前面两个例子的完整代码如下：

use std::iter;
use std::vec::IntoIter;

use std::fmt::{self, Display};
struct node{
    x:i8,
}
impl fmt::Display for node{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({})", self.x)
    }
}
fn fun_trait_result(s:node)->impl Display{
    s.x.to_string()+" from Display trait"
}

pub fn chain<I, J>(i: I, j: J) -> iter::Chain<<I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter>
    where I: IntoIterator,
          J: IntoIterator<Item = I::Item>
{
    i.into_iter().chain(j)
}
pub fn chain1<I, J>(i: I, j: J) -> impl Iterator
    where I: IntoIterator,
          J: IntoIterator<Item = I::Item>
{
    i.into_iter().chain(j)
}
fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = vec![4, 5];
    let mut v3 = chain(v1, v2);
    for s in v3.into_iter(){
    println!("{}",&s);
    }
    
    println!("{}",fun_trait_result(node { x: 11 }));
}

let's 继续下一话题

2、采用impl a Trait返回闭包，闭包也可以做参数如下：

fn fun_closure<T>(agr: T)->impl Fn(i8,i8)->i8
 where T:Fn(i8,i8) ->i8,{
    let closure=agr;
    closure
} 

fn main() {
    let a=1;
    let b=1;
    let clos=|x:i8,y:i8|{println!("{}",x+y);x+y};
  
    let y=fun_closure(clos);
    println!{"{}",y(a,b)};

}

例子没有实际用处，只是为了说明impl a trait的特性 。

相关文章

Rust基础-关于trait之一_DarcyZ_SSM的博客-CSDN博客

Rust基础-关于trait之二_DarcyZ_SSM的博客-CSDN博客

Rust基础-关于trait之四-不得不说一下rust fat point_DarcyZ_SSM的博客-CSDN博客

Rust基础-关于trait之五_DarcyZ_SSM的博客-CSDN博客

Rust基础-关于trait之六，动态派发和静态派发的区别