How_to_learn_modern_Rust - 現代のRustを学ぶ方法

(A guide to the adventurer.)

Created at: 2021-01-14 19:01:49
Language:

現代のRustを学ぶ方法

冒険者へのガイド。

目次

Rustを一歩ずつ深く学ぶ

Rust は信じられないほど強力なプログラミング言語です。ランタイムなしでコンパイルされ、高速であり、安全性の新しい概念をプログラミングにもたらします。
これは、Stack Overflow ユーザー プールで 5 年連続で最も愛されている言語です。
Rust を学習するには、次のコンテンツを記載されている順序で進めてください。コンテンツの大部分は無料です。

  1. 開発者が Rust を好む理由
    https://ibraheem.ca/posts/why-devs-love-rust/

  2. ビデオ - Rust クラッシュ コース - Rustlang
    https://www.youtube.com/watch?v=zF34dRivLOw

  3. ビデオ - Rust 入門パート 1
    https://www.youtube.com/watch?v=WnWGO-tLtLA

  4. ビデオ - Rust 入門パート 2
    https://www.youtube.com/watch?v=lLWchWTUFOQ

  5. ビデオ - せっかちな人のための錆-ボイラープレートなし
    https://www.youtube.com/watch?v=br3GIIQeefY

  6. Rust を学ぶための 30 時間-fasterthanLimeブログ
    https://fasterthanli.me/articles/a-half-hour-to-learn-rust

  7. ビデオ - Rust への Microsoft 初心者向けシリーズ
    https://www.youtube.com/playlist?list=PLlrxD0HtieHjbTjrchBwOVks_sr8EVW1x
    GitHub コード
    https://github.com/microsoft/beginners-series-rust

  8. Rust のツアー
    https://tourofrust.com/

  9. Rustの経験豊富な開発者が、C++の経験豊富な開発者 (Jason Turner) にゼロからRustについて教えます。
    Jonathan が Jason Rust を教える - パート 1 - C++ ウィークリー
    https://www.youtube.com/watch?v=EzQ7YIIo1rY
    Jonathan が Jason Rust を教える - パート 2 - C++ ウィークリー
    https://www.youtube.com/watch?v=Y5 -ZgxfQvpc


  10. Steve Klabnik と Carol Nichols によるRust プログラミング言語ブック(Rust コミュニティからの寄稿あり)
    https://doc.rust-lang.org/stable/book/

  11. Rust 言語のチート シート
    https://cheats.rs/

  12. Rustlings
    Rust コードの読み書きに慣れるための小さな演習。
    https://github.com/rust-lang/rustlings

  13. ビデオ - Rustlang の紹介 - テンソル プログラミング
    https://www.youtube.com/watch?v=EYqceb2AnkU&list=PLJbE2Yu2zumDF6BX6_RdPisRVHgzV02NW

  14. ビデオ - Rustlang プロジェクト - テンソル プログラミング
    https://www.youtube.com/watch?v=-Jp7sabBCp4&list=PLJbE2Yu2zumDD5vy2BuSHvFZU0a6RDmgb

  15. 標準コレクション - 標準情報と正しいコレクションの選択方法
    https://doc.rust-lang.org/std/collections/index.html

  16. Rust タイプに関する雑学: Jon Gjengset の Twitter スレッドの許可された転記
    https://www.thecodedmessage.com/posts/trivia-rust-types/

  17. ビデオ - Rust での危険と FFI
    https://www.youtube.com/watch?v=LFFbTeU25pE

  18. Rust by Example Book
    https://doc.rust-lang.org/rust-by-example/

  19. ドキュメントのメソッドを注意深く調べてください。

    Option<T>
    それらはすべての Rust プログラムで使用されてい
    ます https://doc.rust-lang.org/beta/std/option/index.html

  20. ドキュメントのメソッドを注意深く調べてください。

    Result<T, E>
    それらはすべての Rust プログラムで使用されてい
    ます https://doc.rust-lang.org/beta/std/result/index.html

  21. Rust のコマンド ライン アプリケーション - 本
    https://rust-cli.github.io/book/in-depth/docs.html

  22. Rust 標準ライブラリのドキュメント
    https://doc.rust-lang.org/std/

  23. 完全にリンクされたリストが多すぎる Rust を学ぶ - 書籍
    https://rust-unofficial.github.io/too-many-lists/

  24. Rust Design Patterns - 本
    https://rust-unofficial.github.io/patterns/

  25. 効果的な錆 - 本
    https://www.lurklurk.org/effective-rust/

  26. The Rust Cookbook - 本
    https://rust-lang-nursery.github.io/rust-cookbook/

  27. カーゴブック
    https://doc.rust-lang.org/cargo/index.html

  28. コード 2020 の出現のガイド トラフ
    https://fasterthanli.me/series/advent-of-code-2020

  29. Rust API ガイドラインブック
    https://rust-lang.github.io/api-guidelines/about.html

  30. Rust リファレンスブック
    https://doc.rust-lang.org/stable/reference/

  31. The Rustonomicon - The Dark Arts of Unsafe Rust - 本
    https://doc.rust-lang.org/nomicon/

  32. Rust マクロの小さな本 - 本
    https://veykril.github.io/tlborm/introduction.html

  33. Rust でインタープリターを書く: ガイド - 本
    https://rust-hosted-langs.github.io/book/introduction.html

  34. ビデオ - 高速インタープリターを安く書く - Neil Mitchell
    https://www.youtube.com/watch?v=V8dnIw3amLA
    github
    https://github.com/ndmitchell/interpret

  35. Make A Language Rust プログラミング言語を使用してEldiro
    というプログラミング言語を作成するシリーズ。https://arzg.github.io/lang/

  36. Rust Web アプリケーションのエンジニアリング - 本
    https://erwabook.com/

  37. Programming Rust: Fast, Safe Systems Development 第 2 版
    Jim Blandy、Jason Orendorff 著


  38. Rustaceans のための Rust: Jon Gjengset による経験豊富な開発者のための慣用的なプログラミング


  39. Lily Mara によるRust へのリファクタリング

  40. Rust 開発者のための実用的なシステム プログラミング Prabhu Eshwarla による
    実用的な例を使用して、Linux/Unix システム用の高速で安全なソフトウェアを構築します。

  41. Rust を使用した実践的な並行性 : Rust でメモリセーフで並列かつ効率的なソフトウェアを自信を持って構築する
    by Brian L. Troutwine

  42. GDB: GNU プロジェクト デバッガー
    https://www.gnu.org/software/gdb/documentation/

  43. LLDB デバッガー
    https://lldb.llvm.org/

  44. Valgrind ユーザーマニュアル
    https://valgrind.org/docs/manual/manual.html

  45. perf Linux プロファイラー - 使用例
    https://www.brendangregg.com/perf.html

  46. QuickCheck - QuickCheck は、ランダムに生成された入力を使用してプロパティ ベースのテストを行う方法です。
    https://github.com/BurntSushi/quickcheck

  47. American Fuzzy Lop - 優れたファザー https://lcamt
    ​​uf.coredump.cx/afl/

  48. Criterion rs - Rust での統計主導のマイクロベンチマーク
    https://github.com/bheisler/criterion.rs

  49. 完全な Rust プログラミング リファレンス ガイド
    : Rahul Sharma、Vesa Kaihlavirta によるRust の高度な構造を使用して、効果的なソフトウェア システムを設計、開発、およびデプロイする

  50. Rust プログラマー向けのクリエイティブなプロジェクト : Web アプリ、WebAssembly、ゲーム、解析などの分野でエキサイティングなプロジェクトを構築
    する by Carlo Milanesi

  51. Rust High Performance
    : Iban Eguia Moraza によるRust アプリケーションのパフォーマンスを急上昇させる方法を学ぶ

  52. Rust Philipp Oppermann のブログで OS を書く
    https://os.phil-opp.com/

  53. Rust Unstable Book
    https://doc.rust-lang.org/beta/unstable-book/

