对比学习 Go 和 Rust：自定义类型

// MyInt 为具名类型 int 的类型别名，两者将完全相同.
type MyInt = int

// Scores 为无名类型 map[string]float64 的别名.
type Scores = map[string]float64

// Coordinate 是一个匿名结构体的别名.
type Coordinate = struct {
    X, Y float64
}

// Point 是类型别名 Coordinate 的别名.
type Point = Coordinate

// 可以像变量或常量声明那样，成组地声明类型别名.
type (
    SmallInt   = int8
    SmallFloat = float32
)

// MyInt 为具名类型 i32 的类型别名，两者将完全相同.
type MyInt = i32;

// Scores 为无名类型 map[string]float64 的别名.
type Scores = HashMap<String, f64>;

// Coordinate 是一个元组的别名.
type Coordinate = (f64, f64);

// Point 是类型别名 Coordinate 的别名.
type Point = Coordinate;

// MyInt 为基于 int 类型构建的新类型，两者属不同类型.
type MyInt int

// Scores 为基于 map[string]float64 类型构建的新类型.
type Scores map[string]float64

// Coordinate 是一个表示坐标的结构体.
type Coordinate struct {
    X, Y float64
}

// 可以像变量或常量声明那样，成组地定义类型.
type (
    SmallInt   int8
    SmallFloat float32
)

func main() {
    var n MyInt = 33          // 33 为无类型常量，因此可以赋值给 MyInt 类型变量
    fmt.Println(int(n) == 33) // true，要进行比较，需要进行类型转换
    var _ Scores = Scores{
        "张三":  91.0,
        "李四":  69.4,
        "王老五": 77,
    }
    var _ Coordinate = Coordinate{33.4, 58.9}
}

let _: () = (); // 没有任何字段的元组为空元组，其类型也称作单元或单元类型，其值也称作单元或单元值
let _: (i32,) = (33,); // 一元元组，为了和括号表达式区分，字段后面的逗号是不可省略的

let mut c: (f64, f64, f64) = (33.4, 58.1, 52.3); // 三元元组
c.1 = 47.8; // 通过索引访问元组的字段
assert_eq!(c, (33.4, 47.8, 52.3));

let t1: (i32, &str) = (33, "张三");
let (n, s): (i32, &str) = t1; // 通过模式匹配快速解构元组的元素
let t2: (&str, i32) = (s, n); // t1, t2 属于不同类型的元组
println!("{:?}", t2); // ("张三", 33);

let mut c: (f64, f64, f64) = (33.4, 58.1, 52.3);
let n = 1;
c.n = 47.8; // 错误：no field n on type (f64, f64, f64)

a, b := 33, 44                     // 通过表达式列表一次性对多个变量赋值
a, b = b, a                        // 交换 a, b 的值
fmt.Printf("a: %d, b: %d\n", a, b) // a: 44, b: 33

let (mut a, mut b) = (33, 44); // 通过模式匹配一次性对多个变量赋值
(a, b) = (b, a); // 交换 a, b 的值
println!("a: {}, b: {}", a, b); // a: 44, b: 33

package main

import (
    "fmt"
    "reflect"
    "time"
)

type empty struct{} // 空结构体

type student struct {
    id           int
    name         string
    class, major string // 两个相同类型可以成组声明
    birthdate    time.Time
}

type coordinate struct {
    // 字段声明的后方可以可选地添加任意一个字符串（通常表示为原始字符串），即为标签（tag）。
    // 标签是该字段的属性（attribute）。当没有添加标签时，默认为 ""。
    x float64 `json:"x" xml:"x"`
    y float64 `json:"y" xml:"y"`
}

type coordinate3D struct {
    // 嵌入另外一个匿名的结构体字段，其该字段名称默认为类型名称 coordinate，
    // coordinate 的字段（及方法） X 和 Y 将被提升为 coordinate3D 的字段（及方法）
    coordinate
    z float64
}

