Rust 编程:道-类型系统

类型系统

基本类型

一切皆表达式，表达式皆有值，值皆有类型，所以一切皆类型。
包括：

• 基本类型
• 复合类型
• 作用域
• 返回值
  • Option＜T＞
  • Result＜T，E＞

编程语言中不同的类型本质上是内存占用空间和编码方式的不同，Rust也不例外。

Rust中绝大部分类型都是在编译期可确定大小的类型（Sized Type），如u8，f64等

Rust也有少量的动态大小的类型（Dynamic Sized Type，DST），如str

对于动态类型，Rust提供了引用方式来解决，引用类型存在栈空间，具体内容存在堆空间。

例如：

包含了动态大小类型地址信息和携带了长度信息的指针，叫作胖指针（Fat Pointer），&str就是胖指针。

有如下代码

fn test(mut arr:[u32]){
	arr[1] = 5;
	arr[2] = 1;
}
fn main(){
	let arr:[u32]= [1,2,4,5,6];
	test(arr);
}

以上代码编译会出错

表示期望切片类型，找到的是数组类型，做如下修改可通过编译

fn test(mut arr:[u32;5]){
	arr[1] = 5;
	arr[2] = 1;
}
fn main(){
	let arr:[u32;5]= [1,2,4,5,6];
	test(arr);
    println!("{:?}",arr);// 1 2 4 5 6
}

这样类型就匹配了，但是arr结果并没有被改变，其实是因为传入的参数通过shadow机制在栈空间创建了一个新的arr，所以并不会改变原来的值。可以类比C语言的值传递swap(a,b)，结果并不会交换a，b。

c语言解决方法是传入a，b的指针，Rust也一样，传入可变引用，即胖指针即可

fn reverse(arr:&mut [u32]){
    arr[0] = 3;
	arr[1] = 2;
	arr[2] = 1;
    println!("len : {}",arr.len());
}
fn main(){
	let mut arr= [1,2,3];//[u32;3]
	reverse(&mut arr);//传入的引用包含了大小，编译器解决
    println!("{:?}",arr);
}

可以查看占用内容大小

fn main(){
    println!("{}",std::mem::size_of::<&mut [u32]>());//16
    println!("{}",std::mem::size_of::<& [u32;3]>());//8
}

胖指针由来。

ZST类型

除了可确定大小类型和DST类型，Rust还支持零大小类型（Zero Sized Type，ZST），比如单元类型和单元结构体，大小都是零。

以下都为ZST类型

enum void {}
struct foo;
struct Baz{
    f:foo,
    q:(),
    buf:[u16;0],
    em:void,
}
fn main(){
    println!("{}",std::mem::size_of::<void>());//0
    println!("{}",std::mem::size_of::<foo>());//0
    println!("{}",std::mem::size_of::<Baz>());//0
    println!("{}",std::mem::size_of::<[();32]>());//0
}

底类型

如never类

zst是空，底类型是无。

• 没有值。
• 是其他任意类型的子类型
• 用！表示

以下返回底类型：

• 发散函数（Diverging Function）
• continue和break关键字
• loop循环
• 空枚举，比如enum Void{}

以下代码正常执行

fn foo()->!{
    loop { }
}
fn main(){
    let a = if false{
        foo()
    }else{
        100
    };
    print!("{}",a);
}

因为！是所有类型的子类型。

以下不可

enum Void {}
fn main(){
    let  res:Result<u32,Void> = Ok(0);
    let Ok(num) = res;
}

Rust中使用Result类型来进行错误处理，强制开发者处理Ok和Err两种情况，但是有时可能永远没有Err，这时使用enum Void{}就可以避免处理Err的情况。

但是可惜的是，当前版本的Rust还不支持上面的语法，编译会报错。不过Rust团队还在持续完善中，在不久的将来Rust就会支持此用法。

类型推断

Rust支持类型推断，但其功能并不像Haskell那样强大，Rust只能在局部范围内进行类型推导

fn add(a:u32,b:u32)->u32{
    a b
}

fn main(){
    let a = 1;
    let b = 2;
    add(a, b);
}

Turbofish操作符

fn main(){
   let x = "1";
   print!("{:?}",x.parse::<i32>().unwrap());
     
}