Rustでのテキスト処理


  1. Mihalis TsoukalosによるRust でのテキスト処理
    https://www.linuxjournal.com/content/text-processing-rust

  2. Rust での文字列の操作- fastThanLimeブログ
    https://fasterthanli.me/articles/working-with-strings-in-rust

  3. 文字列の継続
    バックスラッシュ、改行、開始スペースは消えます。

println!(
    "... the {p}, by the {p}, for the {p}, \
    will never fall.",
    p = "people"
);

Will print: 
"... the people, by the people, for the people, will never fall."
  1. ASCII 文字列 (127 未満の値) 非 UTF-8 文字列の場合、文字列をバイトに変換してからバイトと比較すると、文字列をより高速に処理できます。
let my_str = "Hello!".to_string();
for c in my_str.chars() {
    if c == 'l' {
        // Do something!
    }
}

// A faster implementation for ASCII characters would be.

let my_str_2 = "Hello!".to_string();
for b in my_str.bytes() {
    if b == b'l' {
        // Do something!
    }
}

// There is also a slice of bytes.

let my_str_3 = "Hello!".to_string();
let my_str_as_bytes_slice = my_str_3.as_bytes();

if my_str_as_bytes_slice[2] == b'l' {
        // Do something!
}
  1. Kibi - Rust で書かれた ≤1024 行のコードのテキストエディタ
    https://github.com/ilai-deutel/kibi

  2. Rust の部分文字列処理
    については、以下のセクションを参照してください。

Rust が Rust のメモリとライフタイムのアノテーションにどのようにマップするか

  1. ビデオ - Rust のデータ型のメモリ レイアウトを視覚化する - Sreekanth 素晴らしい
    ビデオです。
    https://www.youtube.com/watch?v=rDoqT-a6UFg

  2. ビデオ - Rust のライフタイムを理解する - Ryan Levick
    https://www.youtube.com/watch?v=MSi3E5Z8oRw

  3. ビデオ - 錆の地殻: ライフタイム アノテーション - ジョン ジェンセット
    https://www.youtube.com/watch?v=rAl-9HwD858

  4. Rust での HashMap の実装。
    ビデオ - Rust でのリンクされたハッシュ マップのライブ コーディング - Jon Gjengset
    https://www.youtube.com/watch?v=k6xR2kf9hlA

循環参照と所有権に対処する方法

前のリンクでは、問題に対処する 3 つの方法

示しまし

std::rc::Rc
std::cell:RefCell


2-所有権を集中化します (たとえば、すべてのノードはツリー内のノードのベクトルによって所有されます)。次に、参照がハンドルになります (ベクトルへのインデックス)。

3-生のポインターと安全でないブロックを使用して、安全なRustのルールを回避します。

Rustにおけるポリモーフィズム

Rust Testing と TDD - テスト駆動開発

Rustでのシステムプログラミング

システムプログラミングの背景

  1. 最新の Linux の学習方法
    https://github.com/joaocarvalhoopen/How_to_learn_modern_Linux

  2. Rust での安全なシステム プログラミング
    Ralf Jung、Jacques-Henri Jourdan、Robert Krebbers、Derek Dreyer
    https://cacm.acm.org/magazines/2021/4/251364-safe-systems-programming-in-rust/fulltext

  3. The Linux Command Line, 2nd Edition: A Complete Introduction Illustrated Edition
    by William Shotts

  4. Linux の仕組み、第 3 版: すべてのスーパーユーザーが知っておくべきこと 第 3 版
    、Brian Ward 著

  5. オペレーティング システム: 3 つの簡単な部分
    Remzi H. Arpaci-Dusseau および Andrea C. Arpaci-Dusseau
    http://pages.cs.wisc.edu/~remzi/OSTEP/

  6. The Linux Programming Interface: A Linux and UNIX System Programming Handbook
    by Michael Kerrisk
    注:この本は最初から最後まで読んでください。

  7. System Programming Vol I and Vol II
    by Jin-Jwei Chen
    注:この本は最初から最後まで読んでください。


  8. Suzanne J. Matthews、Tia Newhall、Kevin C. Webb によるDive into Systems
    https://diveintosystems.org/
    注:この本を最初から最後まで読んでください。

  9. Linux デバイス ドライバー、第 3 版
    https://lwn.net/Kernel/LDD3/

  10. 組み込みプロセッサ用の Linux ドライバー開発 - 第 2 版: カーネル 4.9 LTS を使用した Linux 組み込みドライバーの開発方法を学ぶ
    (Alberto Liberal de los Ríos 著)

  11. Computer Systems: A Programmer's Perspective 第 3 版
    、Randal Bryant、David O'Hallaron 著

  12. コンピュータ ネットワーキング: トップダウン アプローチ
    by James Kurose

  13. The Illustrated Network: How TCP/IP Works in a Modern Network 第 2 版
    Walter Goralski 著

  14. C プログラミング: 最新のアプローチ、第 2 版
    KN King 著


  15. 効果的な C - Robert C. Seacord によるプロフェッショナルな C プログラミングの紹介

  16. CERT C Coding Standard - The 98 Rules for Developing Safe, Reliable, and Secure Systems 2nd Edition
    by Robert C. Seacord (著者)**

  17. エクストリーム C: 同時実行性、OOP、および C の最も高度な機能の限界にあなたを導きます (
    Kamran Amini 著)


  18. プログラミング - Bjarne Stroustrup によるC++ 2nd Edition、C++ 14 を使用した原則と実践

  19. C++ クラッシュ コース: テンポの速い紹介、C++ 17
    (Josh Lospinoso 著)

Rustでコンパイラを書く

  1. Crafting Interpreters
    by Robert Nystrom
    本のライセンスはクリエイティブ コモンズです。
    https://craftinginterpreters.com/
    Lox の実装
    https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations Rust でのインタープリター
    作成 - tdp2110
    https://github.com/tdp2110/crafting-interpreters-rs
    Rust における Lox インタープリター、パート 1 - Diego Freijo
    https://www.diegofreijo.com/blog/rlox-vm-a-lox-interpreter-in-rust-part-1/

  2. ビデオ再生リスト - Crafting Interpreters - Uncle Scientist
    https://www.youtube.com/playlist?list=PLib6-zlkjfXluRjBgK8grQH2IUSZjn-YN

  3. Rust の LISP インタープリター
    https://vishpat.github.io/lisp-rs/


  4. Thorsten Ball によるGo でのインタープリターの作成


  5. Thorsten Ball によるGo でのコンパイラの記述

  6. Compilers: Principles, Techniques, and Tools
    by Alfred Aho, Monica Lam, Ravi Sethi

Rustコンパイラrustcへの貢献

  1. ビデオ - RustConf 2021 - Rustc のハッキング: Esteban Kuber によるコンパイラへの貢献
    https://www.youtube.com/watch?v=9H9SO2u6Q20

  2. ビデオ -rustc - Rust プログラミング言語とコンパイラに関する Mark Mansi による講演
    https://www.youtube.com/watch?v=68U8ZZ1EnEQ

  3. ビデオ -rustc のハッキング - インデックス式の負のリテラル
    https://www.youtube.com/watch?v=OGihuce8rl8

  4. Rust Lang - コンパイラチーム
    https://rust-lang.github.io/compiler-team/

  5. Rust コンパイラ -rustc
    https://github.com/rust-lang/rust

  6. rustc API docs - コンパイラのrustdocドキュメント
    https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/

  7. Zulip チャット -rust-lang
    https://rust-lang.zulipchat.com/

  8. フォーラム Rust Internals
    https://internals.rust-lang.org/

  9. Rustc 開発ガイド - 本
    https://rustc-dev-guide.rust-lang.org/

  10. ビデオ再生リスト -rustc レクチャー シリーズ
    https://www.youtube.com/playlist?list=PL85XCvVPmGQhOL-J2Ng7qlPvDVOwYpGTN

