Blowing in the wind – ページ 7

2024年8月21日2024年8月22日

構造体や列挙体などオブジェクト要素にCopy/Cloneが実装されてない型の複製(@Rust)

コピーや複製はRustでは、オブジェクトの型に依存してデフォルトで実装されているもの（プリミティブ型）もありますが、性能を重視しているので基本は移動です。

代入のセマンティクには以下の三種類がありますが、

① 共有：本体は共有してアクセスポインタは個別に持つやり方、GCを持つ言語(Java, C#, Golang)では標準のようです

② コピー：C++のデフォルト実装が該当

③ 移動：Rustの標準、ただしプリミティブ型（オブジェクトの長さが変化しないのでスタックを使用する型）は例外

Rustでプリミティブ型以外のヒープ領域に保存されるオブジェクトは標準は移動ですが、コピー（コピーすることに意味があれば、DBのコネクションとかコピーは無意味だし害があるだろう）はcloneを実装すれば良いのですが、例えば構造体などはデフォルトでcloneを適用しようとしても、対象オブジェクトのメンバーは対象に含まれないからコンパイルは通りません。

以下のコードはコンパイルエラーになりますが、理由はderiveは構造体という型に適用されるだけで、その要素であるVec型には適用されないから。

回避方法は、以下のソースでコメントアウトしているCloneのカスタマイズが必要になります。

  |     #[derive(Copy, Clone)]
  |              ^^^^
  |     struct S {
  |         x: Vec,
  |         ----------- this field does not implement `Copy`

fn main() {
    #[derive(Copy, Clone)]
    struct S {
        x: Vec<i32>,
    }
    /*impl Clone for S {
        fn clone(&self) -> Self {
            S { x: self.x.clone() }
        }
    }*/
    let mut s1 = S { x: vec![12] };
    let s2 = s1.clone();
    s1.x[0] += 1;
    print!("{} {}", s1.x[0], s2.x[0]);

    //
    // same as above(this field(x: Vec) does not implement `Copy`)
    // Object members are out of target, Copy/Clone is applied only to struct S/S1
    //

    struct S1 {
        x: Vec<i32>,
    }
    impl Copy for S1 {}
    impl Clone for S1 {
        fn clone(&self) -> Self {
            *self
        }
    }
}

この辺りについては、

https://doc.rust-lang.org/std/marker/trait.Copy.html

の解説を読むのが良いと思います。

admin

2024年8月11日

コンパイルのoptimizeオプション(@Rust)

Beginning Rustに出てくるコードですが、rustcに -Oというコンパイルオプションがありますが、以下のコードで-Oを指定しないと何回か実行するとその都度時間は変わってきますが、この程度の処理時間、

実行環境はM1 Mac 16GB/512GB、rustc 1.79.0です

5.14425ms 1.031666ms

ここでrustic -Oでコンパイルすると、

584.666µs 84ns

この数字はwhileループを丸々パス、全く処理しないでvdをクリアしているだけに見えます。

fn main() {
    use std::time::Instant;
    const SIZE: usize = 40_000;
    let start_time = Instant::now();
    let mut vd = std::collections::VecDeque::<usize>::new();
    for i in 0..SIZE {
        vd.push_back(i);
        vd.push_back(SIZE + i);
        vd.pop_front();
        vd.push_back(SIZE * 2 + i);
        vd.pop_front();
    }
    let t1 = start_time.elapsed();
    while vd.len() > 0 {
        vd.pop_front();
    }
    let t2 = start_time.elapsed();
    print!("{:?} {:?}", t1, t2 - t1);
}

で、コンパイラが手抜きをさせないように、毎回結果を使うように書き換えると、

    while vd.len() > 0 {
        sum += vd.pop_front().unwrap();
    }
    let t2 = start_time.elapsed();
    print!("{:?} {:?} {}", t1, t2 - t1, sum);

386.083µs 81.209µs 2933353333

こちらはまともそうに見えます。コンパイルオプションで処理時間が著しく異なるときは実はコードが冗長というケースもありそうだよねということです、

admin

2024年8月2日2024年8月6日

FromとInto変換できる浮動小数と整数の精度条件(@Rust)

まあどちらもトレイトで定義されているわけで、対応する型が定義されてなければ変換できないわけですが、Begginig Rustのコードで浮動小数点に整数から変換するコードが出てきますが、テキストではi32をfloat変換するには相手先はf64でなければできないとあります。

https://doc.rust-lang.org/std/convert/trait.From.html

で該当部分を抜き出すと、

impl From<i16> for f32
impl From<i16> for f64
~
impl From<i32> for f64

i32からfloatに変換するときにはf32ではダメで、f64になるよということで無理に変換しようとするとエラーメッセージは、

the trait `From<i32>` is not implemented for `f32`

なので、そういうことです。i32の精度はf32では保持できないから変換に意味がないから用意されてないということです。

admin

2024年7月31日

プリミティブ型にメソッドの追加(@Rust)

プリミティブ型に、他の型にもあるだろうけれども、メソッドの追加定義は単純なimpl str/i32 ・・・のようなやり方ではできませんが、traitを介在したメソッド追加はできます。

以下Beginning Rustのコードからですが、traitを介在させることで、追加メソッドlenght()を定義しています。

fn main() {
    // "imple str" doesn't work as intended
    // primitive type doesn't allow adding some specific methods to it
    // to use tarit to adopt specific method lenght() for type "str"
    trait HasLength {
        fn length(&self) -> usize;
    }
    impl HasLength for str {
        fn length(&self) -> usize {
            self.chars().count()
        }
    }
    let s = "€èe";
    print!("{} {}", s.len(), s.length());
}

trait経由でプリミティブ型にメソッド追加の一般的なやり方ですが、直接追加（今はできない仕様ですが、できたとしたら）と比較して可読性とか保守性が直接追加に比較して優位であるというところが理由なのだろう。

admin

2024年7月28日2024年7月28日

スライスの長さをメソッド記法とドット記法で求めるときに(@Rust)

Beginning Rustの第18章の最初の方に出てくるコードですが、

fn main() {
    print!("{} {}",
        [1, 2, 3].len(),
        <[i32]>::len(&[1, 2, 3]));
}

ここで最後の２行はドット記法あるいはメソッド記法の違いですが、メソッド記法では<[i32]>::の表現が出てきます。ここで、<[i32]>の意味はスライスのジェネリック型でi32型の要素を持つこと、::はlen()の引数の型指定です。なぜこのような記法が必要かというと、len()というメソッドは他にもあって型を明示的に指定しないとどのトレイトに属するメソッドかを判断できないかから。

またlen()の引数は参照で無いとコンパイルできません。スライスのメソッドlen()の解説は以下の通り、

https://doc.rust-lang.org/std/primitive.slice.html#method.len

ここでa.len()を最後の行のように書き直してもコンパイルできます、スライスの要素はi8でもカバーされるので、

    let a = [1, 2, 3];
    assert_eq!(a.len(), 3);
    assert_eq!(<[i8]>::len(&a), 3);

ドット記法は実はこのような変換は暗黙で実行されています。それゆえ先のソースコードで、

&[1, 2, 3].len()のような冗長な記法でも問題ありません。ドット記法はRustの背後に存在するオブジェクト指向的な特性故に簡略な記法で使うことができます。

admin

2024年7月24日2024年7月26日

Result型を扱う演算子?(@Rust)

Beginning Rustに以下のようなコードがありますが、

fn main() {
    fn f1(x: i32) -> Result<i32, String> {
        if x == 1 {
            Err(format!("Err. 1"))
        } else {
            Ok(x)
        }
    }
    fn f2(x: i32) -> Result<i32, String> {
        if x == 2 {
            Err(format!("Err. 2"))
        } else {
            Ok(x)
        }
    }
    fn f3(x: i32) -> Result<i32, String> {
        if x == 3 {
            Err(format!("Err. 3"))
        } else {
            Ok(x)
        }
    }
    fn f4(x: i32) -> Result<i32, String> {
        if x == 4 {
            Err(format!("Err. 4"))
        } else {
            Ok(x)
        }
    }

    fn f(x: i32) -> Result<i32, String> {
        let result1 = f1(x);
        // -----------------------------------
        // let result2 = f2(result1?); equivalent to 
        //
        // if result1.is_err() { return result1; }
        // let result2 = f2(result1.unwrap());
        // -----------------------------------
        // if result1.is_err() { return result1; }
        let result2 = f2(result1?);
        //if result2.is_err() { return result2; }
        let result3 = f3(result2?);
        //if result3.is_err() { return result3; }
        f4(result3?)
    }
    // in short
    //    fn f(x: i32) -> Result<i32, String> {
    //      f4(f3(f2(f1(x)?)?)?)
    //    }
    //
    match f(2) {
        Ok(y) => println!("{}", y),
        Err(e) => println!("Error: {}", e),
    }
    match f(4) {
        Ok(y) => println!("{}", y),
        Err(e) => println!("Error: {}", e),
    }
    match f(5) {
        Ok(y) => println!("{}", y),
        Err(e) => println!("Error: {}", e),
    }
}

元のソースでは、f(x: i32)は以下のようになっていますが、上のソースにコメント付きで変更しています。オリジナルのコードは説明のために冗長になってますが。

    fn f(x: i32) -> Result<i32, String> {
        let result1 = f1(x);
        if result1.is_err() { return result1; }
        let result2 = f2(result1.unwrap());
        if result2.is_err() { return result2; }
        let result3 = f3(result2.unwrap());
        if result3.is_err() { return result3; }
        f4(result3.unwrap())
    }

比較すると、f2(result1?)の?はResult値の処理を行うsyntax sugarで以下のif文でのエラー処理（エラーの伝搬）とエラーがなけれが値を取り出すunwrap()処理を合わせて実行するのだと、

// -----------------------------------
// let result2 = f2(result1?); equivalent to 
// 
// if result1.is_err() { return result1; } 
// let result2 = f2(result1.unwrap()); 
// -----------------------------------

テキスト中にも書かれていますが、

let ex = func();

match ex {

Ok(v) => v,

Err(_) => return ex,

}

と等価なのだと。実は?はResultのみならずOptionの戻り値処理でも使えると、当然OkはSomeでErrはNoneになりますが。

さらにmain()関数も普通の関数のようにResultを返すことができて、以下のようなコードが出てきます。

Okからば空のタプルを返却し、エラー（この場合は負の値を引数）ならばErrを返却するコードです。以下のコードではincremented(-3)でmain()が終了してしまうので、最後の２行は実行されませんが、戻り値としてのOk(())は無いとコンパイルできません。実行時にエラーが起こるかどうかはコンパイラは事前に知ることはできないので。

ここでも?演算子はErrはそのまま返していることがわかります。

/* It prints:
5
Error: "negative argument"
*/
fn main() -> Result<(), String> {
    fn incremented(n: i32) -> Result<i32, String> {
        if n < 0 { Err(format!("negative argument")) }
        else { Ok(n + 1) }
    }
    println!("{} ", incremented(4)?);
    println!("{} ", incremented(-3)?);
    println!("{} ", incremented(7)?);
    Ok(())
}

admin

2024年7月20日

イテレーターチェインと遅延評価(@Rust)

Beginning Rustのコードから、

以下のようなイテレーターを返す関数（イテレーターアダプタとイテレータコンシューマ）をチェインして、最後にcollectコンシューマというのは、Rustではイテレーターチェインと呼ばれる構造になりますが、同時に遅延評価(lazy evaluation)もなされます。遅延評価とはコンシューマが要求しない限りは結果を出さない、つまり使われない結果を出すというのは無駄なことだろうから。

fn main() {
    let v = [66, -8, 43, 19, 0, -31]
        .into_iter()
        .filter(|x| { print!("F{} ", x); *x > 0 })
        .map(|x| { print!("M{} ", x); x * 2 })
        .collect::<Vec<_>>();
    print!("{:?}", v);
}

実行結果は、

F66 M66 F-8 F43 M43 F19 M19 F0 F-31 [132, 86, 38]

実質ループ処理になっていて、collectコンシューマがループ処理を受け持っていることになります、このコードをfor loopで書き直すと、

fn main() {
    let mut v = vec![];
    for item in [66, -8, 43, 19, 0, -31]
        .into_iter()
        .filter(|x| { print!("F{} ", x); *x > 0 })
        .map(|x| { print!("M{} ", x); x * 2 }) {
        v.push(item);
    }
    print!("{:?}", v);
}

このコードでは、vは変更されるのでmutになってますが、先のコードでvはmutである必要はありません。なぜなら作成されるだけで、書き換えはしないから。

admin

2024年7月19日

$ echo $?コマンド

Macでecho $?と打ち込むと、直前に実行したコマンドの終了コードを取得できる。

例えば、

% date
2024年 7月19日 金曜日 21時28分47秒 JST
% echo $?
0

というふうになります、ただ履歴を遡ることはできず、あくまで直前に実行したコマンドの終了コードです。

admin

2024年7月16日2024年7月19日

Rustのedition(@Rust)

Rustもそこそこ年代を重ねてきているので、editionによる互換性問題は出てきています。Beginning Rustの以下のコードはedition=2021と指定しないとコンパイルが通りません。

$ rustc –edition=2021 main.rs （=ではなくスペースでも同じ）

Cargoを使っていれば、cargo.tomlにエディション指定（デフォルトは2021）しておけば問題ないですが

/* It prints:
11 21 31 */
fn main() {
    let array_iterator: std::array::IntoIter<i32, 3_usize>
        = [10, 20, 30].into_iter();
    for item in array_iterator {
        let j: i32 = item;
        print!("{} ", j + 1);
    }
}

ここでarray_iteratorの型は、https://doc.rust-lang.org/std/array/struct.IntoIter.html

の通りですが、ここでは説明用に型を指定しているだけで、省略してもコンパイラが解釈できます。ここで3_usizeという見慣れない表記が出てきますが、ここで’_’は見やすさのためのスペーサーで3usizeの記法でも構いません。

ここで配列がイテレーターを返せる訳は、イテレーターを返すinto_iter()関数を実装しているからです。

この辺りの仕様はeditionにより変わるようで、以下に記載があります。

https://doc.rust-jp.rs/edition-guide/rust-2021/IntoIterator-for-arrays.html

該当部分は”

Rust 2021 から、array.into_iter() が IntoIterator::into_iter を意味するように変更されます。

”

従って、2021以前のeditionでコンパイルするためには以下のようなコードになります。

fn main() {
    let array_iterator: std::array::IntoIter<i32, 3_usize>
        = IntoIterator::into_iter([10, 20, 30]);
    for item in array_iterator {
        let j: i32 = item;
        print!("{} ", j + 1);
    }
}

admin

2024年7月15日2024年7月15日

Unicodeのcode point(@Rust)

別にRust限定ではないですが、Rustのサンプルコードで出てきたので書き止め。

Beginning Rustに以下のようなコードがあり、

fn main() {
    fn print_codes(s: &str) {
        let mut iter = s.chars();
        loop {
            match iter.next() {
                // c as u32 generates 'code point', not UTF-8
                Some(c) => { println!("{}: {}", c, c as u32); },    
                None => { break; },
            }
        }
    }
    print_codes("€èe");
}

結果は、

€: 8364
è: 232
e: 101

となりますが、eはUTF-8でもそのままですが、€とèは何なのかと思ったら、c as u32というのはUnicode上のコードポイントを返すだけで、UTF-8コードではないから。

https://qiita.com/omiita/items/50814037af2fd8b2b21e

このリンクを参照すると理屈はよくわかります。

admin