Rustの型変換
Rustの型変換まわりを頭の整理がてらまとめました。
cast
Rustではas演算子でキャストを行えます。
as演算子は数値やbool, char, ポインタ等一部の型のみで利用できます。
as演算子はパニックを起こさないので安心して利用できます。
整数のキャストの例を載せておきます。
// 整数のサイズが変わらない場合はデータ自体に変更はなく、
// 型の解釈が変わるだけ
let x: u8 = 150;
let y = x as i8;
assert_eq!(y, -106);
assert_eq!(format!("{:b}", x), "10010110");
assert_eq!(format!("{:b}", y), "10010110");
// 整数のサイズが小さくなる場合は上位ビットが切り詰められる
let x: u16 = 500;
let y = x as i8;
assert_eq!(y, -12);
assert_eq!(format!("{:b}", x), "111110100");
assert_eq!(format!("{:b}", y), "11110100");
// 整数のサイズが大きくなる場合は符号ビットで埋める
let x1: u8 = 0;
let x2: i8 = -127;
let y1 = x1 as u16;
let y2 = x2 as i16;
assert_eq!(y1, 0);
assert_eq!(y2, -127);
assert_eq!(format!("{:b}", x1), "0");
assert_eq!(format!("{:b}", y1), "0");
assert_eq!(format!("{:b}", x2), "10000001");
assert_eq!(format!("{:b}", y2), "1111111110000001");
Into/From
IntoとFromはある型から別の型への変換を行うtraitです。
Into<T>はT型へ変換できることを、From<T>はT型から変換できることを表しています。
IntoとFromはtraitを変換先に実装するのか、変換元に実装するのかという違いだけです。
呼び出し方が異なるだけでやっていることは全く同じになります。
そのためIntoにはジェネリックな実装があり、impl From<T> for Xを実装すると自動的にX::from(t)とt.into::<X>()が使えるようになります。
use std::convert::{From, Into};
#[derive(PartialEq, Eq, Debug)]
struct Color {
alpha: u8,
red: u8,
green: u8,
blue: u8,
}
impl From<u32> for Color {
fn from(x: u32) -> Self {
let alpha = (x >> 24) as u8;
let red = (x >> 16) as u8;
let green = (x >> 8) as u8;
let blue = x as u8;
Color {
alpha,
red,
green,
blue,
}
}
}
#[test]
fn test() {
let c = Color {
alpha: 0xff,
red: 0x7f,
green: 0x3f,
blue: 0x0f,
};
let x: u32 = 0xff7f3f0f;
assert_eq!(c, Color::from(x));
// Fromしか実装していないがintoも使える
assert_eq!(c, x.into());
}
TryInto/TryFrom
TryIntoとTryFromはIntoとFromに似ていますが、変換が失敗する可能性がある点が異なります。
（逆に言うとIntoとFromは変換に失敗するケースがあってはいけないということです。）
そのためResultを返すようになっています。
TryFrom<T>だけ実装すればTryInto<T>が使えるようになる点は同じです。
use std::convert::{TryFrom, TryInto};
#[derive(PartialEq, Eq, Debug)]
struct PrimeNumber(u32);
impl TryFrom<u32> for PrimeNumber {
type Error = &'static str;
fn try_from(x: u32) -> Result<Self, Self::Error> {
// めっちゃ雑な素数判定
for n in 2..x {
if x % n == 0 {
return Err("not prime number");
}
}
Ok(PrimeNumber(x))
}
}
#[test]
fn test() {
let x: u32 = 31;
let y: u32 = 32;
assert_eq!(Ok(PrimeNumber(31)), PrimeNumber::try_from(x));
assert_eq!(Ok(PrimeNumber(31)), x.try_into());
assert_eq!(
Err("not prime number") as Result<PrimeNumber, _>,
y.try_into()
);
}
FromStr/ToString
FromStrはその名の通り&strから変換できることを表すtraitでFrom<str>とほぼ同じです。
ToStringはFromStrの逆でStringへの変換をするtraitですが、直接実装する必要はありません。
ToStringはDisplayを実装する型へのジェネリックな実装を持っているため、Displayを実装するとToStringも利用できるようになります。
Displayのほうが汎用的なので、わざわざToStringのみを実装する意味はないでしょう。
Rustの数値などの基本的な型はFromStrとDisplayを実装を実装しているので数値のパースに利用できます。
use std::fmt;
use std::str::FromStr;
use std::string::ToString;
#[derive(PartialEq, Eq, Debug)]
struct Color {
red: u8,
green: u8,
blue: u8,
}
impl fmt::Display for Color {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&format!(
"#{:02x}{:02x}{:02x}",
self.red, self.green, self.blue
))?;
Ok(())
}
}
impl FromStr for Color {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
fn parse_u8(c1: char, c2: char) -> Result<u8, String> {
let mut s = String::with_capacity(2);
s.push(c1);
s.push(c2);
u8::from_str_radix(&s, 16).map_err(|_| format!("cannot parse u8. {}", &s))
}
if s.len() != 7 {
return Err("invalid length of str".to_string());
}
let chars: Vec<_> = s.chars().collect();
if chars[0] != '#' {
return Err("must be starts with #".to_string());
}
let red = parse_u8(chars[1], chars[2])?;
let green = parse_u8(chars[3], chars[4])?;
let blue = parse_u8(chars[5], chars[6])?;
Ok(Color { red, green, blue })
}
}
#[test]
fn test() {
let c = Color {
red: 0xff,
green: 0x7f,
blue: 0,
};
assert_eq!("#ff7f00", c.to_string());
assert_eq!("#ff7f00", format!("{}", c));
assert_eq!(Ok(c), Color::from_str(&"#ff7f00"));
assert_eq!(true, Color::from_str(&"#hoge").is_err());
}
IntoIter/FromIter
IntoIteratorはイテレータを生成できるようにするtraitです。
このtraitを実装することでfor式で回せるようになります。
IntoIteratorはselfをmoveするため、そのまま実装すると1度しかイテレートできません。
何度でもイテレートできるようにするには参照に対してtraitを実装する必要があります。
FromIteratorはイテレータから値を生成できるようにするtraitです。
このtraitを実装するとcollectメソッドを使って値を生成できるようになります。
FromIteratorを直接実装することは少ないかもしれませんが、VecやHashMapといった型はFromIteratorを実装しているおかげでcollectできます。
use std::iter::{FromIterator, IntoIterator, Iterator};
#[derive(PartialEq, Eq, Debug)]
struct Bits(u32);
impl<'a> IntoIterator for &'a Bits {
type Item = bool;
type IntoIter = BitsIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
BitsIterator {
mask: 1,
bits: self,
}
}
}
impl FromIterator<bool> for Bits {
fn from_iter<T>(iter: T) -> Self
where
T: IntoIterator<Item = bool>,
{
let mut bits: u32 = 0;
let mut mask: u32 = 1;
for bit in iter.into_iter().take(32) {
if bit {
bits += mask;
}
mask = mask << 1;
}
Bits(bits)
}
}
struct BitsIterator<'a> {
mask: u32,
bits: &'a Bits,
}
impl<'a> Iterator for BitsIterator<'a> {
type Item = bool;
fn next(&mut self) -> Option<Self::Item> {
if self.mask == 0 {
return None;
}
let x = (self.bits.0 & self.mask) != 0;
self.mask = self.mask << 1;
Some(x)
}
}
#[test]
fn test() {
let bits = Bits(10);
let v: Vec<_> = bits.into_iter().take(4).collect();
// 10 は 2進数で1010
// 左からいてレートするのでこの並びになる
assert_eq!(v, vec![false, true, false, true]);
// IntoIteratorを実装すると、for式で直接回せるようになる
for x in &bits {
println!("{}", x);
}
// FromIteratorを実装するとcollectでイテレータから直接変換できるようになる
assert_eq!(Bits(10), Bits::from_iter(vec![false, true, false, true]));
assert_eq!(bits, vec![false, true, false, true].into_iter().collect());
}
AsRef/AsMut
AsRefとAsMutは参照を別の型の参照に変換するためのtraitです。
AsRefがimmutable参照, AsMutがmutable参照です。
例えばStringはUTF8でエンコーディングされていることが保証されているu8スライスとみなす事ができます。
Stringはもちろん, str, Vec<u8>, u8配列などもAsRef<u8>を実装しているので、trait boundsで利用することで汎用的にできます。
標準ライブラリではOsStringやPathといったStringの類似型が相互に変換できるようになっているため、文字列で活用することが多くなるかと思います。
AsMutは変更可能という特性上、AsRefに比べ実装している型が限られています。
strはAsMut<[u8]>を実装していませんが、これは実装してしまうとUTF8として不正なバイト列を生成できてしまうからです。
use std::convert::{AsMut, AsRef};
fn hex_dump<T>(data: &T) -> String
where
T: AsRef<[u8]>,
{
let data = data.as_ref();
let mut s = String::with_capacity(data.len() * 3);
for x in data {
s.push_str(&format!("{:02x} ", x));
}
s
}
fn zero_fill<T>(data: &mut T)
where
T: AsMut<[u8]>,
{
let data = data.as_mut();
for x in data.iter_mut() {
*x = 0;
}
}
#[test]
fn test() {
let mut ary = [1u8; 5];
let mut vec: Vec<u8> = vec![1, 2, 10];
let s = "abc".to_string();
// AsRef
assert_eq!(hex_dump(&ary), "01 01 01 01 01 ");
assert_eq!(hex_dump(&vec), "01 02 0a ");
assert_eq!(hex_dump(&s), "61 62 63 ");
// AsMut
zero_fill(&mut ary);
zero_fill(&mut vec);
// StringはAsMut<[u8]>を実装してない
assert_eq!(hex_dump(&ary), "00 00 00 00 00 ");
assert_eq!(hex_dump(&vec), "00 00 00 ");
}
おわりに
Rustには他にもDerefやBorrowといった参照を変換するtraitが存在します。
このtraitはそれだけで1つの記事になりそうです。
そのうち整理してまとめようかと思います。
Discussion