Rust での WebAssembly - WASM

  1. Rust と WebAssembly - 本
    https://rustwasm.github.io/docs/book/

  2. Rust を使用して最初の WASM モジュールを作成する
    https://www.youtube.com/watch?v=nW71Mlbmxt8

  3. WebAssembly と Rust の開始: 初見
    https://www.youtube.com/watch?v=YHJjmsw_Sx0

  4. wasm-bindgen のクレート Wasm
    モジュールと JavaScript の間のハイレベルな対話を容易にします。
    GitHub
    https://github.com/rustwasm/wasm-bindgen
    wasm-bindgen ガイド- 本
    https://rustwasm.github.io/docs/wasm-bindgen/

  5. Project WASM Fourier Rust WASM モジュールに渡されるブラウザ オーディオ マイク データ
    の例。 注: Rust でオーディオ処理を使用して APP を研究し、たとえば APP を実行するための本当にクールな例です。https://github.com/linanova/wasm-fourier

  6. ビデオ - Rust + Yew + WASM + Canvas - Vers Binarii
    https://www.youtube.com/watch?v=7Smco8araSo

Rust の WebFrameworks - React Angular または Vue と同様

Rust で拡張された Python と Rust 内で Python インタープリターを実行する

  1. PyO3 - GitHub
    https://github.com/PyO3/pyo3

  2. PyO3 ユーザーガイド - 本
    https://pyo3.rs/master/

  3. PyO3 を使用した Pure Rust の Python 拡張機能
    https://depth-first.com/articles/2020/08/10/python-extensions-in-pure-rust-with-pyo3/

  4. RustPython - Rust で書かれた Python-3 インタープリター
    https://github.com/RustPython/RustPython

インライン Python で Rust

Rustで作ったプログラムで、

use a macro to insert inline Python
両者の間でデータ(変数)を簡単に移動します。

// Example_1 

use inline_python::python;