func main() {
    var _ empty = empty{}         // 初始化一个空结构体
    var _ student = *new(student) // 通过 new 函数初始化结构体，并返回指向结构体的指针
    var _ student = student{}     // 使用 T{} 创建一个所有字段都是零值的结构体
    var _ student = student{      // 使用结构体的复合字面量创建结构体
        id:    111111111,
        name:  "张三",
        class: "2201",
        major: "软件工程",
        birthdate: time.Date(2004, time.December, 21, 0, 0, 0, 0,
            time.FixedZone("UTC+8", 8*60*60)),
    }

    // 使用复合字面量时可以不指定各字段的名称，则按照结构体声明时的字段排序对字段赋值
    var coord1 coordinate = coordinate{3.3, 4.4}

    // 通过反射接口访问字段标签
    ct := reflect.TypeOf(coord1)
    field := ct.Field(0)
    fmt.Println(field.Tag.Get("json"), field.Tag.Get("xml")) // x x

    // 先生成一个指向零值结构体的指针，再对各个字段进行赋值
    var coord2 *coordinate = &coordinate{}
    // 通过点号方式访问结构体的成员，且点号能作用于结构体指针上，中间有一个自动解引用的操作
    coord2.x = 3.3 // 等价于 (*coord2).X = 3.3
    // 可以获得结构体字段的地址
    y := &coord2.y // 等价于 y := &(*coord2).y
    *y = 4.4

    // 当结构体各个元素是可比较类型且对应相等时，结构体也相等
    fmt.Println(coord1 == *coord2) // true

    // 在结构体复合字面量中，被提升的字段名称不能起作用，因此以下的
    // coordinate3D 字面量不能是 coordinate3D{X: 3.3, Y: 4.4, Z: 5.5}
    var coord3 coordinate3D = coordinate3D{coordinate{3.3, 4.4}, 5.5}

    coord3.coordinate.x = 2.2 // 嵌入的结构体相当于结构体的一个字段
    coord3.y = 3.3            // 直接访问被提升的字段

    // 使用无名的结构体类型字面量来创建一个结构体
    var coord4 = struct {
        coordinate
        z float64
    }{
        coordinate{2.2, 3.3},
        5.5,
    }

    fmt.Println(coord3 == coord4) // true
}

// 通过添加此属性告诉编译器禁止产生未使用的函数、类型、字段等警告。
#![allow(dead_code)]

use chrono::{DateTime, FixedOffset, TimeZone};

struct Empty; // 类单元结构体，注意结构体名称后面可以省略大括号或圆括号

// 通过添加此属性，可以在 println! 宏中用 {:?} 或 {:#?} 格式化字符串打印结构体内容。
#[derive(Debug)]
struct Student {
    id: i32,
    name: String,
    class: String,
    major: String,
    // email: &str, // 借用却没有标注生命周期，因此此行不能编译
    birthdate: DateTime<FixedOffset>,
}

#[derive(Debug)]
struct Coordinate {
    x: f64,
    y: f64, // 结构体定义时，最后一个字段后的逗号可以省略，但分行书写时通常不省略
}

// 元组结构体，请注意这里不是用大括号，而是像元组那样用圆括号定义的，末尾还要有分号。
struct Point(f64, f64, f64);

// 只包含一个字段的元组结构体，看起来就像一个新建的整数类型。
struct MyInt(i32);