::<>就是Turbofish操作符

不完善

fn main(){
   let x = 0;
   let flag = x.is_positive();
}

can’t call method is_positive on ambiguous numeric type {integer}

泛型

泛型（Generic）是一种参数化多态。使用泛型可以编写更为抽象的代码，减少工作量。简单来说，泛型就是把一个泛化的类型作为参数，单个类型就可以抽象化为一簇类型。

即把类型作为参数。

泛型可以用在，函数，结构体，使用泛型必须声明<T>

struct Point<T>{
    x:T,
    y:T,
}
fn get_x<T>(x:T) -> T{
    x
} 

为泛型结构体实现方法impl＜T＞

struct Message<T>{
    content:T,
}
impl <T> Message<T> {
    fn new(content:T)->Self{
        Message { content }
    }
}

Rust中的泛型属于静多态，它是一种编译期多态。在编译期，不管是泛型枚举，还是泛型函数和泛型结构体，都会被单态化

（Monomorphization）。单态化是编译器进行静态分发的一种策略

泛型及单态化是Rust的最重要的两个功能。单态化静态分发的好处是性能好，没有运行时开销；缺点是容易造成编译后生成的二进制文件膨胀。这个缺点并不影响使用Rust编程。

返回值推导

struct Foo(i32);
struct Bar(i32,i32);

trait Instance {
    fn new(i:i32) -> Self;
}

impl Instance for Foo {
    fn new(i:i32) -> Foo {
        Foo(i)
    }
}
impl Instance for Bar{
    fn new(i:i32)->Self{//Self指结构体本身
        Bar(i,i 10)
    }
}
fn foobar<T:Instance>(i:i32) -> T{//表明T是实现了Instance trait的结构体
    T::new(i)
}

fn main(){
    let f:Foo = foobar(10);
    let b:Bar = foobar(20);
}

深入Trait

可以说trait是Rust的灵魂。Rust中所有的抽象，比如接口抽象、OOP范式抽象、函数式范式抽象等，均基于trait来完成。同时，trait也保证了这些抽象几乎都是运行时零开销的。

从类型系统的角度来说，trait是Rust对Ad-hoc多态的支持。从语义上来说，trait是在行为上对类型的约束，这种约束可以让trait有如下4种用法：

• 接口抽象。对类型行为的统一约束。
• 泛型约束。泛型的行为被trait限定在更有限的范围内。
• 抽象类型。在运行时作为一种间接的抽象类型去使用，动态地分发给具体的类型。
• 标签trait。对类型的约束，直接作为标签使用。

接口抽象

特点：

• 接口中定义方法，并支持默认实现。

• 接口中不能实现另一个接口，但接口间可以继承。

• 同一个接口可以被多个类型实现，但不能被同一个类型实现。

• 使用impl关键字为类型实现接口方法。

• 使用trait关键字定义接口。

  

trait T_A{
    fn say(msg:&str)->String;
}
struct A;
struct B;
enum C{
}

impl T_A for A{
    fn say(msg:&str)-> String{
        let t = "A".to_string();
        t   msg
    }
}
impl T_A for B{
    fn say(msg:&str)->String{
        let t = "B".to_string();
        t   msg
    }
}
impl T_A for C{
    fn say(msg:&str)->String{
        let t = "C".to_string();
        t   msg
    }
}


fn main(){

}

加减乘除等也是一种trait

trait Add<RHS,Output>{
    fn my_add(self,rhs:RHS) -> Output;
}
impl Add<i32,i32> for i32 {
    fn my_add(self,rhs:i32)->i32{
        self   rhs
    }
}

impl Add<u32,i32> for u32{
    fn my_add(self,rhs:u32) -> i32{
        (self   rhs) as i32
    }
}

fn main(){
    let (a,b,c,d) = (1i32,2i32,3u32,4u32);
    let x:i32 = a.my_add(b);
    let y:i32 = c.my_add(d);
    assert_eq!(x,3i32);
    assert_eq!(y,7i32);
}

RHS是 的右侧值类型，Output是输出类型。

对于Add，加法的输入与输出值应该为同一类型，所以Add<RHS,Output>的output有点多余，于是有以下写法