fn main() {
    let who = "world";
    let n = 5;
    python! {
        for i in range('n):
            print(i, "Hello", 'who)
        print("Goodbye")
    }
}
// Example_2 
// Creates the data in Rust and plots the plot with inline Python with the lib matplotlib.

use inline_python::python;

fn main() {
    let data = vec![(4, 3), (2, 8), (3, 1), (4, 0)];
    python! {
        import matplotlib.pyplot as plt
        plt.plot('data)
        plt.show()
    }
}
  1. Crate inline-python
    インライン Python コードを Rust コードで直接
    https://crates.io/crates/inline-python

このプロジェクトの内部構造とすべての開発ステップは、この一連のブログ投稿で詳細に美しく説明されています。

  1. Rust コード内で Python を書く - パート 1 - Mara のブログ
    https://blog.m-ou.se/writing-python-inside-rust-1/

  2. Rust コード内で Python を書く - パート 1A - Mara のブログ
    https://blog.m-ou.se/writing-python-inside-rust-1a/

  3. Rust コード内で Python を書く - パート 2 - Mara のブログ
    https://blog.m-ou.se/writing-python-inside-rust-2/

  4. Rust コード内で Python を書く - パート 3 - Mara のブログ
    https://blog.m-ou.se/writing-python-inside-rust-3/

  5. Rust コード内で Python を書く - パート 4 - Mara のブログ
    https://blog.m-ou.se/writing-python-inside-rust-4/

ラズベリーパイの錆

  • Raspberry Pi で Rust を使用するには、 2 つのモードがあります。
    1つ目はRust開発ツールをRaspberry Pi自体にインストールする方法、2つ目はPCにインストールしてクロスコンパイルし、Raspberry Pi上で動作する実行ファイルを生成する方法です。

Raspberry Pi での開発と Raspberry Pi での Rust プログラムの実行

  1. Raspberry Pi で Rust を使い始める方法
    https://www.muo.com/tag/getting-started-rust-raspberry-pi/

PC 上で開発し、クロスコンパイルして Raspberry Pi で Rust プログラムを実行する

  1. Rust を Raspberry Pi
    にクロスコンパイルする コンパイル後にファイルを Raspberry Pi に自動的にコピーする方法についても説明します。
    https://chacin.dev/blog/cross-compiling-rust-for-the-raspberry-pi/

  2. ラズベリーパイのためのRustのクロスコンパイル
    https://dev.to/h_ajsf/cross-compiling-rust-for-raspberry-pi-4iai

ラズベリーパイベアメタル

  1. Github - Zoltan Baldaszti - ベアメタル Raspberry Pi 3 チュートリアル
    https://github.com/bztsrc/raspi3-tutorial/

  2. Raspberry Pi 4 用のベアメタル オペレーティング システムの作成
    https://www.rpi4os.com/

  3. ビデオ プレイリスト - 低レベルの開発 - Raspberry Pi ベア メタル
    https://www.youtube.com/playlist?list=PLVxiWMqQvhg9FCteL7I0aohj1_YiUx1x8

  4. ビデオ ベアメタル Rust は、Raspberry Pi を含むすべてで実行されます -
    低レベル学習による組み込み Rust チュートリアル
    https://www.youtube.com/watch?v=jZT8APrzvc4

  5. Github - Raspberry Pi 上の Rust でのオペレーティング システム開発チュートリアル
    https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials

埋め込まれた錆

  1. Embedded Rust エコシステムの概要- 2020 年末
    https://www.youtube.com/watch?v=vLYit_HHPaY

  2. 素晴らしい埋め込み錆 - Github
    外部デバイスをマイクロコントローラーに接続するためのドライバーなど、知っておく必要があるすべて。
    https://github.com/rust-embedded/awesome-embedded-rust

  3. Embedded ワーキング グループのニュースレターまたはブログ
    https://rust-embedded.github.io/blog/

  4. Discovery Book MicroBitSTM32
    の良い出発点https://docs.rust-embedded.org/discovery/

  5. PlayList - Embedded Rust コース - JaJakub - 2022
    https://www.youtube.com/playlist?list=PLL2SCPK5xSRWBPj-nKOVYIhxRw7C4kYeI

  6. STM32 BluePill
    Embedded Rustで Embedded Rust を使用した開発の良い例をライブ ストリームし
    ます。

  7. Rust を使用した組み込みハードウェア開発- 2018
    https://www.youtube.com/watch?v=g25xsK3HKkE

  8. 組み込みプログラミングは錆びつつある- 2021 年末の
    組み込みコンピューティング設計
    https://www.youtube.com/watch?v=sOTx5324nKI

  9. Embedded Rust Book あらゆるタイプのチップ ブランドのジェネリック
    を読むための 2 番目の素晴らしい本。 https://docs.rust-embedded.org/book/

  10. 組み込みワークショップ向けワークブック - Nordic nRF52840開発キット
    を使用して予約します。https://embedded-trainings.ferrous-systems.com/

  11. Embedonomicon Book
    内部の仕組みを深く掘り下げます。
    https://docs.rust-embedded.org/embedonomicon/

  12. ビデオ - 最適なデバイス ドライバーを作成するにはどうすればよいですか?
    https://www.youtube.com/watch?v=z9z74VpqO9A

  13. ビデオ - RTIC - リアルタイム割り込み駆動同時実行
    性 RTIC は RTOS - リアルタイム オペレーティング システムです。
    https://www.youtube.com/watch?v=saNdh0m_qHc

  14. RTIC Book
    リアルタイム割り込み駆動型同時実行。タスクの優先順位付けデッドロックのない実行をサポートする、
    非常に効率的なプリエンプティブ マルチタスク フレームワークhttps://rtic.rs/1.0/book/en/

  15. Github - rtic-rs - cortex-m-rtic
    https://github.com/rtic-rs/cortex-m-rtic

  16. ビデオ - Rust RTIC フレームワークに関する Grepit
    https://www.youtube.com/watch?v=sSJ-Md8nwIM

  17. 優れた RTICプロジェクトの
    LCD を備えた STM32 の IR 温度計用の Rust ファームウェア- geomatsi -rust-ir-thermo
    https://github.com/geomatsi/rust-ir-thermo

  18. ビデオ - Rust を使用したベアメタル オーディオ プログラミング - Antoine van Gelder - ADC20
    https://www.youtube.com/watch?v=udlK1LQ3f3g
    スライド
    https://flowdsp.io/talks/talk-adc20/#1

  19. ビデオ - Rust リンツでシンプルなロジック アナライザーを構築する、
    2020 年 9 月 - Roland Ruckerbauer - 組み込み Rust
    ボードはstm32互換の bluepillを使用しました。
    https://www.youtube.com/watch?v=xY342ACNXFg
    スライド
    https://github.com/ruabmbua/rlogic/blob/master/presentation.pdf
    Github - ruabmbua - rlogic
    https://github.com/ruabmbua/ rlogic

埋め込み Rust クレートとコードサイズの最適化

  1. クレートヒープレス
    https://github.com/japaric/heapless
   Arc         - Thread-safe reference-counting pointer backed by a memory pool
   BinaryHeap  - Priority queue
   IndexMap    - Hash table
   IndexSet    - Hash set
   LinearMap
   Pool        - Lock-free memory pool
   String
   Vec
   mpmc::Q*    - Multiple producer multiple consumer lock-free queue
   spsc::Queue - Single producer single consumer lock-free queue
  1. Crate ufmt
    A (6-40x) 小さく、(2-9x) 速く、パニックのない core::fmt の代替
    https://github.com/japaric/ufmt

  2. LCD 16x2 - クレート hd44780-driver HD44780、16x1、16x2、および 16x4
    組み込み hal トレイトの実装。https://github.com/JohnDoneth/hd44780-driver

  3. Crate Embedded graphics
    これは、メモリに制約のある組み込みデバイスに焦点を当てた 2D グラフィックス ライブラリです。
    https://github.com/embedded-graphics/embedded-graphics

  4. クレート フリップリンク
    ゼロコストのスタック オーバーフロー保護を組み込みプログラムに追加します。
    https://github.com/knurling-rs/flip-link/

  5. Crate defmt
    defmt (「デ フォーマット」、「遅延フォーマット」の略) は、マイクロ コントローラーなどのリソースに制約のあるデバイスを対象とする非常に効率的なログ フレームワークです。
    https://github.com/knurling-rs/defmt/

  6. より小さなコードサイズを生成するための TOML コンパイルフラグオプション

....

[profile.release.package."*"]
opt-level = "z"

[profile.release]
codegen-units = 1
debug = true
opt-level = "z"

STM32 BluePill を使用した Rust の埋め込み - STM32F103

  1. STM32 BluePill in Rust -プロジェクト テンプレートと多くの情報
    これは、私が BluePill プロジェクトで使用するプロジェクト テンプレートです。
    https://github.com/joaocarvalhoopen/stm32_bluepill_in_rust__Template

Rust を Raspberry Pi Pico に組み込む - 4 ドル ボード

  1. 関連するすべての情報と開始プロジェクトのテンプレート。
    Rust での Pico 開発に関連すると思われるすべての情報を記載しました。
    RTIC USB-Serial および UF2 を使用した Rust Proj テンプレートの Raspberry Pi Pico
    https://github.com/joaocarvalhoopen/Raspberry_Pi_Pico_in_Rust__Proj_Template_with_RTIC_USB-Serial_UF2

  2. Raspberry Pi Pico - rp-HAL
    https://github.com/rp-rs/rp-hal
    rp2040-hal -
    https://github.com/rp-rs/rp-hal/tree/main/rp2040-hal /examples ボード rp-pico
    https://github.com/rp-rs/rp-hal/tree/main/boards/rp-picoドキュメンテーションhttps://docs.rs/rp2040-hal/latest/rp2040_hal/


  3. サイト - rp2040 - チップのドキュメント
    https://www.raspberrypi.com/documentation/microcontrollers/

  4. Raspberry Pi Pico で Rust を使い始める- パート 1
    https://reltech.substack.com/p/getting-started-with-rust-on-a-raspberry

  5. Raspberry Pi Pico で Rust を使い始める- パート 2
    https://reltech.substack.com/p/getting-started-with-raspberry-pi

  6. Raspberry Pi Pico で Rust を使い始める- パート 3
    https://reltech.substack.com/p/getting-started-with-rust-on-a-raspberry-a88

  7. 前のページの Oleg Eterevsky のコメント- セットアップが少し簡単になりました。デバッグを処理するために別のコントローラを使用する代わりに、彼はUSB シリアル ポート経由でデバッグ ログを設定しただけです。これにはもう少しボイラープレート (USB 割り込みの処理など) が必要ですが、ハードウェアの観点からははるかに簡単です: USB に 1 つの Pico ボードを接続し、それをフラッシュするだけで、すぐにデバッグ出力を確認できます。
    USB_Serial - リポジトリ
    https://github.com/eterevsky/rp2040-blink

  8. Crate usb-device - 組み込みデバイス用の実験的なデバイス側 USB スタック.
    https://crates.io/crates/usb-device

  9. Pico を USB-PEN モードに簡単に再起動してプログラムする方法
    ケーブルを再接続して起動ボタンを押しながら、切断する必要なく簡単に再起動できます。
    ピン RUN から GND にスイッチを追加し、ブート ボタンを押しながら実行ボタンを押し、実行スイッチを放してからブート ボタンを放します。USB-PEN モードに入り、PC から Rust または C バイナリを Raspberry Pico マイクロコントローラにコピーするだけでプログラムできるようになります。
    詳細については、公式ドキュメントを参照してください。

  10. PlayList - Rust Pico - 低レベルの学習
    https://www.youtube.com/playlist?list=PLc7W4b0WHTAUAEAguiqpNa5H0QqXJIJI6

  11. プレイ リスト - C 言語による Raspberry Pi Pico - 低レベルの学習
    https://www.youtube.com/playlist?list=PLc7W4b0WHTAV6EYRVayb9c9dEsq-NeXAt

  12. PlayList - Raspberry Pi Pico および RP2040の紹介- Digi-Key
    C/C++およびMicroPython
    https://www.youtube.com/playlist?list=PLEBQazB0HUyQO6rJxKr2umPCgmfAU-cqR

  13. 詳細: Raspberry Pi Pico の PIO - プログラマブル IO - スタックスマッシング
    https://www.youtube.com/watch?v=yYnQYF_Xa8g

  14. サイト - Raspberry Pi Pico
    https://www.raspberrypi.com/products/raspberry-pi-pico/

  15. サイト - Raspberry Pi Pico 入門
    https://projects.raspberrypi.org/en/projects/getting-started-with-the-pico/0

  16. 本 - Raspberry Pi Pico で MicroPython を使い始める
    https://hackspace.raspberrypi.com/books/micropython-pico

  17. 本 - Adafruit - Raspberry Pi Pico と CircuitPython の入門
    https://cdn-learn.adafruit.com/downloads/pdf/getting-started-with-raspberry-pi-pico-circuitpython.pdf

  18. ビデオ - Raspberry Pi Pico レビュー - 4 ドルの ARM マイクロコントローラ
    https://www.youtube.com/watch?v=dUCgYXF01Do

  19. ビデオ - 抵抗のみを使用した Raspberry Pi Pico VGA ビデオ出力
    https://www.youtube.com/watch?v=RmPWcsvGSyk

ESP32 で Rust を埋め込む

  1. esp-rs - ESP-IDF "Hello, World" テンプレートの Rust
    https://github.com/esp-rs/esp-idf-template

  2. Video - Embedded Rust: Wifi and I2C on a ESP32-C3 - Andrei Litvin
    https://www.youtube.com/watch?v=CXm7NdBBegk
    GitHub andy31415 - rust-esp32-c3-demos
    https://github.com/andy31415/rust-esp32-c3-demos/tree/oled_wifi

  3. ivmarkov - rust-esp32-std-demo
    A complex demo of ESP32 in Rust
    https://github.com/ivmarkov/rust-esp32-std-demo

Links

  1. Rust site
    A language empowering everyone to build reliable and efficient software.
    https://www.rust-lang.org/

  2. Song - Rust 2021 Edition
    https://www.youtube.com/watch?v=q0aNduqb2Ro

  3. Crate.io - The Rust community’s crate registry
    https://crates.io/

  4. Rust weekly news letter
    https://this-week-in-rust.org/

  5. Rust Books の小さな本
    https://lborb.github.io/book/title-page.html

  6. Awesome-rust
    https://github.com/rust-unofficial/awesome-rust

  7. Awesome-embedded-rust
    https://github.com/rust-embedded/awesome-embedded-rust

  8. Rust Analyzer - ユーザーマニュアルとショートカットキー
    https://rust-analyzer.github.io/manual.html

  9. Jon Gjengset - Rust in depth Youtube チャンネル。
    https://www.youtube.com/c/JonGjengset

  10. Tokio Tokio は、Rust プログラミング言語
    の非同期ランタイム ( asyncおよびawait ) です。ネットワーク アプリケーションの作成に必要なビルディング ブロックを提供します。数十のコアを持つ大規模なサーバーから小さな組み込みデバイスまで、幅広いシステムを対象とする柔軟性を提供します。
    チュートリアルを参照してください。
    https://tokio.rs/

  11. 最高のasync and await紹介ビデオ。
    ビデオ - Crust of Rust: async e await - Jon Gjengset
    https://www.youtube.com/watch?v=ThjvMReOXYM

  12. ビデオ - 非同期 Rust と Tokio を使用したチャット サーバーの作成 – Lily Mara
    https://www.youtube.com/watch?v=Iapc-qGTEBQ

  13. トレース - ログ トレース プラットフォーム
    https://github.com/tokio-rs/tracing

  14. Actix Web Web フレームワークは、Tokio で実行され、Python のFlask
    に 「似た」ものであり、非常に高速で安全な、非同期の Web フレームワークです。1 秒あたり 650.000 のリクエストを 処理できます。https://actix.rs/

  15. 高速で安全で、Python のDjango
    に 「似ている」Rocket Web フレームワーク。https://rocket.rs/

  16. Serde
    Serde は、Rust データ構造を効率的かつ汎用的にシリアライズおよびデシリアライズするためのフレームワークです。
    https://serde.rs/
    https://crates.io/crates/serde

  17. BindGen
    C および C++ ライブラリへの Rust FFI バインディングを自動的に生成します。
    https://crates.io/crates/bindgen
    チュートリアル ガイド。
    https://rust-lang.github.io/rust-bindgen/

  18. Rustc のハッキング: Esteban Kuber によるコンパイラへの貢献- RustConf 2021
    https://www.youtube.com/watch?v=9H9SO2u6Q20

ラストファンデーション

  1. ビデオ - Rust Foundation とは
    https://www.youtube.com/watch?v=AI4lPN0BqGc

  2. サイト - Rust Foundation
    https://foundation.rust-lang.org/

さびたブログ

  1. pretzelhammer の Rust ブログ
    https://github.com/pretzelhammer/rust-blog

    1. 同期および非同期 Rust の RESTful API - pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/restful-api-in-sync-and-async-rust.md

    2. Common Rust Lifetime Misconceptions - pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md

    3. Tour of Rust's Standard Library Traits - pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/tour-of-rusts-standard-library-traits.md

    4. Sizedness in Rust – pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/sizedness-in-rust.md

  2. fasterThanLime Blog - Amos Wenger
    https://fasterthanli.me

Rust Youtube Channels

  1. Channel Rust
    https://www.youtube.com/c/RustVideos/videos

  2. Channel Rust Foundation
    https://www.youtube.com/channel/UC0jzvznwtnsdXYIp415oC9g/videos

  3. Channel fasterthanlime - Amos Wegner
    https://www.youtube.com/c/fasterthanlime/videos

  4. Channel Jon Gjengset - Rust in depth Youtube channel.
    https://www.youtube.com/c/JonGjengset/videos

  5. Channel Tensor Programming - Intro to Rust
    https://www.youtube.com/playlist?list=PLJbE2Yu2zumDF6BX6_RdPisRVHgzV02NW

  6. Channel Tensor Programming - Rust Projects
    https://www.youtube.com/playlist?list=PLJbE2Yu2zumDD5vy2BuSHvFZU0a6RDmgb

  7. Channel Let's Get Rusty
    https://www.youtube.com/c/LetsGetRusty/videos

  8. Channel Uncle Scientist
    https://www.youtube.com/channel/UClnm0enwPt9iPWGZ5uh3Bfw/videos

  9. Channel Ryan Levick
    https://www.youtube.com/c/RyanLevicksVideos/videos

  10. Channel Tantan
    https://www.youtube.com/c/Tantandev/videos

  11. Channel Crazcalm's Tech Stack
    https://www.youtube.com/c/CrazcalmsTechStack/videos

  12. Channel Ferrous Systems GmbH
    Embedded Rust
    https://www.youtube.com/c/FerrousSystemsGmbH/videos

  13. Channel JaJakub
    Embedded Rust
    https://www.youtube.com/c/JaJakubYT/videos

  14. Channel Vers Binarii
    Embedded Rust
    https://www.youtube.com/channel/UCgLxnJi8BU476a3uZO29H4w/videos

GUI programming in Rust

  1. GTK4 - Unlocking the GNOME stack for Rust
    https://gtk-rs.org/

  2. Book - GUI development with Rust and GTK 4
    https://gtk-rs.org/gtk4-rs/stable/latest/book/

  3. Relm4 for GTK4
    https://github.com/AaronErhardt/relm4

  4. Speedrunning GUI development in Rust
    Hint: 1.2 seconds compilation technic.
    https://aaronerhardt.github.io/blog/posts/gui_speedrun/

  5. egui: an easy-to-use GUI in pure Rust
    Normal desktop GUI and WebAssembly written entirely in Rust, immediate mode.
    https://github.com/emilk/egui

  6. eGUI - Web Demo
    https://emilk.github.io/egui/index.html

  7. eframe - It's the official framework library for writing apps using egui
    https://github.com/emilk/egui/tree/master/eframe

  8. egui - 7a. Building a GUI app in Rust - Part A - creativcoder
    https://www.youtube.com/watch?v=NtUkr_z7l84

  9. egui - 7b. Building a GUI app in Rust - Part B - creativcoder
    https://www.youtube.com/watch?v=SvFPdgGwzTQ

  10. egui - 8. Building a web app in Rust - WASM - creativcoder
    https://www.youtube.com/watch?v=4MKcqR9z8AU

  11. Crate confy
    To maintain the state fo the APP in a config file. Serializes and deserializes automatically with Serde.
    https://github.com/rust-cli/confy

  12. Crate tracing
    https://github.com/tokio-rs/tracing

  13. pix_engine
    It's a cross-platform graphics & UI library for simple games, visualizations, digital art, and graphics applications. A kind of more simple Processing or p5.js but for Rust. Has a good collection of examples.
    https://github.com/lukexor/pix-engine

Audio in Rust

  1. RustAudio
    Free and useful Audio, DSP and music libraries written in Rust.
    https://github.com/RustAudio

  2. CPAL - Cross-Platform Audio Library
    Low-level library for audio input and output in pure Rust.
    Works aldo in WASM.
    https://github.com/RustAudio/cpal

  3. Rodio - Audio playback library
    MP3, WAV, Vorbis, Flac, MP4 and AAC.
    https://github.com/RustAudio/rodio

  4. dasp - Digital Audio Signal Processing in Rust
    https://github.com/RustAudio/dasp

  5. rust-portaudio - PortAudio bindings and wrappers for Rust.
    https://github.com/RustAudio/rust-portaudio

Faster Compilation - Linker times in Linux and Unix ELF

mold is optimized for Linux, zld only works on macOS. For production use, lld might be the most mature option.

mold is a high-performance drop-in replacement for existing Unix linkers. It is several times faster than LLVM lld linker
In the context of building a Relm4 for GTK-4 GUI application:
"With mold I was able to reduce my incremental compile times by factor 7 to only about 1.2 second. With this, it’s really fun to play with the code of the UI as you can see the result of your changes almost immediately." by the author of Relm4

  1. Mold
    https://github.com/rui314/mold
// After installing mold, all you need to do is add the
// prefix mold -run to the command you want to run.
// Most likely this will be:

mold -run cargo run
  1. Tips for Faster Rust Compile Times
    https://endler.dev/2020/rust-compile-times/

Machine Learning for Rust

  1. Taking ML to production with Rust: a 25x speedup
    https://www.lpalmieri.com/posts/2019-12-01-taking-ml-to-production-with-rust-a-25x-speedup/

  2. Machine learning in Rust using Linfa
    https://blog.logrocket.com/machine-learning-in-rust-using-linfa/

  3. Crate Linfa
    linfa aims to provide a comprehensive toolkit to build Machine Learning applications with Rust.
    Kin in spirit to Python's scikit-learn, it focuses on common preprocessing tasks and classical ML algorithms for your everyday ML tasks.
    https://crates.io/crates/linfa
    https://github.com/rust-ml/linfa

  4. Crate tch-rs
    Rust wrappers for the PyTorch C++ api (libtorch).
    https://crates.io/crates/tch
    https://docs.rs/tch

  5. Crate Rust TensorFlow
    TensorFlow Rust provides idiomatic Rust language bindings for TensorFlow.
    https://crates.io/crates/tensorflow
    https://github.com/tensorflow/rust

  6. Crate rust-xgboost
    Rust bindings for the XGBoost gradient boosting library.
    https://crates.io/crates/xgboost

Rust VSCode plugins

  1. rust-analyzer
    Code analyzer while editing
    https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer
    For better warnings in the same user interface, go into the VSCode settings > Rust Analyzer > Check On Save: Command and setting “clippy” instead of “check”.

  2. Better TOML
    .toml syntax hilight.
    https://marketplace.visualstudio.com/items?itemName=bungcip.better-toml

  3. Error Lens
    Better positioning of error messages in editor.
    https://marketplace.visualstudio.com/items?itemName=usernamehw.errorlens

  4. CodeLLDB - Vadim Chugunov
    Debugger plugin for Rust.
    https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb

  5. Code Spell Checker
    https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker

  6. Markdown All in One
    https://marketplace.visualstudio.com/items?itemName=yzhang.markdown-all-in-one

Rust Debugger

  1. How to Debug Rust with Visual Studio Code
    https://www.forrestthewoods.com/blog/how-to-debug-rust-with-visual-studio-code/

  2. Debugging Rust with VS Code
    https://dev.to/rogertorres/debugging-rust-with-vs-code-11dj

  3. CodeLLDB - Vadim Chugunov
    Plugin for VS Code
    https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb

Rust Error Handling

To define good error types that encapsulate other errors. In the case where you need to return from a function, multiple incompatible types, and you don't want to manually write conversion functions that implement the trait std::convert::From< > .

  1. Crate Anyhow
    Use Anyhow if you don't care what error type your functions return, you just want it to be easy. This is common in application code.
    https://crates.io/crates/anyhow

  2. Crate thiserror
    Use thiserror if you are a library that wants to design your own dedicated error type(s) so that on failures the caller gets exactly the information that you choose.
    https://crates.io/crates/thiserror

Tips and Tricks

GC for Rust - Garbage Collector

“Cases where one needs to maintain a complicated, dynamic graph “(with cycles)” are where a GC becomes useful. Similarly, if one is writing an interpreter for a GCd language, having a GC in Rust would simplify things a lot.”

Programming Parallel computers - Optimization guide C Plus Plus and Rust

  1. Programming Parallel Computers - In depth lectures notes
    https://ppc.cs.aalto.fi/

  2. Comparing Parallel Rust and C++
    https://parallel-rust-cpp.github.io/

  3. Crossbeam - Tools for concurrent programming
    https://crates.io/crates/crossbeam
    Crossbeam - Learning Resources
    https://github.com/crossbeam-rs/rfcs/wiki

  4. Rayon - It is a data-parallelism library for Rust
    https://crates.io/crates/rayon
    Video - Rayon: Data Parallelism for Fun and Profit — Nicholas Matsakis
    https://www.youtube.com/watch?v=gof_OEv71Aw
    Rayon: data parallelism in Rust
    https://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelism-in-rust/
    Rayon docs
    https://docs.rs/rayon/latest/rayon/

  5. dpc-pariter - Parallel iterator processing
    https://crates.io/crates/dpc-pariter
    Adding parallelism to your Rust iterators with dpc-pariter
    https://dpc.pw/adding-parallelism-to-your-rust-iterators

  6. perf Examples
    See also the lecture.
    https://www.brendangregg.com/perf.html

  7. perf: Linux profiling with performance counters
    https://perf.wiki.kernel.org/index.php/Main_Page

  8. Systems Performance Enterprise and the Cloud 2nd Ed
    by Brendan Gregg

To install Perf on your Linux system you can do a simple package installation like apt-get if you are on a debian, then execute perf and it will tell you the package that you will have to install that is specific for your Linux kernel version. If your distribution automatically updates your kernel, you will need to download a new and correct version for your new kernel, and install it with your system package manager, ex: apt-get.

In the Rust .toml file add the 2 following lines, to add the debug symbols table to the Rust executable program file, compiled with

--release
flag:

[profile.release]
debug = true

To run Perf profiling on your Rust executable program. After that you can also use flamegraph.

# Temporarily activate this flag perf_event_paranoid.

> echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid


# Record the executable program profiling data in a .data file.

> perf record -F99 --call-graph dwarf <path to the executable>


# To see the report use with Up/Down arrow keys, with "+"
# and with "a" to see the annotated assembly code with the Rust
# code correspondent code. The report will include the % of time in
# inside the function and in each group of assembly instructions.
# Press "tab" key in annotation mode to jump between hot spots.

> perf report

The Perf profiler has many command use the stat command to get the IPC – Instruction Per Clock Cycle, it's an average.

To know how much peak memory your executable program uses do:

> /usr/bin/time -v <path to the executable>

Note: There are 2 "time" executables and this is not the bash default time program. That's why you have to write the full path

/usr/bin/time
to execute it.

  1. The Rust Performance Book
    https://nnethercote.github.io/perf-book/title-page.html

  2. Guide to Optimization
    Achieving warp speed with Rust
    https://gist.github.com/jFransham/369a86eff00e5f280ed25121454acec1
    Cheap tricks for high-performance Rust
    https://deterministic.space/high-performance-rust.html
    Video - Optimizing Rust - Rust Oslo 2021-11-11 - Lily Mara
    https://www.youtube.com/watch?v=LQ2nIhj45vE
    Optimization - Making Rust Code Go Brrrr
    https://aspenuwu.me/posts/rust-optimization.html
    Profile Guided Optimization
    https://doc.rust-lang.org/rustc/profile-guided-optimization.html
    Optimizations: the speed size tradeoff
    https://rust-embedded.github.io/book/unsorted/speed-vs-size.html

Rust Optimization - Compilation modes and flags

The best way to optimize your code is to choose the right algorithm and the right data structures.

You can also apply several coding techniques that come from the underling knowledge of how the rust transforms your code structures in memory (stack and heap) and how they are executed, for example avoiding allocation, avoiding cloning large things that aren’t basic types and that are by nature cloned. (More info bellow.) You can do profiling to guide you through optimization, identifying the hot-spots to pin point you to the exact code your program spends that 90% of his time. And to allow you to see where you can shave it in the number of instructions that are executed at the same time and to increase your IPC – Instructions Per Clock cycle of your superscaller CPU. And then you can also mess around with compilation flags like the following, see https://nnethercote.github.io/perf-book/build-configuration.html :

[profile.release]
debug = true
  • LTO - Link-Time Optimization
    Link-time optimization (LTO) is a whole-program optimization technique that can improve runtime performance by 10-20% or more, at the cost of increased build times. In
    Cargo.toml
    .
[profile.release]
lto = true
  • Codegen Units
    The Rust compiler splits your crate into multiple codegen units to parallelize (and thus speed up) compilation. However, this might cause it to miss some potential optimizations. This will optimize it as a all, not dividing into more than one units. You have to benchmark it, because it can run faster or in some cases slower. In
    Cargo.toml
    .
[profile.release]
codegen-units = 1
  • Using CPU Specific Instructions - Compiling to native CPU features.
    It identifies and optimizes for the features of your CPU used in the compilation machine.
$ RUSTFLAGS="-C target-cpu=native" cargo build --release
[profile.release]
opt-level = z

Rust bounds check removal

This forum thread shows well some ways to remove bounds check without the need to do a loop for and a iterator, the case where bounds check are automatically removed, or without using the manual way

get_unchecked()
.

I have put here some examples from the previous forum thread of bounds check removal with a simple assert. Imagine that you have a loop with a index array that the compiler can’t easily know that it doesn’t need to bounds check a easy way to ensure that the bounds check will be removed is with the introduction of an assert that will assure to the compiler it is safe. In this case the assert only makes one bounds check outside a loop and all the bounds checks inside the look will disappear.

// Instead of….
for i in array1.len() {
    println!("{} {}", array1[i], array2[i]);
}

// Do….
assert_eq!(array1.len(), array2.len());
for i in array1.len() {
    println!("{} {}", array1[i], array2[i]);
}
// This does three bounds checks
pub fn demo1(x: &[i32]) -> i32 {
    x[0] + x[1] + x[2]
}

// Whereas these two examples each only have one bounds check:
pub fn demo2(x: &[i32]) -> i32 {
    assert!(x.len() >= 3);
    x[0] + x[1] + x[2]
}

pub fn demo3(x: &[i32]) -> i32 {
    let x = &x[..3];
    x[0] + x[1] + x[2]
}
  • Removal of bounds checks in extreme cases.
    Rust has slice, array and Vec bounds checks for each indices.
    If you use iterators there will be no bounds check.
    But in the common case Rust uses LLVM, and LLVM does a very good job at removing the bounds checks that aren't needed.
    But if you need the fastest code implementation and want to remove bounds check, you can use
    get_unchecked()
    and
    get_unchecked_mut()
    , they must be inside a unsafe block.
let x = &mut [1, 2, 4];

unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
}
assert_eq!(x, &[1, 13, 4]);
// Normal performance: 84,694,933 ns/iter (+/- 7,412,836)

// This optimization:  41,440,947 ns/iter (+/- 752,463)   [x2 times faster]

fn bench_vec_of_vec_unsafe(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![vec![0u8; n]; m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                unsafe {
                    *matrix.get_unchecked_mut(i).get_unchecked_mut(j) = 1u8;
                }
            }
        }
    });
}