fn main() {
    let _: Empty = Empty; // 初始化一个类单元结构体，注意后面的大括号对 {} 同样可以省略
    let _: Student; // 声明了结构体变量，但没有初始化

    let beijing_timezone: FixedOffset = FixedOffset::east(8 * 60 * 60);
    let major: String = String::from("软件工程");

    let zhang_san: Student = Student {
        id: 111111111,
        name: "张三".to_string(),
        class: "2201".to_string(),
        major, // 存在与字段名同名的变量，因此可以使用字段初始化简写语法，这种方法对函数参数同样适用
        birthdate: beijing_timezone.ymd(2004, 12, 21).and_hms(0, 0, 0),
    };

    // 使用结构体更新语法从其他实例创建实例
    let li_si: Student = Student {
        id: 111111112,
        name: "李四".to_string(),
        birthdate: beijing_timezone.ymd(2004, 4, 17).and_hms(0, 0, 0),
        // 对于前面没有赋值的字段，会将 zhang_san 中的对应字段通过赋值 = 操作移动或复制给 li_si。
        // 这里主要移动了 class 和 major 字段，此后 zhang_san 的这些字段处于未赋值状态，
        // 从而使 zhang_san 变得不可用。
        ..zhang_san
    };

    // println!("{:?}", zhang_san); // 因为 zhang_san 中的部分字段值已经被移动，因此此项不可用

    // Student { id: 111111112, name: "李四", class: "2201", major: "软件工程", birthdate: 2004-04-17T00:00:00+08:00 }
    println!("{:?}", li_si);

    // 在结构体字面量中，必须给出所有字段的值
    // 无论右大括号是否和最后一个字段名称:值对项在一行，其后的逗号都可以省略
    let coord1: Coordinate = Coordinate { x: 3.3, y: 4.4 };

    let coord2: &mut Coordinate = &mut Coordinate { x: 0.0, y: 0.0 };
    // 通过点号方式访问结构体的成员，且点号能作用于结构体指针上，中间有一个自动解引用的操作
    coord2.x = 3.3; // 等价于 (*coord2).X = 3.3;
    let y = &mut coord2.y;
    *y = 4.4;

    // assert_eq!(coord1, *coord2); // 结构体默认没有实现 PartialEq<_> trait，因此不能比较

    println!("{:?}", coord1); // Coordinate { x: 3.3, y: 4.4 }

    // 使用更易读的 {:#?} 风格，将打印：
    // Coordinate {
    //     x: 3.3,
    //     y: 4.4,
    // }
    println!("{:#?}", coord2);

    // 实例化元组结构体
    let _: Point = Point(3.3, 4.4, 5.5);
    let _: MyInt = MyInt(33);
}

type ByteSize float64

const (
    _           = iota // 通过将其赋值给一个空白标识符来忽略第一个值
    KB ByteSize = 1 << (10 * iota)
    MB
    GB
    TB
    PB
    EB
    ZB
    YB
)

#![allow(dead_code)]

#[derive(Debug)]
enum Geometry {
    Nothing,                                // 类单元类型
    // 这里有意将 Point 的两个元素声明为 i64 类型，以便在后面演示模式匹配时匹配数值字面量，
    // 因为在未来版本的 Rust 编译器将不允许模式中出现浮点数字面量，目前只是显示为警告。
    Point(i64, i64),                        // 二元元组类型
    Rect(Rectangle),                        // 一元元组类型
    Circle { x: f64, y: f64, radius: f64 }, // 结构体类型
}

#[derive(Debug)]
struct Rectangle {
    lower_left: (f64, f64),
    up_right: (f64, f64),
}

fn main() {
    let mut g: Geometry = Geometry::Point(3, 4);
    println!("{:?}", g); // Point(3.3, 4.4)
    g = Geometry::Rect(Rectangle {
        lower_left: (33.3, 44.4),
        up_right: (48.7, 59.3),
    });
    println!("{:?}", g); // Rect(Rectangle { lower_left: (33.3, 44.4), up_right: (48.7, 59.3) })
    g = Geometry::Circle {
        x: 33.4,
        y: 44.4,
        radius: 10.3,
    };
    println!("{:?}", g); // Circle { x: 33.4, y: 44.4, radius: 10.3 }

    // 通过模式匹配访问枚举中保存的对象。
    match g {
        Geometry::Nothing => println!("什么也没有"),
        // 匹配具体的值。除了下面一行可以省略，其他匹配项都不可省略，因为 match 表达式必须是穷尽的。
        Geometry::Point(3, 4) => println!("x: 3, y: 4"),
        Geometry::Point(x, y) => println!("x: {}, y: {}", x, y), // 匹配并解构元组
        Geometry::Rect(r) => println!("{:#?}", r),       // 匹配并结构元组
        // 匹配并结构结构体，将打印：x: 33.4, y: 44.4, radius: 10.3
        Geometry::Circle { x, y, radius } => println!("x: {}, y: {}, radius: {}", x, y, radius),
    }
}

#![allow(dead_code)]

fn main() {
    // 该枚举的所有变体都没有附加数据，因而每个变体对应一个整型判别值。
    enum DigitalSequence {
        Zero, // 0
        One,  // 1
        Two,  // 2
    }
    // 枚举标识符太长，使用 use 导入各个各个变体，此后就可以直接使用这些变体名称了。
    use DigitalSequence::{One, Two, Zero};
    println!(
        "Zero: {}, One: {}, Two: {}",
        Zero as i32, One as i32, Two as i32 // 通过 as 将枚举值转换为整型
    ); // Zero: 0, One: 1, Two: 2

    enum Number {
        Zero,      // 0
        Three = 3, // 3
        Four,      // 4
        Six = 6,   // 6
        Seven,     // 7
    }
}