pub trait Add<RHS =Self >{// 指定RHS的默认值为Self
    type Output;
    fn add(self,rhs:RHS) -> Self::Output;
}

type Output 叫关联类型，Self是每个trait都带有的隐式类型参数。

impl Add<&str> for String{
    type Output = String;
    fn add(mut self,other:&str) -> String{
        self.push_str(other);
        self
    }
}

trait一致性

可以实现操作符重载。

如想要实现u32 u64

use std::ops::Add;
impl Add<u64> for u32{
    type Output = u64;
    fn add(self,other:u64) -> Self::Output{
        (self as u64)   other
    }
}
 

fn main(){
    let a = 1u32;
    let b = 2u64;
    println!("{}",a b);
}

编译报错。

这是因为Rust遵循一条重要的规则：孤儿规则（Orphan Rule）。孤儿规则规定，如果要实现某个trait，那么该trait和要实现该trait的那个类型至少有一个要在当前crate中定义

Add trait和u32、u64都不是在当前crate中定义的，而是定义于标准库中的。如果没有孤儿规则的限制，标准库中u32类型的加法行为就会被破坏性地改写，导致所有使用u32类型的crate可能产生难以预料的Bug。

解决如下，讲Add trait 定义在当前crate就可以了，当然可以不一定叫Add，和add（）

 trait Add<RHS =Self >{
    type Output;
    fn add(self,rhs:RHS) -> Self::Output;
}
impl Add<u64> for u32{
    type Output = u64;
    fn add(self,other:u64) -> Self::Output{
        (self as u64)   other
    }
}

fn main(){
    let a = 1u32;
    let b = 2u64;
    println!("{}",a.add(b));
}

对其他类型实现trait

 use std::ops::Add;
#[derive(Debug)]
 struct Point{
     x:i32,
     y:i32,
 }
 impl Add for Point  {
     type Output = Self;
     fn add(self,other:Point) -> Self::Output{
         Point{
             x:self.x other.x,
             y:self.y other.y,
         }
     }
 }

fn main(){
    let p1 = Point{
        x:1,
        y:2,
    };
    let p2 = Point{
        x:2,
        y:3,
    };
    println!("{:?}",p1 p2);
}

trait 继承

Rust不支持传统面向对象的继承，但是支持trait继承。子trait可以继承父trait中定义或实现的方法。在日常编程中，trait中定义的一些行为可能会有重复的情况，使用trait继承可以简化编程，方便组合，让代码更加优美。

例如web中常用的分页

trait Page{
    fn set_page(&self, p:i32){
        println!("Page Default 1");
    }
}
trait PerPage{
    fn set_perpage(&self, num:i32){
        println!("Per Page Default 10");
    }
}
struct MyPaginate{page:i32}
impl Page for MyPaginate {}
impl PerPage for MyPaginate {}
fn main(){
    let my_paginate = MyPaginate{page:1};
    my_paginate.set_page(2);
    my_paginate.set_perpage(100);
}

给MyPaginate实现了两个trait。

如果要再实现一个跳转功能，可以使用继承

trait Paginate: Page   PerPage{//继承写法 ：trait
    fn set_skip_page(&self,num:i32){
        println!("skip to page {}",num);
    }
}
impl <T:Page PerPage> Paginate for T {}//T为泛型，类型为实现了Page PerPage的类型，整句话表示为实现了T的类型实现Paginate
fn main(){
    let my_paginate = MyPaginate{page:1};
    my_paginate.set_page(2);
    my_paginate.set_perpage(100);
    my_paginate.set_skip_page(12);//skip to page 12
}

优点是添加了新功能再不影响之前功能的情况下。

trait约束

很多情况下，一个行为并不是为所有类型实现的。比如：

fn sum<T>(a:T,b:T)->T{//编译不通过
    a b
}

整型相加可以，字符串相加可以，但是整型与bool类型，就不行。

可以限制T为可加类型

use std::ops::Add;
fn sum<T:Add<T,Output=T>>(a:T,b:T)->T{//限制T的类型为实现了Add的类型
    a b
}

fn main(){
    let a = 1;
    let b = 2;
    let c = sum(a, b);
    println!("{}",c);
}