Notes - General

  • Enum Option - Option.copied()
// y_copy is a new Option of the cloned char 'a'.
// x is Option<&T> and the y_copy is Option<T> . 
let c: char = 'a';
let x: Option<&char> = Some(&c);
let y_copy: Option<char>  = x.copied();  // =>  Option<char>
  • Trait Iterator - Iterator.copied()
    Example modified from std lib docs.
// Trait Iterator - Iterator.copied()
// Creates an iterator which copies all of its elements.
// This is useful when you have an iterator over &T, but you need an iterator over T.

let a = [1, 2, 3];

{
    // Vector of references &T , &i32
    let v_copied_ref: Vec<&i32> = a.iter().collect();
}

// Vector of copied items T , i32
let v_copied: Vec<i32> = a.iter().copied().collect();

// You should write the Vec type like this "vec<_>".
// let v_copied: Vec<_> = a.iter().copied().collect();

// Copied is the same as .map(|&x| x)
let v_map: Vec<_> = a.iter().map(|&x| x).collect();

assert_eq!(v_copied, vec![1, 2, 3]);
assert_eq!(v_map, vec![1, 2, 3]);

// Better and faster to just transform an array into a Vec.
let v_copied_2 = a.to_vec();
assert_eq!(v_copied_2, vec![1, 2, 3]);

