2510rs,rust清单4
类型别名和转换
type T = S;
//创建一个`类型别名`,即S的别名.
Self
//用来实现类型的`类型别名`,如`fn new()->Self`.self
//`fn f(self){}`中的方法主题,如,类似`fn f(self:Self){}`.&self
//相同,但按借用引用`self`,等于`f(self:&Self)`&mut self
//相同,但是可变借用,将等于`f(self:&mut Self)`self: Box<Self>
//任意`self`类型,在`智能指针`中添加方法`(my_box.f_of_self())`.<S as T>
//按`T`特征消歧S类型,如,`<S as T>::f()`.
a::b as c
//在使用符号时,按`R`导入S,如,`use a::S as R`
x as u32
//原始转换,可能会截断且有点奇怪.
宏&属性
m!()
//宏调用,即(根据宏)`m!{}`,`m![]`.
#[attr]
//注解接着项目的外部属性.#![attr]
//注解向上外围的项目的`内部`属性.$x:ty
//宏抓,`:ty``片段`限定符,声明`$x`可能是什么.
$x
//宏替换,如,使用上面抓的`$x:ty`.$(x),*
//宏重复零次或多次.$(x),+
//相同,但1次或多次.$(x)?
//相同,但零次或一次(不应用分隔符).$(x)<<+
//事实上,也接受以外的分隔符.这里:`<<`.
匹配模式
match m {}
//启动`匹配模式`,然后使用匹配项.下表.let S(x) = get();
//注意,`让`也类似下表的析构.let S { x } = s;
//只有x会绑定在`s.x`值.let (_, b, _) = abc;
//只有b会绑定在`abc.1`值.let (a, ..) = abc;
//忽略"`其余部分`"也有效.let (.., a, b) = (1, 2);
//特定的绑定优先于"其余",这里a是`1`,`b`是`2`.let s @ S { x } = get();
//在x是`bnd`在`S`绑定s.对`s.x`,模式绑定见下let w @ t @ f = get();
//在每个`w,t,f`中存储3个`get()`结果的副本.let (|x| x) = get();
//病理或模式,非闭包.与`let x=get()`相同;let Ok(x) = f();
//如果`p`.则不管用,请使用`let else`或`if let`代替.
let Ok(x) = f();//但如果或没人,则可工作,如,`f`返回`Result<T,!>`let Ok(x) = f() else {};//如果不是`w`,试分配,则`{}w`.必须是`中断,返回,恐慌!`if let Ok(x) = f() {}
//如果可赋值模式(如,枚举 变量),则分支,句法糖.if let ... && let ... { }
//让链,使用超过绑定,嵌套while let Ok(x) = f() {}
//等价;这里继续调用`f()`,只要可赋值`p`.就运行`{}`.fn f(S { x }: S)
//`函数参数`.也像`let`一样工作,这里x,绑定到`f(s)`的`s.x`.模式匹配
E::A => {}
//匹配枚举变量`A`.`匹配模式`.
E::B ( .. ) => {}
//匹配枚举`B`元组变量,忽略任何索引.
E::C { .. } => {}
//匹配枚举`C`结构变量,忽略任何字段.S { x: 0, y: 1 } => {}
//用`特定值`匹配`s`(仅`s.x`为0且`s.y`为`1`).S { x: a, y: b } => {}
//与`s的任意值`匹配`,并用`a`绑定`s.x`,用`b`绑定`s.y`.S { x, y } => {}
//相同,但分别按x和`y`绑定`s.x`和`s.y`来简写.S { .. } => {}
//匹配任何值的结构.D => {}
//如果正在使用D,则匹配`E::D`枚举变量.D => {}//匹配绑定`D`的任何内容;如果未使用D,则可能是`E::D`的假朋友._ => {}
//匹配任何内容或所有其他的`正确通配符`.0 | 1 => {}
//模式替代,或模式E::A | E::Z => {}
//相同,但在枚举变量上.E::C {x} | E::D {x} => {}
//相同,但如果`所有变量`都有它,则绑定`x`.Some(A | B) => {}
//相同,也可匹配`深度`嵌套的替代.|x| x => {}
//引导|忽略,只是x|`x`,因此`x`.|x => {}
//类似,领导|忽视.(a, 0) => {}
//对a匹配`任意值`的元组,对第二个,匹配0.[a, 0] => {}
//切片模式,对a匹配`任意值`的元组,对第二个,匹配0.[1, ..] => {}
//匹配从1开始的数组,对其余值是任何值;子切片模式.[1, .., 5] => {}
//从1开始,以5结尾的`匹配数组`.[1, x @ .., 5] => {}
//相同,但也在代表中间的切片绑定x(模式绑定).[a, x @ .., b] => {}
//相同,但匹配任何第一个,最后,分别按`a,b`绑定.1 .. 3 => {}
//区间模式,此处匹配1和`2`;部分不稳定.1 ..= 3 => {}
//包含区间模式,匹配`1,2`和`3`.1 .. => {}
//开放区间模式,匹配1和任何更大的数字.x @ 1..=5 => {}
//绑定与x匹配;模式绑定,这里x将是`1...5`.Err(x @ Error {..}) => {}
//也可嵌套工作,这里在`Error`绑定x,尤其是对下面的`if`有用的.S { x } if x > 10 => {}
//`匹配模式`警卫,条件必须为`真`才能匹配.
泛型与约束
struct S<T> ...
//有类型参数的`模板类型`(`T`在此是占位符).S<T> where T: R
//特征绑定,允许有限制的`T`,保证T有`R`特征.where T: R, P: S
//独立特征边界,这里一个针对`T`,一个针对(未显示)`P`.where T: R, S
//编译错误,你可能需要下面的复合绑定`R+S`.where T: R + S
//复合特征绑定,`T`必须满足R和`S`.where T: R + 'a//相同,但`T`的`生命期`必须满足`R`,如果T满足,则必须比`'a`更长寿.where T:? Sized
//选出`预定义`的特征绑定,此处为"大小".where T: 'a
//类型`生命期`绑定;如果T有`引用`,它们必须比`'a`更长寿.where T: 'static
//相同;不表明值t会是"静态",只是可以.where 'b: 'a
//`'b`生命期必须至少大于a的`生命期`.where u8: R<T>
//还可使条件语句包含`其他类型`.S<T: R>
//短手绑定,与上文`几乎相同`,写起来更短.S<const N: usize>
//通用常绑定;S类型的用户可提供`常量的N值`.S<10>
//在使用时,可按原语值提供常量边界.S<{5+5}>
//式必须放在大括号中.
S<T = R>
//`默认参数`;使S更易于使用,但保持`灵活性`.S<const N: u8 = 0>
//常量的`默认参数`;如,在`f(x:S){}`中,N参数为`0`.S<T = u8>
//类型的`默认参数`,如,在`f(x:S){}`中,`T`为`u8`.S<'_>
//推导为匿名生命期;如果是明显的,请编译器"搞清楚".S<_>
//推导`匿名类型`,如`let x:Vec<_>=iter.collect()`
S::<T>
//`怪鱼`调用点类型消歧,如`f::<u32>()`.E::<T>::A
//在其E类型上,模板枚举可接收其`类型参数`E::A::<T>
//...或在(此处为A)变量;允许Ok::<R,E>(r)等.trait T<X> {}
//X上的`通用特征`.可有多个`impl T for S`(每个X一个).trait T { type X; }
//定义`X`关联类型.只有一个`impl T for S`可以.trait T { type X<G>; }
//定义通用关联类型,`X`可以是通用的`Vec<>`.trait T { type X<'a>; }
//定义`生命期`内的`GAT`模板.type X = R;
//在`impl T for S{type X=R;}`中设置关联类型.type X<G> = R<G>;
//对`GAT`也是如此,如`impl T for S { type X<G> = Vec<G>; }`impl<T> S<T> {}
//对通用的`S<T>`中的`T`的`实现`函数,这里是`T`类型参数.//从此开始.
impl S<T> {}
//对特定类型的`S<T>`中的`T`的`实现`函数
//这里是T特定类型,如`u8`.fn f() -> impl T
//现有类型(又名`RPIT`)返回一个隐式`T`的未知的调用者`S`.-> impl T + 'a
//表示隐藏类型的`生命期`至少与`'a`一样长-> impl T + use<'a>
//表示代替隐藏类型抓的`生命期`,`'a`而使用边界.-> impl T + use<'a, R>
//还表示隐藏类型可能已从R抓了`生命期`.-> S<impl T>
//也可在类型参数中使用`impl T`部分.fn f(x: &impl T)
//通过`"impl traits"`绑定的特征,类似下面的`fn f<S:T>(x:&S)`.fn f(x: &dyn T)
//通过动态分发调用`f`,不会为x`实例化`f.fn f<X: T>(x: X)
//X模板上的`Fn`,每个X会`实例化`或("`单态化`")`f.fn f() where Self: R;
//在`特征 T{}`中,仅在已知`impl R`的类型上可访问f.fn f() where Self: Sized;
//使用`Sized`可从`特征对象虚表`中选出`f`,从而允许`dyn T`.fn f() where Self: R {}
//其他R有用.