使用trait对泛型进行约束，叫作trait限定（trait Bound）。格式如下

fn generic<T: MyTrait   MyOtherTrait   SomeStandTrait>(t:T){}

泛型限定是许多语言都有概念，是Structural Typing的变种，Rust中的trait限定也是Structural Typing的一种实现。

也可以从数学的角度理解trait限定，例如

trait Paginate: Page   PerPage{}

注意：

如果有trait A,B,C，A，B，C中的方法不能同名，

不能覆盖，

C：A B，为某类型实现C必须要实现A和B。否则报错。

trait A {
    fn getA(&self,i:i32){
        println!("A : {}",i);
    }
}
trait B {
    fn getB(&self,i:i32){
        println!("B : {}",i);
    }
}
trait C:A B {
    fn getC(&self,i:i32){
        println!("C : {}",i);
    }
}
impl A for Test {}
impl B for Test {}
// impl  C for Test {}
impl <T> C for T
where T:A B
{} 
struct Test{
    a:i32,
}
 
 
fn main(){
    let test =  Test{a:1};
    test.getB(2);
    test.getA(1);
    test.getC(3);
  
}

抽象类型

相对于具体类型而言，抽象类型无法直接实例化，它的每个实例都是具体类型的实例。

对于抽象类型而言，编译器可能无法确定其确切的功能和所占的空间大小。所以Rust目前有两种方法来处理抽象类型：trait对象和impl Trait。

trait对象

use std::fmt::Debug;

 
#[derive(Debug)]
struct Foo;

#[derive(Debug)]
struct  Fun;

trait Bar{
    fn baz(&self);
}
impl Bar for Foo{
    fn baz(&self){
        println!("{:#?}",self);
    }
}
impl Bar for Fun{
    fn baz(&self){
        println!("{:#?}",self);
    }
}
fn static_dispatch<T>(t:&T)
where T:Bar{
    t.baz();
}
fn dynamic_dispatch(t:&dyn Bar){//动态分发
    t.baz();
}
fn main(){
    let foo = Foo;
    let fun = Fun;
    static_dispatch(&foo);
    static_dispatch(&fun);
    dynamic_dispatch(&foo);
    dynamic_dispatch(&fun);
}

动态分发

trait本身也是一种类型，但它的类型大小在编译期是无法确定的，所以trait对象必须使用指针。可以利用引用操作符&或 Box＜T＞来制造一个 trait 对象。trait 对象等价代码如下结构体

pub struct TraitObject{
    pub data: *mut (),
    pub vtable: *mut (),
} 

TraitObject 在栈区，数据指针指向堆区数据部分，vtable 名称来自C ，保护了析构函数，大小，函数等信息。

在编译器TraitObject不知道调用哪个方法，但是指针的大小确定，在运行器通过trait_object.method()可以知道函数的指针，然后进行调用。

类比java继承父类可以调用子类的实现。

并不是每个trait都可以作为trait对象被使用，这依旧和类型大小是否确定有关系。每个trait都包含一个隐式的类型参数Self，代表实现该trait的类型。Self默认有一个隐式的trait限定？Sized，形如＜Self：？Sized＞，？Sized trait 包括了所有的动态大小类型和所有可确定大小的类型。Rust 中大部分类型都默认是可确定大小的类型，也就是＜T：Sized＞，这也是泛型代码可以正常编译的原因。

必须同时满足以下两条规则的trait才可以作为trait对象使用

· trait的Self类型参数不能被限定为Sized。
· trait中所有的方法都必须是对象安全的。

简单来说，要将trait作为trait对象就不加限制，否则就加上Sized

trait A:Sized{
 //code
}

安全的trait对象实例

 trait Bar{
    fn bax(self,x:u32);
    fn baz(&mut self);
 }

不安全的trait对象实例

trait Foo{
     fn bad<T>(&self,x:T);
     fn new() ->Self;//Self是unsized
 }

1. 拆分

 trait Foo{
     fn bad<T>(&self,x:T);
 }
 trait Foo:Bar{
    fn new() ->Self;//Self是Bar继承的
}

2. 使用where限定

trait Foo{
    fn bad<T>(&self,x:T);
    fn new()->Self where Self:Sized;
}