Notes on optimization

use std::collections::HashMap;
use fasthash::murmur2::Murmur2_x86_64;

let s = Murmur2_x86_64::new();
let mut map = HashMap::with_hasher(s);
map.insert(1, 2);
  • しかし、さらに高速な HashMap または HashSet を使用するには、
    hashbrown - Google の高性能 SwissTable ハッシュ マップの Rust ポートであるSTD HashMap および HashSet の代わりに、より高速にドロップします。
    https://github.com/Amanieu/hashbrown crate hashbrownをファイルに
    挿入
    .toml

// The fastest HashMap for Rust. HashBrown a drop in replacement for std HashMap.
use hashbrown::HashMap;
  • bstr -有効な UTF-8 である必要のない高速な文字列型。重い UTF-8 検証はありません。
    https://crates.io/crates/bstr

  • LTO (global Link-Time Optimization)を使用した SmartString は
    、一般的に高速 ( 2.5 倍高速) の文字列置換であり、スタックのみが割り当てられる 23 バイト以下の小さな文字列 (例: 「Mary had a little lamb!」) に置き換えられますが、ヒープが割り当てられた長い文字列の場合、String と同じパフォーマンスを発揮します。
    Rust ベンチマーク String vs SmartString および LTO
    https://github.com/joaocarvalhoopen/Rust_benchmark_String_vs_SmartString_and_LTO
    Crate SmartString
    https://crates.io/crates/smartstring