enum ZeroVariants {}

pub enum Option<T> {
    None,
    Some(T),
}

package main

import (
	"errors"
	"fmt"
	"math"
)

type Coordinate struct {
	x, y, z float64
	hasZ    bool // 当该值为 false，表示 z 值为空
}

// NewCoordinate 根据给定的坐标值创建一个新的坐标。
func NewCoordinate(x, y float64, z ...float64) Coordinate {
	c := Coordinate{x: x, y: y}
	if len(z) > 0 {
		c.z = z[0]
		c.hasZ = true
	}
	return c
}

// IsIn3D 方法判断坐标是否在三维空间中。
func (c *Coordinate) IsIn3D() bool {
	return c.hasZ
}

// SetZ 设定坐标的 Z 坐标分量。
func (c *Coordinate) SetZ(z float64) {
	c.z = z
	c.hasZ = true
}

// RemoveZ 方法通过删除 Z 坐标分量将坐标变为二维坐标。
func (c *Coordinate) RemoveZ() {
	c.hasZ = false
}

// DistToCoordinate2D 方法计算到另外一个坐标点的平面距离。
func (c *Coordinate) DistToCoordinate2D(d *Coordinate) float64 {
	return math.Sqrt(math.Pow(c.x-d.x, 2) + math.Pow(c.y-d.y, 2))
}

// DistToCoordinate3D 方法计算到另外一个坐标点在三维空间的距离。
func (c Coordinate) DistToCoordinate3D(d *Coordinate) (float64, error) {
	if !c.hasZ || !d.hasZ {
		return 0, errors.New("coordinate is not defined in 3D space")
	}
	return math.Sqrt(math.Pow(c.x-d.x, 2) + math.Pow(c.y-d.y, 2) + math.Pow(c.z-d.z, 2)), nil
}

func main() {
	c1 := NewCoordinate(3.3, 4.4, 5.5)
	c2 := NewCoordinate(11.1, 22.2)
	d, err := c1.DistToCoordinate3D(&c2)
	if err != nil {
		fmt.Println("error:", err)
	} else {
		fmt.Println(d)
	} // error: coordinate is not defined in 3D space

	c2.SetZ(33.3)
	d, err = c1.DistToCoordinate3D(&c2)
	if err != nil {
		fmt.Println("error:", err)
	} else {
		fmt.Println(d)
	} // 33.91931603084001
}

#![allow(dead_code)]

struct Coordinate {
    x: f64,
    y: f64,
    z: Option<f64>, // 当不存在 z 时，为 None 值
}

impl Coordinate {
    // 根据给定的坐标值创建一个新的坐标。
    fn new(x: f64, y: f64, z: Option<f64>) -> Coordinate {
        Coordinate { x, y, z }
    }

    // 判断坐标是否在三维空间中。
    fn is_in_3d(&self) -> bool {
        self.z.is_some()
    }

    // 设定坐标的 Z 坐标分量。
    fn set_z(&mut self, z: Option<f64>) {
        self.z = z;
    }

    // 通过删除 Z 坐标分量将坐标变为二维坐标。
    fn remove_z(&mut self) {
        self.z = None;
    }

    // 计算到另外一个坐标点的平面距离。
    fn dist_to_coordinate_2d(&self, d: &Coordinate) -> f64 {
        ((self.x - d.x).powi(2) + (self.y - d.y).powi(2)).sqrt()
    }

    // 计算到另外一个坐标点在三维空间的距离。
    fn dist_to_coordinate_3d(&self, d: &Coordinate) -> Option<f64> {
        match (self.z, d.z) {
            (Some(z0), Some(z1)) => {
                Some(((self.x - d.x).powi(2) + (self.y - d.y).powi(2) + (z0 - z1).powi(2)).sqrt())
            }
            _ => None,
        }
    }
}