impl Trait

在Rust 2018版本中，引入了可以静态分发的抽象类型impl Trait。如果说trait对象是装箱抽象类型（Boxed Abstract Type）的话，那么impl Trait就是拆箱抽象类型（Unboxed Abstract Type）。“装箱”和“拆箱”是业界的抽象俗语，其中“装箱”代表将值托管到堆内存，而“拆箱”则是在栈内存中生成新的值，目前impl Trait只可以在输入的参数和返回值这两个位置使用，在不远的将来，还会拓展到其他位置，比如let定义、关联类型等.

例如

use std::fmt::Debug;


pub trait Fly {
    fn fly(&self) ->bool;
}

#[derive(Debug)]
struct Duck;

#[derive(Debug)]
struct Pig;

impl Fly for Duck {
    fn fly(&self)->bool{
        return true;
    }
}
impl Fly for Pig{
    fn fly(&self) -> bool{
        return false;
    }
}

fn fly_static(s: impl Fly Debug) ->bool{
    s.fly()
}
fn can_fly(s:impl Fly Debug) -> impl Fly{
    if s.fly(){
        println!("{:?} can fly",s);
    }else {
        println!("{:?} can't fly",s);
    }
    s
}
fn main() {
    let pig = Pig;
    assert_eq!(fly_static(pig),false);
    let pig = Pig;
    let pig = can_fly(pig);
    let duck = Duck;
    assert_eq!(fly_static(duck),true);
    let duck = Duck;
    let duck = can_fly(duck);
}

将impl Trait语法用于参数位置的时候，等价于使用trait限定的泛型。

let a: impl Trait 是不允许的。

另外，impl Trait只能用于为单个参数指定抽象类型，如果对多个参数使用implTrait语法，编译器将报错

use std::ops::Add;
fn sum<T>(a:impl Add<Output = T>,b:impl Add<Output = T>)->T{
    a   b
}

impl 与 dyn是对应的，一个静态，一个动态。

标签trait

trait 这种对行为约束的特性也非常适合作为类型的标签。

Rust一共提供了5个重要的标签trait，都被定义在标准库std：：marker模块中,分别为：

· Sized trait，用来标识编译期可确定大小的类型。
· Unsize trait，目前该trait为实验特性，用于标识动态大小类型（DST）。
· Copy trait，用来标识可以按位复制其值的类型。
· Send trait，用来标识可以跨线程安全通信的类型。
· Sync trait，用来标识可以在线程间安全共享引用的类型。

#[stable(feature = "rust1", since = "1.0.0")]
#[lang = "sized"]
pub trait Sized {
    // Empty.
}

这里真正起“打标签”作用的是属性＃[lang=＂sized＂],该属性lang表示Sized trait供Rust语言本身使用，声明为＂sized＂，称为语言项（Lang Item），这样编译器就知道Sized trait如何定义了。

默认为Sized，否则

struct Bar<T:?Sized>(T);

Copy trait 继承Clone

#[lang = "copy"]
pub trait Copy: Clone {
    // Empty.
}

#[lang = "clone"]
pub trait Clone: Sized {
    fn clone(&self) -> Self;
    #[inline]
    #[stable(feature = "rust1", since = "1.0.0")]
    fn clone_from(&mut self, source: &Self) {
        *self = source.clone()
    }
}

Rust为很多基本数据类型实现了Copy trait，比如常用的数字类型、字符（Char）、布尔类型、单元值、不可变引用等

Rust提供了Send和Sync两个标签trait，它们是Rust无数据竞争并发的基石。

类型转换

在编程语言中，类型转换分为隐式类型转换（Implicit Type Conversion）和显式类型转换（Explicit Type Conversion）。隐式类型转换是由编译器或解释器来完成的，开发者并未参与，所以又称之为强制类型转换（Type Coercion）。显式类型转换是由开发者指定的，就是一般意义上的类型转换（Type Cast）。

Deref解引用

Rust中的隐式类型转换基本上只有自动解引用。自动解引用的目的主要是方便开发者使用智能指针。Rust 中提供的 Box＜T＞、Rc＜T＞和 String 等类型，实际上是一种智能指针。

引用符&,解引用*

