Rust基础-关于trait之三

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

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

例如:

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

pub fn chain1(i: I, j: J) -> impl Iterator//<=====here
    where I: IntoIterator,
          J: IntoIterator
{
    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来替换。

那么原因是啥呢?

两张截图,自己体会 :)

Rust基础-关于trait之三_第1张图片

同一文件内 

Rust基础-关于trait之三_第2张图片

再来看下面的代码:

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: I, j: J) -> iter::Chain<::IntoIter, ::IntoIter>
    where I: IntoIterator,
          J: IntoIterator
{
    i.into_iter().chain(j)
}
pub fn chain1(i: I, j: J) -> impl Iterator
    where I: IntoIterator,
          J: IntoIterator
{
    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(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之六,动态派发和静态派发的区别

你可能感兴趣的:(rust,rust)