fn main() {
    let c1 = Coordinate::new(3.3, 4.4, Some(5.5));
    let mut c2 = Coordinate::new(11.1, 22.2, None);
    let mut d = c1.dist_to_coordinate_3d(&c2);
    // 只需要匹配一种模式，使用 if let 表达式代替 match。
    if let Some(v) = d {
        println!("{}", v);
    } else {
        println!("coordinate is not defined in 3D space")
    } // coordinate is not defined in 3D space

    c2.set_z(Some(33.3));
    d = c1.dist_to_coordinate_3d(&c2);
    if let Some(v) = d {
        println!("{}", v);
    } else {
        println!("coordinate is not defined in 3D space")
    } // 33.91931603084001
}

#![allow(dead_code)]

use std::mem::ManuallyDrop;

union AnyValue {
    int: i32,
    float: f64,
    boolean: bool,
    text: ManuallyDrop<String>,
    // 下面一行无法通过编译，将显示错误：
    // error[E0740]: unions cannot contain fields that may need dropping
    // text_alt: String,
}

fn main() {
    let mut v: AnyValue = AnyValue { float: 33.3 };

    // 读取字段，需要在 unsafe 块中
    let f = unsafe { v.float };
    println!("{}", f); // 33.3

    // 前面放入了一个浮点数，却试图按整数读出，
    // 程序仍该编译和运行，但读出的数值却是非预期的。
    // 此 f 遮蔽了前面的 f64 类型的 f。
    let f = unsafe { v.int };
    println!("{}", f); // 1717986918

    // 由于 text 字段为 ManuallyDrop 包装类型，因此写入时不需要标记 unsafe。
    v.text = ManuallyDrop::new("Hello".to_string());
    let f = unsafe { &v.text };
    println!("{:?}", f); // ManuallyDrop { value: "Hello" }

    // 通过模式匹配访问联合体字段。
    // 像这里定义的 Value 联合体，其需要匹配的项太多，因此这样漫无目的地匹配起来是没有多大意义的。
    v.int = 1;
    unsafe {
        // 匹配很可能产生错误，因此此段代码是不安全的
        match v {
            // 带有具体值的模式匹配是可驳斥的
            AnyValue { int: 33 } => println!("精确匹配到一个整数值 33"),
            AnyValue { int: 44 } => println!("精确匹配到一个整数值 44"),
            // 布尔类型很容易被匹配到，当值为 1 时，此项竟然被错误地匹配到了；
            // 而当值为 0 或 2 时，此项又匹配不到。
            AnyValue { boolean: true } => println!("真"),
            // 不带具体值的模式匹配是不可驳斥的，所以无论该联合体里面存什么值，都会把它
            // 当作 float 字段对应的 f64 类型。将以上值从 1 改为 2，此项就会被匹配到。
            // 当然打印的结果是错误的，并不是 2.0。
            AnyValue { float } => println!("{}", float),
        } // 最终打印：真
    }

    // 应该把联合体的多个字段当作一个去进行移动和借用。
    unsafe {
        let b1 = &mut v.int; // 第 1 次可变借用
        // 由于同一时刻只能有一个可变借用，因此以下两行代码只能保留一行
        // let b2= &mut v.float; // 第 2 次可变借用
        println!("{}", b1); // 使用 b1，说明到此为止，b1 的借用还没有归还
    }
}

package main

import "fmt"

type MyInt int

// IsOdd 方法判断该整数是否为奇数。也可以声明该方法的接收者为 *MyInt 指针类型。
func (n MyInt) IsOdd() bool {
	return n%2 != 0 // 自动将 n 的类型从 MyInt 转换为 int
}

// PlusOne 使该整数加 1，这时其接收者必须为指针，否则对接收者的改变将不起效果。
func (n *MyInt) PlusOne() {
	*n += 1 // 这里必须对指针手动解引用
}

func main() {
	n := MyInt(11)
	fmt.Println(n.IsOdd()) // true
	n.PlusOne()
	fmt.Println(n.IsOdd()) // false

	p := &n
	fmt.Println(p.IsOdd()) // false
	p.PlusOne()
	fmt.Println(p.IsOdd()) // true
}

// 一元元组结构体，和 Go 中基于 int 声明新类型是相似的。
struct MyInt(i32);

impl MyInt {
    // is_odd 方法判断该整数是否为奇数。如果方法的接收者为 self 而不是 &self，
    // 接收者的所有权将会被移动到方法内部，从而消费接收者。
    fn is_odd(&self) -> bool {
        self.0 % 2 != 0
    }