// In main do.
smartstring::validate();

{
   // In the scope, add the alias to replace normal Strings with SmartString.  
   use smartstring::alias::String;

   // When creating SmartString's from &str instead of doing:
   "blabla".to_string()

   // Do:
   String::from("blabla")
}

Rust部分文字列処理

  • UTF-8 の世界のテキストには多くの複雑な詳細があり、Rust はそのすべての力とすべての複雑さをプログラマーに公開するため、Rust 文字列処理はちょっと難しいです。圧倒されることもあります。単純な部分文字列またはスライスのみが必要で、そのコストを支払うことを気にしない場合があります。これは、この機能が本当に必要であり、標準ライブラリがあまり役に立たないためです。

  • 幸いなことに、 carlomilanesiはこのコードをすべてのユーザーが利用できるようにしました
    https://users.rust-lang.org/t/how-to-get-a-substring-of-a-string/1351/11

  • しかし、文字列内の文字の位置に基づいて多くのテキスト操作を行う必要がある場合、これは本当に良いオプションではありません。文字列を分割するために、すべての文字列を最初から正しい位置までスキャンする必要があるためです。文字の正しい境界に。このコンテキストでは、文字列を Vec に変換する前払いコストを喜んで支払います。個々の文字が分離された文字の Vec は、アクセス コストが 1 の位置文字として処理し、スライスし、範囲を指定し、追加します。それらを最後に追加します(または、最初または途中に追加する必要がある場合は、新しいバッファーへのコピーのコストを支払いますが、必要に応じて実行できます)。次のコードは、carlomilanesiのコードを拡張したものです。それはあなたがそれをすることを可能にします。
    私の GitHub リポジトリにもあります…

  • Rust でのサブストリング、スライス、ランダム文字列アクセス
    https://github.com/joaocarvalhoopen/SubStrings_Slices_and_Random_String_Access_in_Rust