解引用可以自己实现，只要实现了Deref Trait 即可实现类型转换。

Deref的定义，

pub trait Deref {
    type Target: ?Sized;
    fn deref(&self) -> &Self::Target;
}

DerefMut，返回的是可变应用。

解引用例子，字符串连接

fn main(){
    let s1 = "12".to_string();
    let s2 = "34".to_string();
    let s3 = s1   &s2;
    println!("{}",s3);

}

s1,s2都是String类型，&s2应该是&String,期望的是&str，也就是说应该会报错，可是以上代码正常执行，就是因为String实现了解引用，

impl Deref for String {
    type Target = str;
    fn deref(&self) -> &str{
        unsafe{str::from_utf8_unchecked(&self.vec)}
    }
}

标准库中常用的其他类型都实现了Deref，比如Vec＜T＞、Box＜T＞、Rc＜T＞、Arc＜T＞等。实现Deref的目的只有一个，就是简化编程。

解引用实例

use std::rc::Rc;
fn test_vec(s:&[i32]){
    println!("{:?}",s);
}

fn test_rc(){
    let x = Rc::new("hello");
    println!("{}",x);
}
fn main(){
   let v = vec![1,2,3];
   test_vec(&v);
   test_rc();
}

手动解引用

当某类型和其解引用目标类型中包含了相同的方法时，编译器就不知道该用哪一个了。此时就需要手动解引用，

fn test_deref(){
    let x = Rc::new("hello");
    let y = x.clone();//&Rc<&str>
    let z = (*x).clone();//&str
}

因为Rc和str都实现了clone，所以不能自动解引用。

match需要手动解引用

fn test_str(){
    let s = "1234".to_string();
    match &s[..]{
        "1234" => println!("hello"),
        _ => {}
    }
}

有如下几种方式：

• match x.deref()
• match x.as_ref()
• match x.borrow()
• match &*x
• match &x[…]

as 操作

as 操作符最常用的场景就是转换 Rust 中的基本数据类型。需要注意的是，as 关键字不支持重载。

fn main(){
    let a = 1u32;
    let b = a as u64;
    let c = 3i64;
    let d = c as u32;
    print!("a{},b{},c{},d{}",a,b,c,d);
}

长类型转短类型截断。

fn main(){
   let a = u32::MAX;
   let b = a as u16;
   println!("a:{},b:{}",a,b);//a:4294967295,b:65535
}

as 还可以消除语法歧义。

#[derive(Debug)]
struct C;
trait A {
    fn test(&self);
} 
trait B {
    fn test(&self);
}
impl A for C {
    fn test(&self){
        println!("A:{:?}",self);
    }
}
impl B for C {
    fn test(&self){
        println!("B:{:?}",self);
    }
}

fn main(){
   let c = C;
    A::test(&c);
    B::test(&c);
    <C as A>::test(&c);
    <C as B>::test(&c);
}

类型和子类型相互转换

as转换还可以用于类型和子类型之间的转换。Rust中没有标准定义中的子类型，比如结构体继承之类，但是生命周期标记可看作子类型。比如&＇static str类型是&＇a str类型的子类型，因为二者的生命周期标记不同，＇a 和＇static 都是生命周期标记，其中＇a 是泛型标记，是&str的通用形式，而＇static则是特指静态生命周期的&str字符串。

fn main(){   
    let a:&'static str = "hello";
    let b:& str = a as &str;
    let c:&'static str = b as &'static str;
}

From和Into

From和Into是定义于std：：convert模块中的两个trait。它们定义了from和into两个方法，这两个方法互为反操作。

定义

pub trait From<T>: Sized {
    /// Performs the conversion.
    #[lang = "from"]  
    fn from(_: T) -> Self;
}

pub trait Into<T>: Sized {
    /// Performs the conversion.
    #[must_use]
    fn into(self) -> T;
}

关于Into有一条默认的规则：如果类型U实现了From＜T＞，则T类型实例调用into方法就可以转换为类型U

因为Rust实现了

impl<T,U> Into<U> for T where U:From<T>

当前trait系统的不足

· 孤儿规则的局限性。
· 代码复用的效率不高。
· 抽象表达能力有待改进。

这篇好文章是转载于：学新通技术网