    // plus_one 使该整数加 1，这时其接收者必须为可变引用。
    fn plus_one(&mut self) {
        self.0 += 1;
    }

    // take_ownership 将接收者的所有权转移到了方法中，此后方法外的接收者变量将不能再使用。
    fn take_ownership(mut self) {
        self.0 += 1;
    }
}

fn main() {
    let mut n = MyInt(11);
    println!("{}", n.is_odd()); // true
    n.plus_one();
    println!("{}", n.is_odd()); // false

    let p = &mut n;
    println!("{}", p.is_odd()); // false
    p.plus_one();
    println!("{}", p.is_odd()); // true

    n.take_ownership(); // n 的所有权被移动了
    // println!("{}", n.is_odd()); // 错误：borrow of moved value: `n`
}

package main

import "fmt"

type Series []int           // 基于 []int 类型自定义新类型
type SeriesWrapper struct { // 包装 []int 类型的字段自定义结构体
	value []int
}

// PlusThree 将 Series 的每个元素加 3。
func (s Series) PlusThree() {
	for i := 0; i < len(s); i++ {
		s[i] += 3
	}
}

// PlusThree 将 SeriesWrapper 的每个元素加 3。
func (s SeriesWrapper) PlusThree() {
	for i := 0; i < len(s.value); i++ {
		s.value[i] += 3
	}
}

// Extend 所做的工作本来类似 append，但无论接收器是 Series 或 *Series，该方法都不起作用。
func (s Series) Extend(extras ...int) {
	t := append(s, extras...) // [0 1 2 3 4 5]
	// 该行能编译，但不起作用。因为对方法接收器的复制只传递给被调用放（方法内），不传递到调用方（方法外）。
	s = t
}

// ExtendPointer 所做的工作本来类似 append，但无论接收器是 Series 或 *Series，该方法都不起作用。
func (s *Series) ExtendPointer(extras ...int) {
	t := append(*s, extras...) // [0 1 2 3 4 5]
	// 该行能编译，但不起作用。因为对方法接收器的复制只传递给被调用放（方法内），不传递到调用方（方法外）。
	s = &t
}

// Extend 所做的工作本来类似 append，但当接收器是 *SeriesWrapper，该方法不起作用。
func (s SeriesWrapper) Extend(extras ...int) {
	t := append(s.value, extras...) // [0 1 2 3 4 5]
	// 该行能编译，但不起作用。因为对方法接收器的复制只传递给被调用放（方法内），不传递到调用方（方法外）。
	s.value = t
}

// ExtendPointer 所做的工作类似 append，且可以起作用。
func (s *SeriesWrapper) ExtendPointer(extras ...int) {
	t := append(s.value, extras...) // [0 1 2 3 4 5]
	// 这里就能将更改结果传递回去。
	s.value = t
}

func main() {
	s := Series([]int{0, 1, 2})
	sw := SeriesWrapper{value: []int{0, 1, 2}}

	s.Extend(3, 4, 5)
	fmt.Println(s) // [0 1 2]

	sw.Extend(3, 4, 5)
	fmt.Println(sw) // {[0 1 2]}

	s.ExtendPointer(3, 4, 5)
	fmt.Println(s) // [0 1 2]

	sw.ExtendPointer(3, 4, 5)
	fmt.Println(sw) // [0 1 2 3 4 5]

	s.PlusThree()
	fmt.Println(s) // [3 4 5]

	sw.PlusThree()
	fmt.Println(sw) // {[3 4 5 6 7 8]}
}

#[derive(Debug)]
struct Series(Vec<i32>);

impl Series {
    // plus_three 将 Series 的每个元素加 3。
    fn plus_three(&mut self) {
        for v in self.0.iter_mut() {
            *v += 3;
        }
    }

    // extend 将一组数字（切片类型）追加到 Series 的末尾。
    fn extend(&mut self, extra: &[i32]) {
        self.0.extend_from_slice(extra);
    }
}

fn main() {
    let mut s = Series(vec![0, 1, 2]);
    s.extend(&[3, 4, 5]);
    println!("{:?}", s); // Series([0, 1, 2, 3, 4, 5])
    s.plus_three();
    println!("{:?}", s); // Series([3, 4, 5, 6, 7, 8])
}