use std::ops::{Bound, RangeBounds};

trait StringUtils {
    fn substring(&self, start: usize, len: usize) -> &str;
    fn slice(&self, range: impl RangeBounds<usize>) -> &str;
    fn get_vec_chars(&self) -> Vec<char>;
}

impl StringUtils for str {
    fn substring(&self, start: usize, len: usize) -> &str {
        let mut char_pos = 0;
        let mut byte_start = 0;
        let mut it = self.chars();
        loop {
            if char_pos == start { break; }
            if let Some(c) = it.next() {
                char_pos += 1;
                byte_start += c.len_utf8();
            }
            else { break; }
        }
        char_pos = 0;
        let mut byte_end = byte_start;
        loop {
            if char_pos == len { break; }
            if let Some(c) = it.next() {
                char_pos += 1;
                byte_end += c.len_utf8();
            }
            else { break; }
        }
        &self[byte_start..byte_end]
    }
    fn slice(&self, range: impl RangeBounds<usize>) -> &str {
        let start = match range.start_bound() {
            Bound::Included(bound) | Bound::Excluded(bound) => *bound,
            Bound::Unbounded => 0,
        };
        let len = match range.end_bound() {
            Bound::Included(bound) => *bound + 1,
            Bound::Excluded(bound) => *bound,
            Bound::Unbounded => self.len(),
        } - start;
        self.substring(start, len)
    }
    fn get_vec_chars(&self) -> Vec<char> { self.chars().collect() }
}

trait StringUtilsVecChars {
    fn to_string(&self) -> String;
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String;
}

impl StringUtilsVecChars for Vec<char> {
    fn to_string(&self) -> String { self.iter().collect() }
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String {
        buf.clear();
        for c in self.iter() { buf.push(*c); }
        buf
    }
}

trait StringUtilsSlices {
    fn to_string(&self) -> String;
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String;
}

impl StringUtilsSlices for [char] {
    fn to_string(&self) -> String { self.iter().collect() }
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String {
        buf.clear();
        for c in self.iter() { buf.push(*c); }
        buf
    }
}

fn main() {
    let s = "abcdèfghij";
    // All three statements should print:
    // "abcdè, abcdèfghij, dèfgh, dèfghij."
    println!("{}, {}, {}, {}.",
        s.substring(0, 5),
        s.substring(0, 50),
        s.substring(3, 5),
        s.substring(3, 50));
    println!("{}, {}, {}, {}.",
        s.slice(..5),
        s.slice(..50),
        s.slice(3..8),
        s.slice(3..));
    println!("{}, {}, {}, {}.",
        s.slice(..=4),
        s.slice(..=49),
        s.slice(3..=7),
        s.slice(3..));

    // Allocating a string from Vec<char>.
    let mut vc = s.get_vec_chars(); 
    println!("{}, {}, {}, {}.",
        vc[..5].to_string(),
        vc.to_string(),
        vc[3..8].to_string(),
        vc[3..].to_string());

    // Reusing a String buffer from a Vec<char>.
    let mut buf = String::new();
    print!("{}, ", vc[..5].to_string_buf(& mut buf));
    print!("{}, ", vc[..].to_string_buf(& mut buf));
    print!("{}, ", vc[3..8].to_string_buf(& mut buf));
    print!("{}.\n", vc[3..].to_string_buf(& mut buf));
    
    // Random access to the Vec<char>. 
    for i in 0..(vc.len() - 2) {
        print!("{} ", vc[i..i+3].to_string_buf(& mut buf));
    }
    println!("");
    
    // Random modifications to the Vec<char>.
    for i in (0..(vc.len() / 3) + 1).rev() {
        vc.insert(i*3, '#');
    }
    println!("{} ", vc.to_string());
    println!("{} ", vc.to_string_buf(& mut buf));
}

// Output:
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abc bcd cdè dèf èfg fgh ghi hij 
//    #abc#dèf#ghi#j
//    #abc#dèf#ghi#j

Rustのマクロ

  1. マクロ ファイルの可視性ルール
    https://users.rust-lang.org/t/3-things-that-the-rust-standard-library-should-have/68825/11

  2. hashMap、hashset、btreeMap、btreeSet のマクロは Python
    Crate maplitに似てい
    ます https://crates.io/crates/maplit

#[macro_use] extern crate maplit;

let map = hashmap!{
    "a" => 1,
    "b" => 2,
};

let map1: HashMap<String, String> = convert_args!(hashmap!(
    "a" => "b",
    "c" => "d",
));

let map2 = convert_args!(keys=String::from, hashmap!(
    "a" => 1,
    "c" => 2,
));
  1. グラフのマクロ
    Rust ユーザー フォーラムにある kaj の次の投稿を参照してください。
    https://users.rust-lang.org/t/3-things-that-the-rust-standard-library-should-have/68825/9
# When you have the following dictionary Python code...

# Adjacency list of graph
data = {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
}
// And you implement it in Rust like this...

let data = HashMap::from([
    (0, vec![1, 2]),
    (1, vec![0, 2]),
    (2, vec![0, 1, 3, 5]),
]);

// ...but you can instead implement it like this...

let data2 = graph![
    0 => 1, 2;
    1 => 0, 2;
    2 => 0, 1, 3, 5
];

// ...using the following simple Macro...

use std::collections::HashMap;

macro_rules! graph {
    [$($k:expr => $($v:expr),*);*] => {
        HashMap::from([
            $(($k, vec![ $($v),* ])),*
        ])
    }
}

コンピュータとプログラミングのトピックについて学ぶ良い方法

  1. ビデオ - コンピューター サイエンス - クラッシュ コース
    https://www.youtube.com/playlist?list=PL8dPuuaLjXtNlUrzyH5r6jN9ulIgZBpdo

良い課題として、Rust で NAND To Tetris を実行します。

  1. Nand から Tetris
    まで 第一原理から最新のコンピューターを構築
    https://www.nand2tetris.org/

  2. ビデオ - Shimon Schocken: 自己組織化コンピューター コース
    https://www.youtube.com/watch?v=iE7YRHxwoDs

  3. ビデオ - Nand からテトリスへのパート I コース プロモ
    https://www.youtube.com/watch?v=wTl5wRDT0CU


  4. 無料コース - Nand から Tetris までの基本原則から最新のコンピューターを構築する(プロジェクト中心のコース)
    https://www.coursera.org/learn/build-a-computer

  5. 無料コース - 第 1 原則
    Nand から Tetris パート II までの最新のコンピューターを構築する (プロジェクト中心のコース)
    https://www.coursera.org/learn/nand2tetris2

私の他のすべてのガイド

  • 私のすべてのガイドへのリンクは次のとおりです。
    Linux のガイド - プログラミング - 組み込み - エレクトロニクス - 航空

楽しむ

敬具、
ジョアン・ヌーノ・カルヴァーリョ