├── src-en ├── .gitignore ├── css └── custom.css ├── docs ├── .nojekyll ├── css │ ├── custom.css │ └── print.css ├── favicon.png ├── FontAwesome │ └── fonts │ │ ├── FontAwesome.ttf │ │ ├── fontawesome-webfont.eot │ │ ├── fontawesome-webfont.ttf │ │ ├── fontawesome-webfont.woff │ │ └── fontawesome-webfont.woff2 ├── fonts │ ├── open-sans-v17-all-charsets-300.woff2 │ ├── open-sans-v17-all-charsets-600.woff2 │ ├── open-sans-v17-all-charsets-700.woff2 │ ├── open-sans-v17-all-charsets-800.woff2 │ ├── open-sans-v17-all-charsets-italic.woff2 │ ├── open-sans-v17-all-charsets-300italic.woff2 │ ├── open-sans-v17-all-charsets-600italic.woff2 │ ├── open-sans-v17-all-charsets-700italic.woff2 │ ├── open-sans-v17-all-charsets-800italic.woff2 │ ├── open-sans-v17-all-charsets-regular.woff2 │ └── source-code-pro-v11-all-charsets-500.woff2 ├── 404.md └── editor.js ├── .gitattributes ├── .gitmodules ├── src-old ├── unsafe │ ├── pointer.rs │ └── transmute.rs ├── flow_control │ ├── match │ │ ├── destructuring │ │ │ ├── input.md │ │ │ ├── destructure_tuple │ │ │ │ ├── input.md │ │ │ │ └── tuples.rs │ │ │ ├── destructure_structures │ │ │ │ ├── input.md │ │ │ │ └── struct.rs │ │ │ ├── destructure_references │ │ │ │ ├── input.md │ │ │ │ └── ref.rs │ │ │ ├── destructure_pointers │ │ │ │ └── input.md │ │ │ └── destructure_enum │ │ │ │ └── input.md │ │ ├── input.md │ │ ├── guard │ │ │ ├── input.md │ │ │ └── guard.rs │ │ ├── binding │ │ │ ├── input.md │ │ │ └── binding.rs │ │ └── match.rs │ ├── input.md │ ├── while │ │ ├── input.md │ │ └── while.rs │ ├── for │ │ ├── for.rs │ │ └── input.md │ ├── loop │ │ ├── nested │ │ │ ├── input.md │ │ │ └── nested.rs │ │ ├── input.md │ │ └── loop.rs │ ├── if_else │ │ ├── input.md │ │ └── if_else.rs │ ├── while_let │ │ └── while_let.rs │ └── if_let │ │ ├── input.md │ │ └── if_let.rs ├── scope │ ├── move │ │ ├── mut │ │ │ ├── input.md │ │ │ └── mut.rs │ │ ├── input.md │ │ └── move.rs │ ├── lifetime │ │ ├── methods │ │ │ ├── input.md │ │ │ └── methods.rs │ │ ├── struct │ │ │ ├── input.md │ │ │ └── struct.rs │ │ ├── lifetime_coercion │ │ │ ├── input.md │ │ │ └── coercion.rs │ │ ├── elision │ │ │ ├── elision.rs │ │ │ └── input.md │ │ ├── lifetime_bounds │ │ │ ├── bounds.rs │ │ │ └── input.md │ │ ├── static_lifetime │ │ │ ├── static_lifetime.rs │ │ │ └── input.md │ │ ├── fn │ │ │ ├── input.md │ │ │ └── fn.rs │ │ ├── explicit │ │ │ └── explicit.rs │ │ └── lifetime.rs │ ├── borrow │ │ ├── freeze │ │ │ ├── input.md │ │ │ └── freeze.rs │ │ ├── ref │ │ │ └── input.md │ │ ├── alias │ │ │ └── input.md │ │ ├── mut │ │ │ └── input.md │ │ ├── input.md │ │ └── borrow.rs │ ├── input.md │ └── raii │ │ └── raii.rs ├── fn │ ├── closures │ │ ├── closure_examples │ │ │ ├── input.md │ │ │ ├── iter_any │ │ │ │ ├── iter_any.rs │ │ │ │ └── input.md │ │ │ └── iter_find │ │ │ │ ├── iter_find.rs │ │ │ │ └── input.md │ │ ├── input_functions │ │ │ ├── input_functions.rs │ │ │ └── input.md │ │ ├── anonymity │ │ │ └── anonymity.rs │ │ ├── output_parameters │ │ │ └── output_parameters.rs │ │ ├── input.md │ │ ├── closures.rs │ │ └── capture │ │ │ └── input.md │ ├── methods │ │ └── input.md │ ├── hof │ │ ├── input.md │ │ └── hof.rs │ ├── input.md │ └── fn.rs ├── attribute │ ├── cfg │ │ ├── custom │ │ │ ├── custom.rs │ │ │ └── input.md │ │ ├── cfg.rs │ │ └── input.md │ ├── unused │ │ ├── unused.rs │ │ └── input.md │ └── crate │ │ ├── lib.rs │ │ └── input.md ├── std_misc │ ├── process │ │ ├── wait │ │ │ ├── wait.rs │ │ │ └── input.md │ │ ├── pipe │ │ │ └── input.md │ │ ├── input.md │ │ └── process.rs │ ├── arg │ │ ├── input.md │ │ ├── args.rs │ │ └── matching │ │ │ └── input.md │ ├── channels │ │ └── input.md │ ├── threads │ │ ├── input.md │ │ └── threads.rs │ ├── path │ │ └── path.rs │ ├── input.md │ ├── ffi │ │ ├── input.md │ │ ├── safe.rs │ │ └── ffi.rs │ ├── file │ │ ├── input.md │ │ └── open │ │ │ ├── input.md │ │ │ └── open.rs │ └── fs │ │ └── input.md ├── mod │ ├── use │ │ ├── input.md │ │ └── use.rs │ ├── split │ │ ├── my │ │ │ ├── nested.rs │ │ │ ├── inaccessible.rs │ │ │ └── mod.rs │ │ ├── split.rs │ │ └── input.md │ ├── super │ │ └── input.md │ ├── visibility │ │ └── input.md │ ├── input.md │ └── struct_visibility │ │ └── input.md ├── todo │ └── input.md ├── input.md ├── custom_types │ ├── enum │ │ ├── c_like │ │ │ ├── input.md │ │ │ └── c_like.rs │ │ ├── enum_use │ │ │ ├── input.md │ │ │ └── use.rs │ │ ├── testcase_linked_list │ │ │ └── input.md │ │ └── input.md │ ├── input.md │ ├── constants │ │ └── constants.rs │ └── structs │ │ ├── input.md │ │ └── structs.rs ├── crates │ ├── link │ │ ├── executable.rs │ │ └── input.md │ ├── lib │ │ ├── rary.rs │ │ └── input.md │ └── input.md ├── macros │ ├── overload │ │ ├── input.md │ │ └── overload.rs │ ├── simple.rs │ ├── designators │ │ ├── input.md │ │ └── designators.rs │ ├── repeat │ │ ├── repeat.rs │ │ └── input.md │ ├── dry │ │ └── input.md │ └── input.md ├── error │ ├── error.rs │ ├── result │ │ └── result.rs │ ├── result_alias │ │ ├── alias.rs │ │ └── input.md │ ├── option_with_result │ │ ├── option_result.rs │ │ ├── combinator_combinations │ │ │ └── input.md │ │ ├── input.md │ │ └── result_string_errors │ │ │ ├── input.md │ │ │ └── result_string.rs │ ├── result_map │ │ └── result.rs │ ├── map │ │ └── input.md │ └── unwrap │ │ └── unwrap.rs ├── variable_bindings │ ├── mut │ │ ├── input.md │ │ └── mut.rs │ ├── scope │ │ ├── input.md │ │ └── scope.rs │ ├── declare │ │ ├── input.md │ │ └── declare.rs │ ├── input.md │ └── variable_bindings.rs ├── hello │ ├── hello.rs │ ├── comment │ │ ├── comment.rs │ │ └── input.md │ ├── print │ │ ├── print_debug │ │ │ └── debug.rs │ │ └── print_display │ │ │ └── testcase_list │ │ │ └── testcase_list.rs │ └── input.md ├── generics │ ├── multi_bounds │ │ ├── input.md │ │ └── multi.rs │ ├── impl │ │ ├── impl.rs │ │ └── input.md │ ├── gen_trait │ │ ├── input.md │ │ └── trait.rs │ ├── where │ │ └── where.rs │ ├── bounds │ │ ├── testcase_empty │ │ │ ├── input.md │ │ │ └── empty.rs │ │ └── bounds.rs │ ├── assoc_items │ │ ├── input.md │ │ └── types │ │ │ └── input.md │ ├── generics.rs │ ├── gen_fn │ │ ├── input.md │ │ └── fn.rs │ └── phantom │ │ └── input.md ├── primitives │ ├── primitives.rs │ ├── literals │ │ └── literals.rs │ └── array │ │ ├── input.md │ │ └── array.rs ├── expression │ └── expression.rs ├── cast │ ├── inference │ │ ├── inference.rs │ │ └── input.md │ ├── input.md │ ├── literals │ │ └── literals.rs │ └── alias │ │ ├── alias.rs │ │ └── input.md ├── meta │ ├── doc │ │ ├── input.md │ │ └── doc.rs │ ├── test │ │ └── unit_test.rs │ └── input.md ├── std │ ├── panic │ │ └── panic.rs │ ├── option │ │ ├── input.md │ │ └── option.rs │ ├── box │ │ └── input.md │ ├── input.md │ ├── result │ │ ├── try │ │ │ └── input.md │ │ └── input.md │ ├── vec │ │ ├── input.md │ │ └── vec.rs │ ├── str │ │ └── input.md │ └── hash │ │ ├── hashset │ │ └── hashset.rs │ │ └── input.md └── trait │ ├── clone │ ├── input.md │ └── clone.rs │ ├── input.md │ ├── drop │ ├── input.md │ └── drop.rs │ ├── ops │ ├── operator.rs │ └── input.md │ ├── iter │ └── input.md │ └── derive │ └── derive.rs ├── transcheck.toml ├── src ├── fn │ └── closures │ │ └── closure_examples.md ├── flow_control.md ├── scope.md ├── compatibility.md ├── custom_types.md ├── mod.md ├── macros │ └── syntax.md ├── std_misc.md ├── meta.md ├── scope │ ├── lifetime │ │ ├── methods.md │ │ └── trait.md │ └── move │ │ └── mut.md ├── flow_control │ ├── loop │ │ ├── return.md │ │ └── nested.md │ ├── match │ │ └── destructuring.md │ ├── while.md │ └── loop.md ├── std_misc │ ├── process │ │ └── wait.md │ ├── file.md │ └── process.md ├── types.md ├── conversion.md ├── error │ └── panic.md ├── attribute │ ├── cfg │ │ └── custom.md │ └── unused.md ├── generics │ ├── assoc_items.md │ └── multi_bounds.md ├── std.md ├── cargo.md ├── variable_bindings │ ├── mut.md │ └── freeze.md ├── crates.md ├── custom_types │ └── enum │ │ └── c_like.md └── crates │ ├── lib.md │ ├── link.md │ └── using_lib.md ├── book.toml ├── patches └── 404.md ├── README.md ├── LICENSE-MIT └── tools └── circleci └── push-to-master.sh /src-en: -------------------------------------------------------------------------------- 1 | .examples-en/src -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | docs/ 2 | 3 | -------------------------------------------------------------------------------- /css/custom.css: -------------------------------------------------------------------------------- 1 | em { 2 | font-weight: bold; 3 | font-style: normal; 4 | } 5 | -------------------------------------------------------------------------------- /docs/.nojekyll: -------------------------------------------------------------------------------- 1 | This file makes sure that Github Pages doesn't process mdBook's output. 2 | -------------------------------------------------------------------------------- /docs/css/custom.css: -------------------------------------------------------------------------------- 1 | em { 2 | font-weight: bold; 3 | font-style: normal; 4 | } 5 | -------------------------------------------------------------------------------- /docs/favicon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/favicon.png -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Set the default behavior, in case people don't have core.autocrlf set. 2 | * text=auto eol=lf 3 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule ".examples-en"] 2 | path = .examples-en 3 | url = https://github.com/rust-lang/rust-by-example/ 4 | -------------------------------------------------------------------------------- /docs/FontAwesome/fonts/FontAwesome.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/FontAwesome/fonts/FontAwesome.ttf -------------------------------------------------------------------------------- /src-old/unsafe/pointer.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let raw_p: *const u32 = &10; 3 | 4 | unsafe { 5 | assert!(*raw_p == 10); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /docs/FontAwesome/fonts/fontawesome-webfont.eot: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/FontAwesome/fonts/fontawesome-webfont.eot -------------------------------------------------------------------------------- /docs/FontAwesome/fonts/fontawesome-webfont.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/FontAwesome/fonts/fontawesome-webfont.ttf -------------------------------------------------------------------------------- /docs/FontAwesome/fonts/fontawesome-webfont.woff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/FontAwesome/fonts/fontawesome-webfont.woff -------------------------------------------------------------------------------- /docs/FontAwesome/fonts/fontawesome-webfont.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/FontAwesome/fonts/fontawesome-webfont.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-300.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-300.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-600.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-600.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-700.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-700.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-800.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-800.woff2 -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/input.md: -------------------------------------------------------------------------------- 1 | 2 | `match`は値をさまざまなやり方でデストラクトすることができます。 3 | -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-italic.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-italic.woff2 -------------------------------------------------------------------------------- /src-old/scope/move/mut/input.md: -------------------------------------------------------------------------------- 1 | 2 | データのミュータビリティは所有権を移譲した際に変更できます。 3 | 4 | {mut.play} 5 | -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-300italic.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-300italic.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-600italic.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-600italic.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-700italic.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-700italic.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-800italic.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-800italic.woff2 -------------------------------------------------------------------------------- /docs/fonts/open-sans-v17-all-charsets-regular.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/open-sans-v17-all-charsets-regular.woff2 -------------------------------------------------------------------------------- /docs/fonts/source-code-pro-v11-all-charsets-500.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rust-lang-ja/rust-by-example-ja/HEAD/docs/fonts/source-code-pro-v11-all-charsets-500.woff2 -------------------------------------------------------------------------------- /src-old/fn/closures/closure_examples/input.md: -------------------------------------------------------------------------------- 1 | 2 | この節では`std`ライブラリを用いて、クロージャの利用例を幾つかお見せします。 3 | -------------------------------------------------------------------------------- /src-old/unsafe/transmute.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let u: &[u8] = &[49, 50, 51]; 3 | 4 | unsafe { 5 | assert!(u == std::mem::transmute::<&str, &[u8]>("123")); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src-old/attribute/cfg/custom/custom.rs: -------------------------------------------------------------------------------- 1 | #[cfg(some_condition)] 2 | fn conditional_function() { 3 | println!("condition met!") 4 | } 5 | 6 | fn main() { 7 | conditional_function(); 8 | } 9 | -------------------------------------------------------------------------------- /src-old/std_misc/process/wait/wait.rs: -------------------------------------------------------------------------------- 1 | use std::process::Command; 2 | 3 | fn main() { 4 | let _process = Command::new("sleep").arg("5").spawn(); 5 | 6 | println!("reached end of main"); 7 | } 8 | -------------------------------------------------------------------------------- /src-old/mod/use/input.md: -------------------------------------------------------------------------------- 1 | 3 | `use`宣言をすることで、要素の絶対パスを新しい名前にバインドすることができ、より簡潔な記述が可能になります。 4 | 5 | {use.play} 6 | -------------------------------------------------------------------------------- /src-old/todo/input.md: -------------------------------------------------------------------------------- 1 | If you would like to see a chapter about some concept or library, please drop a 2 | comment in [issue #1][issue-1] 3 | 4 | [issue-1]: https://github.com/rust-lang/rust-by-example/issues/1 5 | -------------------------------------------------------------------------------- /transcheck.toml: -------------------------------------------------------------------------------- 1 | [matcher] 2 | enable_code_comment_tweak = false 3 | code_comment_header = "# " 4 | [linter] 5 | enable_emphasis_check = true 6 | enable_half_paren_check = true 7 | enable_full_paren_check = true 8 | -------------------------------------------------------------------------------- /src-old/flow_control/match/input.md: -------------------------------------------------------------------------------- 1 | 3 | Rustは`match`を用いて、C言語における`switch`のようなパターンマッチングを行うことができます。 4 | 5 | {match.play} 6 | -------------------------------------------------------------------------------- /src-old/input.md: -------------------------------------------------------------------------------- 1 | The chapters in this section are being worked on. These chapters are likely to 2 | contain valid information, but may be unsorted or some of the concepts used 3 | in them may have not been explained yet. 4 | -------------------------------------------------------------------------------- /src-old/mod/split/my/nested.rs: -------------------------------------------------------------------------------- 1 | pub fn function() { 2 | println!("called `my::nested::function()`"); 3 | } 4 | 5 | #[allow(dead_code)] 6 | fn private_function() { 7 | println!("called `my::nested::private_function()`"); 8 | } 9 | -------------------------------------------------------------------------------- /src-old/mod/split/my/inaccessible.rs: -------------------------------------------------------------------------------- 1 | #[allow(dead_code)] 2 | pub fn public_function() { 3 | println!("called `my::inaccessible::public_function()`"); 4 | } 5 | 6 | // 訳注: この関数は`my/mod.rs`中で`pub mod`されていないため、 7 | // `split.rs`からは呼び出すことができない。 8 | -------------------------------------------------------------------------------- /src/fn/closures/closure_examples.md: -------------------------------------------------------------------------------- 1 | 4 | # `std`における使用例 5 | 6 | 9 | この節では`std`ライブラリを用いて、クロージャの利用例を幾つかお見せします。 10 | -------------------------------------------------------------------------------- /src-old/custom_types/enum/c_like/input.md: -------------------------------------------------------------------------------- 1 | 2 | 列挙型はC言語の列挙型のような使い方をする事もできます。 3 | 4 | {c_like.play} 5 | 6 | 9 | ### 参照 10 | 11 | [キャスティング][cast] 12 | 13 | [cast]: ./cast.html 14 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/methods/input.md: -------------------------------------------------------------------------------- 1 | 2 | メソッドのライフタイムは関数に似ている。 3 | 4 | {methods.play} 5 | 6 | 9 | ### 参照 10 | 11 | [メソッド][methods] 12 | 13 | 14 | [methods]: /fn/methods.html 15 | -------------------------------------------------------------------------------- /src-old/flow_control/input.md: -------------------------------------------------------------------------------- 1 | 3 | 処理の流れをコントロールすることはあらゆるプログラミング言語において重要な要素です。 4 | 5 | `if`/`else`, `for`等です。Rustの文法を見ていきましょう。 6 | -------------------------------------------------------------------------------- /src-old/mod/super/input.md: -------------------------------------------------------------------------------- 1 | 3 | `super`及び`self`キーワードは、要素にアクセスする際に、曖昧さをなくし、不必要なハードコーディングを避けるために使用できます。 4 | 5 | {super.play} 6 | -------------------------------------------------------------------------------- /src-old/flow_control/match/guard/input.md: -------------------------------------------------------------------------------- 1 | 2 | `match`内の条件文をフィルタリングするために、*ガード(`guard`)*を使用することができます。 3 | 4 | {guard.play} 5 | 6 | 9 | ### 参照 10 | 11 | [タプル](../../primitives/tuples.html) 12 | -------------------------------------------------------------------------------- /src-old/crates/link/executable.rs: -------------------------------------------------------------------------------- 1 | // `library`にリンクし、`rary`モジュール内の要素を全てインポートする。 2 | extern crate rary; 3 | 4 | fn main() { 5 | rary::public_function(); 6 | 7 | // エラー！`private_function`はプライベート 8 | //rary::private_function(); 9 | 10 | rary::indirect_access(); 11 | } 12 | -------------------------------------------------------------------------------- /src-old/macros/overload/input.md: -------------------------------------------------------------------------------- 1 | 3 | マクロは異なる引数の組み合わせを取るようにオーバーロードすることができるため、`macro_rules!`はマッチと似たような使い方をすることができます。 4 | 5 | {overload.play} 6 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_tuple/input.md: -------------------------------------------------------------------------------- 1 | 2 | 以下のように、タプルは`match`を用いてデストラクトすることができます。 3 | 4 | {tuples.play} 5 | 6 | 9 | ### 参照 10 | 11 | [タプル](../../../primitives/tuples.html) 12 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/struct/input.md: -------------------------------------------------------------------------------- 1 | 2 | 構造体におけるライフタイムも関数のそれと似ている。 3 | 4 | {struct.play} 5 | 6 | 9 | ### 参照 10 | 11 | [`structs`][structs] 12 | 13 | [structs]: /custom_types/structs.html 14 | -------------------------------------------------------------------------------- /src-old/attribute/unused/unused.rs: -------------------------------------------------------------------------------- 1 | fn used_function() {} 2 | 3 | // `#[allow(dead_code)]`は`dead_code`リントを抑制するアトリビュートです。 4 | #[allow(dead_code)] 5 | fn unused_function() {} 6 | 7 | fn noisy_unused_function() {} 8 | // FIXME ^ 警告を抑制するアトリビュートを追加しましょう。 9 | 10 | fn main() { 11 | used_function(); 12 | } 13 | -------------------------------------------------------------------------------- /src-old/std_misc/process/pipe/input.md: -------------------------------------------------------------------------------- 1 | 4 | `Process`構造体は実行中の子プロセスを表します。`stdin`、`stdout`、`stderr`を介して表面化のプロセスとのやり取りを仲介します。 5 | 6 | {pipe.play} 7 | -------------------------------------------------------------------------------- /src-old/scope/borrow/freeze/input.md: -------------------------------------------------------------------------------- 1 | 3 | (訳注: ミュータブルな)データがイミュータブルに借用された場合、同時に*フリーズ*します。*フリーズ*したデータは、参照が全てスコープから出て行かないかぎり、元のオブジェクトを介して変更することはできません。 4 | 5 | 6 | {freeze.play} 7 | -------------------------------------------------------------------------------- /src-old/error/error.rs: -------------------------------------------------------------------------------- 1 | fn give_princess(gift: &str) { 2 | // お姫様はヘビが大嫌いです。拒絶の意思をお示しに 3 | // なられたなら、直ちにストップしなくてはなりません。 4 | if gift == "snake" { panic!("AAAaaaaa!!!!"); } 5 | 6 | println!("I love {}s!!!!!", gift); 7 | } 8 | 9 | fn main() { 10 | give_princess("teddy bear"); 11 | give_princess("snake"); 12 | } 13 | -------------------------------------------------------------------------------- /src-old/macros/simple.rs: -------------------------------------------------------------------------------- 1 | // `say_hello`という名のシンプルなマクロ 2 | macro_rules! say_hello { 3 | // `()`はマクロが引数をとらないことを示す。 4 | () => ( 5 | // マクロは(訳注: プリコンパイルの段階で)このブロック内の内容に展開されます。 6 | println!("Hello!"); 7 | ) 8 | } 9 | 10 | fn main() { 11 | // この呼び出しは`println!("Hello");`に置き換えられます。 12 | say_hello!() 13 | } 14 | -------------------------------------------------------------------------------- /src/flow_control.md: -------------------------------------------------------------------------------- 1 | 4 | # 条件分岐 5 | 6 | 10 | 処理の流れをコントロールすることはあらゆるプログラミング言語において重要な要素です。 11 | 12 | `if`/`else`, `for`等です。Rustの文法を見ていきましょう。 13 | -------------------------------------------------------------------------------- /src-old/fn/methods/input.md: -------------------------------------------------------------------------------- 1 | 4 | メソッドとはオブジェクトに付属した関数のことです。オブジェクトの持つデータや他のメソッドへは`self`という語を介してアクセスすることができます。`impl`キーワードによって定義します。 5 | 6 | {methods.play} 7 | -------------------------------------------------------------------------------- /src-old/variable_bindings/mut/input.md: -------------------------------------------------------------------------------- 1 | 3 | 変数はデフォルトでイミュータブル（変更不可能）ですが`mut`構文を使用することでミュータブルになります。 4 | 5 | {mut.play} 6 | 7 | 8 | コンパイラはミュータビリティに関するエラーの詳細を出してくれます。 9 | -------------------------------------------------------------------------------- /src-old/crates/lib/rary.rs: -------------------------------------------------------------------------------- 1 | pub fn public_function() { 2 | println!("called rary's `public_function()`"); 3 | } 4 | 5 | fn private_function() { 6 | println!("called rary's `private_function()`"); 7 | } 8 | 9 | pub fn indirect_access() { 10 | print!("called rary's `indirect_access()`, that\n> "); 11 | 12 | private_function(); 13 | } 14 | -------------------------------------------------------------------------------- /src-old/custom_types/enum/enum_use/input.md: -------------------------------------------------------------------------------- 1 | 2 | `use`を使用すれば変数のスコープを絶対名で指定する必要がなくなる。 3 | 4 | {use.play} 5 | 6 | 9 | ### 参照 10 | 11 | [マッチ(`match`)][match] and [`use`][use] 12 | 13 | [use]: ./mod/use.html 14 | [match]: ./flow_control/match.html 15 | -------------------------------------------------------------------------------- /src-old/custom_types/input.md: -------------------------------------------------------------------------------- 1 | 2 | Rustでのカスタムデータ型の作成は主に以下の2つのキーワードを介して行われます。 3 | 4 | * `struct`: 構造体を定義する 5 | * `enum`: 列挙型を定義する 6 | 7 | 8 | 9 | `const`、あるいは`static`というキーワードによって定数を定義することもできます。 10 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_structures/input.md: -------------------------------------------------------------------------------- 1 | 2 | 以下のようにして、構造体(`struct`)も同様にデストラクトすることができる。 3 | 4 | {struct.play} 5 | 6 | 9 | ### 参照 10 | 11 | [構造体](../../../custom_types/structs.html), [refによるパターンマッチ](../../../scope/borrow/ref.html) 12 | -------------------------------------------------------------------------------- /src-old/hello/hello.rs: -------------------------------------------------------------------------------- 1 | // これはコメントです。コンパイラによって無視されます。 2 | // 右にある「Run」ボタンからこのコードをテストできます。 3 | // キーボードを使いたければ「Ctrl + Enter」もOKです。 4 | 5 | // このコードは編集可能です。ぜひハックしてみましょう！ 6 | // 「Reset」ボタンでいつでも元のコードに戻すことができます -> 7 | 8 | // main関数です 9 | fn main() { 10 | // コンパイルされたバイナリが実行されるとこの関数が呼び出されます 11 | 12 | // コンソールに文字列を出力する 13 | println!("Hello World!"); 14 | } 15 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_references/input.md: -------------------------------------------------------------------------------- 1 | 3 | リファレンスとミュータブルなリファレンスはそれぞれ`ref`と`ref mut`を使用することで取得できます。 4 | 5 | {ref.play} 6 | 7 | 10 | ### 参照 11 | 12 | [借用 (`&`)][borrow] 13 | 14 | [borrow]: ../../../borrow.html 15 | -------------------------------------------------------------------------------- /src-old/mod/split/split.rs: -------------------------------------------------------------------------------- 1 | // このように宣言すると、`my.rs`または、`my/mod.rs`という名のファイルを探し、 2 | // その内容をこのファイル中で`my`という名から使用することができるようにします。 3 | mod my; 4 | 5 | fn function() { 6 | println!("called `function()`"); 7 | } 8 | 9 | fn main() { 10 | my::function(); 11 | 12 | function(); 13 | 14 | my::indirect_access(); 15 | 16 | my::nested::function(); 17 | } 18 | -------------------------------------------------------------------------------- /src-old/flow_control/while/input.md: -------------------------------------------------------------------------------- 1 | 2 | `while`キーワードは条件が満たされるまでのループのために使用します。 3 | 4 | 5 | 悪名高い[FizzBuzz問題][fizzbuzz]を`while`を用いて解いてみましょう。 6 | 7 | {while.play} 8 | 9 | [fizzbuzz]: http://en.wikipedia.org/wiki/Fizz_buzz 10 | -------------------------------------------------------------------------------- /src-old/mod/visibility/input.md: -------------------------------------------------------------------------------- 1 | 4 | デフォルトでは、モジュール内の要素はプライベートですが、これは`pub`で修飾することでパブリックな属性にすることができます。パブリックな属性のみがモジュールの外のスコープからアクセスすることができるようになります。 5 | 6 | {visibility.play} 7 | -------------------------------------------------------------------------------- /src-old/scope/input.md: -------------------------------------------------------------------------------- 1 | 4 | 所有権、借用、ライフタイムといったRustに特有の概念において、変数のスコープは重要な役割を果たします。すなわち、スコープの存在によってコンパイラは借用は可能か否か、メモリ上の資源は解放可能か、変数はいつ作成され、いつ破棄されるか。といったことを知るのです。 5 | -------------------------------------------------------------------------------- /src-old/custom_types/enum/testcase_linked_list/input.md: -------------------------------------------------------------------------------- 1 | 2 | `enum`を使用が適切なパターンのひとつに、連結リスト(`linked-list`)を作成する場合があります。 3 | 4 | {linked_list.play} 5 | 6 | 9 | ### 参照 10 | 11 | [ボックス(`Box`)][box] and [メソッド][methods] 12 | 13 | [box]: ./std/box.html 14 | [methods]: ./fn/methods.html 15 | -------------------------------------------------------------------------------- /src-old/std_misc/arg/input.md: -------------------------------------------------------------------------------- 1 | 3 | コマンドライン引数は`std::env::args`を介して取得できます。これはそれぞれの引数を文字列としてyieldするイテレータを返します。 4 | 5 | {args.play} 6 | 7 | ``` 8 | $ ./args 1 2 3 9 | My path is ./args. 10 | I got 3 arguments: ["1", "2", "3"]. 11 | ``` 12 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/methods/methods.rs: -------------------------------------------------------------------------------- 1 | struct Owner(i32); 2 | 3 | impl Owner { 4 | // 通常の関数と同様にライフタイムを明示 5 | fn add_one<'a>(&'a mut self) { self.0 += 1 } 6 | fn print<'a>(&'a self) { 7 | println!("`print`: {}", self.0); 8 | } 9 | } 10 | 11 | fn main() { 12 | let mut owner = Owner(18); 13 | 14 | owner.add_one(); 15 | owner.print(); 16 | } 17 | -------------------------------------------------------------------------------- /src-old/scope/borrow/ref/input.md: -------------------------------------------------------------------------------- 1 | 4 | `let`を介してデストラクトやパターンマッチングを行う場合、`ref`キーワードを用いて構造体・タプルのフィールドへのリファレンスを取得することができます。以下の例ではこれが有用になる例を幾つかお見せします。 5 | 6 | {ref.play} 7 | -------------------------------------------------------------------------------- /src-old/std_misc/channels/input.md: -------------------------------------------------------------------------------- 1 | 4 | Rustは、スレッド間のコミュニケーションのために、非同期のチャネル(`channels`)を提供しています。チャネル2つのエンドポイント、すなわち送信者(`Sender`)と受信者(`Receiver`)を介して、情報の一方向への流れを作り出すことを可能にしています。 5 | 6 | {channels.play} 7 | -------------------------------------------------------------------------------- /src-old/generics/multi_bounds/input.md: -------------------------------------------------------------------------------- 1 | 3 | `+`を用いて複数のトレイト境界を設けることができます。複数の引数を受け取るときは、通常時と同様、`,`で区切ります。 4 | 5 | {multi.play} 6 | 7 | 10 | ### 参照 11 | 12 | [`std::fmt`][fmt], [トレイト][traits] 13 | 14 | [fmt]: ../hello/print.html 15 | [traits]: ../trait.html 16 | -------------------------------------------------------------------------------- /src-old/std_misc/arg/args.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | 3 | fn main() { 4 | let args: Vec = env::args().collect(); 5 | 6 | // ひとつ目の引数はプログラムを呼び出す際に使用したパス 7 | println!("My path is {}.", args[0]); 8 | 9 | // 残りはプログラムに渡されたコマンドラインパラメータ。 10 | // プログラムはこんなふうに呼び出す。 11 | // $ ./args arg1 arg2 12 | println!("I got {:?} arguments: {:?}.", args.len() - 1, &args[1..]); 13 | } 14 | -------------------------------------------------------------------------------- /src-old/variable_bindings/mut/mut.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let _immutable_binding = 1; 3 | let mut mutable_binding = 1; 4 | 5 | println!("Before mutation: {}", mutable_binding); 6 | 7 | // Ok 8 | mutable_binding += 1; 9 | 10 | println!("After mutation: {}", mutable_binding); 11 | 12 | // Error! 13 | _immutable_binding += 1; 14 | // FIXME ^ この行をコメントアウトしましょう 15 | } 16 | -------------------------------------------------------------------------------- /src-old/flow_control/for/for.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // `n`は1, 2, ...., 100のそれぞれの値を取ります。 3 | for n in 1..101 { 4 | if n % 15 == 0 { 5 | println!("fizzbuzz"); 6 | } else if n % 3 == 0 { 7 | println!("fizz"); 8 | } else if n % 5 == 0 { 9 | println!("buzz"); 10 | } else { 11 | println!("{}", n); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src-old/fn/closures/input_functions/input_functions.rs: -------------------------------------------------------------------------------- 1 | // 関数を引数として取り、即座に実行する関数を定義 2 | fn call_function(f: F) { 3 | f() 4 | } 5 | 6 | // 引数として渡すための簡単な関数を定義 7 | fn print() { 8 | println!("I'm a function!") 9 | } 10 | 11 | fn main() { 12 | // 上で定義した`print()`に似たクロージャを定義 13 | let closure = || println!("I'm a closure!"); 14 | 15 | call_function(closure); 16 | call_function(print); 17 | } 18 | -------------------------------------------------------------------------------- /src-old/std_misc/process/input.md: -------------------------------------------------------------------------------- 1 | 3 | `ProcessOutput`構造体は終了したプロセスのアウトプットを表し、`Command`構造体はプロセスの作成を行います。 4 | 5 | {process.play} 6 | 7 | 9 | (余裕があれば、上の例で`rustc`に不正なフラグを渡し、どうなるか見てみましょう) 10 | -------------------------------------------------------------------------------- /src-old/flow_control/loop/nested/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | ネストしたループを回している時に外側のループを`break`または`continue`したい場合があります。こういった場合には`label`を用いてループにラベルを貼り、`break`/`continue`にそのラベルを渡します。 5 | 6 | {nested.play} 7 | -------------------------------------------------------------------------------- /src-old/generics/impl/impl.rs: -------------------------------------------------------------------------------- 1 | struct Val (f64,); 2 | struct GenVal(T,); 3 | 4 | // Valに対してimpl 5 | impl Val { 6 | fn value(&self) -> &f64 { &self.0 } 7 | } 8 | 9 | // ジェネリック型`T`の場合のメソッドをGenValに対して実装 10 | impl GenVal { 11 | fn value(&self) -> &T { &self.0 } 12 | } 13 | 14 | fn main() { 15 | let x = Val(3.0); 16 | let y = GenVal(3i32); 17 | 18 | println!("{}, {}", x.value(), y.value()); 19 | } 20 | 21 | -------------------------------------------------------------------------------- /src-old/mod/input.md: -------------------------------------------------------------------------------- 1 | 4 | Rustにはコードを階層的に分割し、お互いの機能を隠蔽・公開するための強力なモジュールシステムが存在します。 5 | 6 | 8 | モジュールは関数、構造体、トレイト、`impl`ブロック、さらには他のモジュールなどの要素の集合です。 9 | -------------------------------------------------------------------------------- /src/scope.md: -------------------------------------------------------------------------------- 1 | 4 | # スコーピングの規則 5 | 6 | 11 | 所有権、借用、ライフタイムといったRustに特有の概念において、変数のスコープは重要な役割を果たします。すなわち、スコープの存在によってコンパイラは借用は可能か否か、メモリ上の資源は解放可能か、変数はいつ作成され、いつ破棄されるか。といったことを知るのです。 12 | -------------------------------------------------------------------------------- /src-old/variable_bindings/scope/input.md: -------------------------------------------------------------------------------- 1 | 4 | 変数はスコープを持つため、**ブロック**の中に閉じ込められています。ブロックとは`{}`で囲まれた領域のことです。また、[変数のシャドーイング][variable-shadow]も可能です。 5 | 6 | {scope.play} 7 | 8 | [variable-shadow]: https://en.wikipedia.org/wiki/Variable_shadowing 9 | -------------------------------------------------------------------------------- /src-old/primitives/primitives.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // 変数に型を指定 3 | let logical: bool = true; 4 | 5 | let a_float: f64 = 1.0; // 通常の型指定 6 | let an_integer = 5i32; // サフィックスによる型指定 7 | 8 | // サフィックスを指定しない場合、デフォルトを選択 9 | let default_float = 3.0; // `f64` 10 | let default_integer = 7; // `i32` 11 | 12 | let mut mutable = 12; // ミュータブルな `i32`. 13 | 14 | // エラー！ ミュータブルな変数でも型は不変 15 | mutable = true; 16 | } 17 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/lifetime_coercion/input.md: -------------------------------------------------------------------------------- 1 | 5 | 長いライフタイムは、短いものに圧縮(coerce)することで、そのままでは動作しないスコープの中でも使用できるようになります。これは、Rustコンパイラが推論の結果として圧縮する場合と、複数のライフタイムを比較して圧縮する場合があります。 6 | 7 | 8 | {coercion.play} 9 | -------------------------------------------------------------------------------- /src-old/std_misc/process/wait/input.md: -------------------------------------------------------------------------------- 1 | 3 | `Process`がスコープから抜けても、その子プロセスが実行を終了するまで、`drop`メソッドはリソースの開放を**行いません** 4 | 5 | {wait.rs} 6 | 7 | ``` 8 | $ rustc wait.rs && ./wait 9 | reached end of main 10 | # `wait` keeps running for 5 seconds 11 | # `sleep 5` command ends, and then our `wait` program finishes 12 | ``` 13 | -------------------------------------------------------------------------------- /src-old/fn/closures/anonymity/anonymity.rs: -------------------------------------------------------------------------------- 1 | // `F`は`Fn`を実装していなくてはならず、`Fn`は引数と返り値を持たない。 2 | // `print`は文字をプリントするだけのクロージャなので、これが正しい。 3 | fn apply(f: F) where 4 | F: Fn() { 5 | f() 6 | } 7 | 8 | fn main() { 9 | let x = 7; 10 | 11 | // `x`を無名の構造体に入れ、それに対し`Fn`を実装する。 12 | // (訳注: ここでは`Fn`は`fn Fn(&self) -> {println!("{}", &self)}`) 13 | // その構造体を`print`にアサインする。 14 | let print = || println!("{}", x); 15 | 16 | apply(print); 17 | } 18 | -------------------------------------------------------------------------------- /src/compatibility.md: -------------------------------------------------------------------------------- 1 | 4 | # 互換性 5 | 6 | 11 | Rust言語は急速に進化しており、可能な限り前方互換性を確保する努力にも関わらず、特定の互換性の問題が生じることがあります。 12 | 13 | 16 | * [生識別子](compatibility/raw_identifiers.md) 17 | -------------------------------------------------------------------------------- /src-old/expression/expression.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let x = 5u32; 3 | 4 | let y = { 5 | let x_squared = x * x; 6 | let x_cube = x_squared * x; 7 | 8 | // この式文は`y`に代入されます。 9 | x_cube + x_squared + x 10 | }; 11 | 12 | let z = { 13 | // セミコロンがあるので`z`には`()`が入ります。 14 | 2 * x; 15 | }; 16 | 17 | println!("x is {:?}", x); 18 | println!("y is {:?}", y); 19 | println!("z is {:?}", z); 20 | } 21 | -------------------------------------------------------------------------------- /src-old/flow_control/match/binding/input.md: -------------------------------------------------------------------------------- 1 | 4 | いくつかの変数をまとめてマッチ対象とした場合、そのうちの一つを分岐先で使用することはそのままでは不可能です。`match`内では`@`マークを使用して変数をバインディングすることができます。 5 | 6 | 7 | {binding.play} 8 | 9 | 12 | ### 参照 13 | [関数][functions] 14 | 15 | [functions]: ../../../fn.html 16 | -------------------------------------------------------------------------------- /src-old/attribute/crate/lib.rs: -------------------------------------------------------------------------------- 1 | // このクレイトはライブラリである。 2 | #![crate_type = "lib"] 3 | // このライブラリの名前は「rary」である。 4 | #![crate_name = "rary"] 5 | 6 | pub fn public_function() { 7 | println!("called rary's `public_function()`"); 8 | } 9 | 10 | fn private_function() { 11 | println!("called rary's `private_function()`"); 12 | } 13 | 14 | pub fn indirect_access() { 15 | print!("called rary's `indirect_access()`, that\n> "); 16 | 17 | private_function(); 18 | } 19 | -------------------------------------------------------------------------------- /src-old/error/result/result.rs: -------------------------------------------------------------------------------- 1 | fn double_number(number_str: &str) -> i32 { 2 | // 文字列は常に他の型にパースできるとは限らない。 3 | // ゆえに、`parse()`は失敗の可能性があることを意味する`Result`型を返す。 4 | // ここでは単に`unwrap`して数字を取り出すことを試みている。 5 | // これが、良くない事態を招く可能性とは？ 6 | 2 * number_str.parse::().unwrap() 7 | } 8 | 9 | fn main() { 10 | let twenty = double_number("10"); 11 | println!("double is {}", twenty); 12 | 13 | let tt = double_number("t"); 14 | println!("double is {}", tt); 15 | } 16 | -------------------------------------------------------------------------------- /src-old/std_misc/threads/input.md: -------------------------------------------------------------------------------- 1 | 3 | Rustは`spawn`関数を用いてOSのネイティブスレッドを開始することができます。この関数の引数はmoveクロージャ(訳注: 参照ではなく値を取るクロージャ。　詳しくは[クロージャを返す関数][fn_output]を参照)です。 4 | 5 | {threads.play} 6 | 7 | 8 | これらのスレッドのスケジューリングはOSによって行われる。 9 | 10 | 11 | [fn_output]: ../fn/closures/output_parameters.html 12 | -------------------------------------------------------------------------------- /src-old/scope/borrow/freeze/freeze.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let mut _mutable_integer = 7i32; 3 | 4 | { 5 | // `_mutable_integer`を借用 6 | let _large_integer = &_mutable_integer; 7 | 8 | // エラー! `_mutable_integer`はこのスコープではフリーズしている。 9 | _mutable_integer = 50; 10 | // FIXME ^ この行をコメントアウトしましょう。 11 | 12 | // `_large_integer`はスコープを抜ける 13 | } 14 | 15 | // OK! `_mutable_integer`はこのスコープではフリーズしていない。 16 | _mutable_integer = 3; 17 | } 18 | -------------------------------------------------------------------------------- /src-old/cast/inference/inference.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // アノテーションのおかげで、コンパイラは`elem`がu8型であることがわかる。 3 | let elem = 5u8; 4 | 5 | // 空のベクトル(可変長の配列)を生成 6 | let mut vec = Vec::new(); 7 | // この時点でコンパイラは`vec`の型を知らず、 8 | // 単に何らかの値のベクトル(`Vec<_>`)であるということだけを把握している。 9 | 10 | // `elem`をベクトルに挿入 11 | vec.push(elem); 12 | // よし！ これでコンパイラは`vec`が`u8`のベクトル(`Vec`)であることを把握する。 13 | // TODO ^ 上の `vec.push(elem)` をコメントアウトしてみましょう。 14 | 15 | println!("{:?}", vec); 16 | } 17 | -------------------------------------------------------------------------------- /src-old/flow_control/match/guard/guard.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let pair = (2, -2); 3 | // TODO ^ `pair`の値を変更してみましょう。 4 | 5 | println!("Tell me about {:?}", pair); 6 | match pair { 7 | (x, y) if x == y => println!("These are twins"), 8 | // ^ `if`とそれに続く条件式がガードです。 9 | (x, y) if x + y == 0 => println!("Antimatter, kaboom!"), 10 | (x, _) if x % 2 == 1 => println!("The first one is odd"), 11 | _ => println!("No correlation..."), 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src-old/flow_control/while/while.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // カウンタとなる変数 3 | let mut n = 1; 4 | 5 | // `n`が101以下である場合のループ 6 | while n < 101 { 7 | if n % 15 == 0 { 8 | println!("fizzbuzz"); 9 | } else if n % 3 == 0 { 10 | println!("fizz"); 11 | } else if n % 5 == 0 { 12 | println!("buzz"); 13 | } else { 14 | println!("{}", n); 15 | } 16 | 17 | // カウンタに1を追加 18 | n += 1; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src-old/fn/closures/output_parameters/output_parameters.rs: -------------------------------------------------------------------------------- 1 | fn create_fn() -> Box { 2 | let text = "Fn".to_owned(); 3 | 4 | Box::new(move || println!("This is a: {}", text)) 5 | } 6 | 7 | fn create_fnmut() -> Box { 8 | let text = "FnMut".to_owned(); 9 | 10 | Box::new(move || println!("This is a: {}", text)) 11 | } 12 | 13 | fn main() { 14 | let fn_plain = create_fn(); 15 | let mut fn_mut = create_fnmut(); 16 | 17 | fn_plain(); 18 | fn_mut(); 19 | } 20 | -------------------------------------------------------------------------------- /src-old/scope/move/mut/mut.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let immutable_box = Box::new(5u32); 3 | 4 | println!("immutable_box contains {}", immutable_box); 5 | 6 | // ミュータビリティエラー 7 | //*immutable_box = 4; 8 | 9 | // boxを*ムーブ*する、同時に所有権とミュータビリティを変更する。 10 | let mut mutable_box = immutable_box; 11 | 12 | println!("mutable_box contains {}", mutable_box); 13 | 14 | // boxの内容を変更 15 | *mutable_box = 4; 16 | 17 | println!("mutable_box now contains {}", mutable_box); 18 | } 19 | -------------------------------------------------------------------------------- /src/custom_types.md: -------------------------------------------------------------------------------- 1 | 4 | # カスタム型 5 | 6 | 9 | Rustでのカスタムデータ型の作成は主に以下の2つのキーワードを介して行われます。 10 | 11 | 15 | * `struct`: 構造体を定義する 16 | * `enum`: 列挙型を定義する 17 | 18 | 21 | `const`、あるいは`static`というキーワードによって定数を定義することもできます。 22 | -------------------------------------------------------------------------------- /src/mod.md: -------------------------------------------------------------------------------- 1 | 4 | # モジュール 5 | 6 | 11 | Rustにはコードを階層的に分割し、お互いの機能を隠蔽・公開するための強力なモジュールシステムが存在します。 12 | 13 | 17 | モジュールは関数、構造体、トレイト、`impl`ブロック、さらには他のモジュールなどの要素の集合です。 18 | -------------------------------------------------------------------------------- /src-old/macros/designators/input.md: -------------------------------------------------------------------------------- 1 | 3 | macroの引数は`$`が頭につきます。型は*識別子*(`designator`)でアノテーションされます。 4 | 5 | {designators.play} 6 | 7 | 8 | 以下が全識別子のリストです。 9 | 10 | * `block` 11 | * `expr` 式文に使用 12 | * `ident` 関数、変数の名前に使用 13 | * `item` 14 | * `pat` (*pattern*) 15 | * `path` 16 | * `stmt` (*statement*) 17 | * `tt` (*token tree*) 18 | * `ty` (*type*) 19 | -------------------------------------------------------------------------------- /src-old/macros/repeat/repeat.rs: -------------------------------------------------------------------------------- 1 | // `min!`は引数として与えられた数字の中の最低の値を計算する。 2 | macro_rules! find_min { 3 | // 基本となるケース 4 | ($x:expr) => ($x); 5 | // `$x`に少なくとも1つの`$y`が続く場合 6 | ($x:expr, $($y:expr),+) => ( 7 | // `find_min!`を残りの`$y`に対して再帰的に適用 8 | std::cmp::min($x, find_min!($($y),+)) 9 | ) 10 | } 11 | 12 | fn main() { 13 | println!("{}", find_min!(1u32)); 14 | println!("{}", find_min!(1u32 + 2 , 2u32)); 15 | println!("{}", find_min!(5u32, 2u32 * 3, 4u32)); 16 | } 17 | -------------------------------------------------------------------------------- /src-old/flow_control/loop/input.md: -------------------------------------------------------------------------------- 1 | 2 | Rustには`loop`というキーワードが存在します。これは無限ループを作成するのに使用します。 3 | 4 | > 訳注: `while True`と同じですが、ループのたびに条件を確認しないため、若干高速になります。 5 | 6 | 7 | 8 | 9 | ループから抜けだす時は`break`, 即座に次のループに移るときは`continue`が使用できます。 10 | 11 | {loop.play} 12 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_pointers/input.md: -------------------------------------------------------------------------------- 1 | 4 | Rustのポインタは、`C`のポインタとは異なる概念なので、デストラクトとデリファレンスを同じようなやり方で扱うことはできない 5 | 6 | 8 | * デリファレンスには`*`を用いる。 9 | * デストラクトには`&`, `ref`, `ref mut`を用いる。 10 | 11 | {pointers.play} 12 | -------------------------------------------------------------------------------- /src-old/scope/borrow/alias/input.md: -------------------------------------------------------------------------------- 1 | 5 | データは一度にいくつでもイミュータブルに借用することができますが、その間オリジナルのデータをミュータブルに借用することはできません。一方でミュータブルな借用は一度に*一つ*しか借用することができず、オリジナルのデータをもう一度借用するためには、ミュータブルな参照がスコープを抜けた*あとで*ないといけません。 6 | 7 | {alias.play} 8 | -------------------------------------------------------------------------------- /src-old/mod/split/my/mod.rs: -------------------------------------------------------------------------------- 1 | // 同様に`mod inaccessible`、`mod nested`によって、`nested.rs`、`inaccessible.rs`の内容をこの中で使用することができるようになる。 2 | // 訳注: `pub`をつけないかぎり、この中でしか使用できない。 3 | mod inaccessible; 4 | pub mod nested; 5 | 6 | pub fn function() { 7 | println!("called `my::function()`"); 8 | } 9 | 10 | fn private_function() { 11 | println!("called `my::private_function()`"); 12 | } 13 | 14 | pub fn indirect_access() { 15 | print!("called `my::indirect_access()`, that\n> "); 16 | 17 | private_function(); 18 | } 19 | -------------------------------------------------------------------------------- /src-old/flow_control/if_else/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | `if-else`を用いた条件分岐は他の言語に似ています。多くの言語では条件式の中を括弧でくくる必要がありますが、Rustではその必要はありません。条件式の直後にはブロックが続きます。`if-else`は式文の一種で、いずれの分岐先でも返り値の型は同一でなくてはなりません。 6 | 7 | {if_else.play} 8 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_enum/input.md: -------------------------------------------------------------------------------- 1 | 2 | 列挙型(`enum`)も似たやり方でデストラクトすることができます。 3 | 4 | {enum.play} 5 | 6 | 9 | ### 参照 10 | 11 | [`#[allow(...)]`][allow], [カラーモデル][color_models], [列挙型][enum], 12 | and [`#[derive(...)]`][derive] 13 | 14 | [allow]: ../../../fn/unused.html 15 | [color_models]: http://en.wikipedia.org/wiki/Color_model 16 | [derive]: ../../../trait/derive.html 17 | [enum]: ../../../custom_types/enum.html 18 | -------------------------------------------------------------------------------- /src-old/flow_control/loop/nested/nested.rs: -------------------------------------------------------------------------------- 1 | #![allow(unreachable_code)] 2 | 3 | fn main() { 4 | 'outer: loop { 5 | println!("Entered the outer loop"); 6 | 7 | 'inner: loop { 8 | println!("Entered the inner loop"); 9 | 10 | // これは内側のループのみを中断します。 11 | //break; 12 | 13 | // こちらは外側を中断します 14 | break 'outer; 15 | } 16 | 17 | println!("This point will never be reached"); 18 | } 19 | 20 | println!("Exited the outer loop"); 21 | } 22 | -------------------------------------------------------------------------------- /src-old/meta/doc/input.md: -------------------------------------------------------------------------------- 1 | 4 | ドキュメンテーションコメントとは[Rustdoc][1]を使用した際にドキュメントにコンパイルされるコメントのことです。`///`によって普通のコメントと区別され、ここでは[Markdown][2]を使用することができます。ドキュメンテーションコメントは大規模なプロジェクトの際に非常に有用です。 5 | 6 | {doc.play} 7 | 8 | [1]: http://doc.rust-lang.org/book/documentation.html 9 | [2]: https://en.wikipedia.org/wiki/Markdown 10 | -------------------------------------------------------------------------------- /src-old/std_misc/threads/threads.rs: -------------------------------------------------------------------------------- 1 | use std::thread; 2 | 3 | static NTHREADS: i32 = 10; 4 | 5 | // この関数は`main`スレッドで実行される。 6 | fn main() { 7 | // spawnされるクロージャを保持するためのベクタ 8 | let mut children = vec![]; 9 | 10 | for i in 0..NTHREADS { 11 | // 新しいスレッドを起動 12 | children.push(thread::spawn(move || { 13 | println!("this is thread number {}", i) 14 | })); 15 | } 16 | 17 | for child in children { 18 | // 子スレッドが終了するのを待ち、結果を返す。 19 | let _ = child.join(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src-old/variable_bindings/declare/input.md: -------------------------------------------------------------------------------- 1 | 4 | 変数の宣言だけを行っておき、初期化（定義）をのちに行うことも可能です。 5 | 6 | しかし、最後まで初期化されない変数が生じる可能性があるため、ふつうは同時に行われます。 7 | 8 | 9 | {declare.play} 10 | 11 | 15 | 16 | 未初期化の変数があると予期せぬ動作をする場合があるため、コンパイラは変数を初期化してから使用するよう強制します。 17 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_tuple/tuples.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let pair = (0, -2); 3 | // TODO ^ `pair`に別の値を入れてみましょう。 4 | 5 | println!("Tell me about {:?}", pair); 6 | // `match`を用いてタプルをデストラクトしてみましょう。 7 | match pair { 8 | // 2つ目の値をデストラクト 9 | (0, y) => println!("First is `0` and `y` is `{:?}`", y), 10 | (x, 0) => println!("`x` is `{:?}` and last is `0`", x), 11 | _ => println!("It doesn't matter what they are"), 12 | // ここでは`_`は、値を変数に束縛しないことを意味します。 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src-old/std_misc/path/path.rs: -------------------------------------------------------------------------------- 1 | use std::path::Path; 2 | 3 | fn main() { 4 | // `&'static str`から`Path`を作成 5 | let path = Path::new("."); 6 | 7 | // `display`メソッドは`Show`可能な構造体を返す。 8 | let display = path.display(); 9 | 10 | // `join`はOS固有のセパレータによってバイトのコンテナ型であるパス 11 | // を結合し、新しいパスを返す。 12 | let new_path = path.join("a").join("b"); 13 | 14 | // パスを文字列のスライスに変換する。 15 | match new_path.to_str() { 16 | None => panic!("new path is not a valid UTF-8 sequence"), 17 | Some(s) => println!("new path is {}", s), 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src-old/attribute/cfg/custom/input.md: -------------------------------------------------------------------------------- 1 | 3 | `target_os`のように、いくつかの条件分岐は`rustc`が暗黙のうちに提供しています。条件を独自に追加する場合には`--cfg`フラグを用いて`rustc`に伝える必要があります。 4 | 5 | {custom.rs} 6 | 7 | 8 | `cfg`フラグがない場合: 9 | 10 | {custom.out} 11 | 12 | 13 | `cfg`フラグがある場合: 14 | 15 | ``` 16 | $ rustc --cfg some_condition custom.rs && ./custom 17 | condition met! 18 | ``` 19 | -------------------------------------------------------------------------------- /src-old/fn/hof/input.md: -------------------------------------------------------------------------------- 1 | 4 | Rustには高階関数(`Higher Order Functions, HOF`)を扱う機能が備わっています。 5 | 6 | {hof.play} 7 | 8 | [オプション型][option] 9 | と 10 | [イテレータ][iter]には高階関数が使用されています。 11 | 12 | 13 | 14 | [option]: http://doc.rust-lang.org/core/option/enum.Option.html 15 | [iter]: http://doc.rust-lang.org/core/iter/trait.Iterator.html 16 | -------------------------------------------------------------------------------- /src-old/std/panic/panic.rs: -------------------------------------------------------------------------------- 1 | // 整数の除法(/)の再実装 2 | fn division(dividend: i32, divisor: i32) -> i32 { 3 | if divisor == 0 { 4 | // ゼロによる除算はパニックを引き起こす 5 | panic!("division by zero"); 6 | } else { 7 | dividend / divisor 8 | } 9 | } 10 | 11 | // `main`のタスク 12 | fn main() { 13 | // ヒープ上の整数 14 | let _x = Box::new(0i32); 15 | 16 | // This operation will trigger a task failure 17 | // このオペレーションはタスクの失敗を引き起こす 18 | division(3, 0); 19 | 20 | println!("This point won't be reached!"); 21 | 22 | // `_x`はここに到達する前に破棄される。 23 | } 24 | -------------------------------------------------------------------------------- /src-old/variable_bindings/declare/declare.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // 変数を宣言 3 | let a_binding; 4 | 5 | { 6 | let x = 2; 7 | 8 | // 変数を初期化 9 | a_binding = x * x; 10 | } 11 | 12 | println!("a binding: {}", a_binding); 13 | 14 | let another_binding; 15 | 16 | // Error! Use of uninitialized binding 17 | // エラー！ 初期化していない変数の使用 18 | println!("another binding: {}", another_binding); 19 | // FIXME ^ この行をコメントアウトしましょう。 20 | 21 | another_binding = 1; 22 | 23 | println!("another binding: {}", another_binding); 24 | } 25 | -------------------------------------------------------------------------------- /src-old/generics/gen_trait/input.md: -------------------------------------------------------------------------------- 1 | 3 | もちろんトレイトもジェネリクスを活用することができます。ここでは`Drop`トレイトをジェネリックメソッドとして再実装し、自身と引数として受け取った値の両方を`drop`するようなメソッドにします。 4 | 5 | {trait.play} 6 | 7 | 10 | ### 参照 11 | 12 | [`Drop`][Drop], [構造体(`struct`)][structs], [トレイト(`trait`)][traits] 13 | 14 | [Drop]: http://doc.rust-lang.org/std/ops/trait.Drop.html 15 | [structs]: /custom_types/structs.html 16 | [traits]: /trait.html 17 | -------------------------------------------------------------------------------- /src-old/scope/borrow/mut/input.md: -------------------------------------------------------------------------------- 1 | 5 | ミュータブルなデータは`&mut T`でミュータブルに(変更可能な形で)借用することができます。これは*ミュータブルな参照*と呼ばれ、読み込み・書き込みの権限を借用者に与えます。対照的に`&T`はデータをイミュータブルな参照を介して借用し、借用した側はデータを読み込みはできますが書き込みはできません。 6 | 7 | {mut.play} 8 | 9 | ### See Also 10 | [`static`][static] 11 | 12 | [static]: scope/lifetime/static_lifetime.html 13 | -------------------------------------------------------------------------------- /src/macros/syntax.md: -------------------------------------------------------------------------------- 1 | 4 | # 構文 5 | 6 | 10 | 以下のサブセクションでは、Rustにおいてマクロを定義する方法を示します。 11 | 3つの基本的な考え方があります： 12 | 13 | 14 | 19 | - [パターンと識別子][designators] 20 | - [オーバーロード][overloading] 21 | - [繰り返し][repetition] 22 | 23 | 24 | [designators]: designators.md 25 | [overloading]: overload.md 26 | [repetition]: repeat.md 27 | -------------------------------------------------------------------------------- /src-old/custom_types/constants/constants.rs: -------------------------------------------------------------------------------- 1 | // グローバル変数はあらゆるスコープの外で宣言します 2 | static LANGUAGE: &'static str = "Rust"; 3 | const THRESHOLD: i32 = 10; 4 | 5 | fn is_big(n: i32) -> bool { 6 | // 関数内から定数を参照 7 | n > THRESHOLD 8 | } 9 | 10 | fn main() { 11 | let n = 16; 12 | 13 | // main 関数の中から定数を参照 14 | println!("This is {}", LANGUAGE); 15 | println!("The threshold is {}", THRESHOLD); 16 | println!("{} is {}", n, if is_big(n) { "big" } else { "small" }); 17 | 18 | // エラー!`const`は変更できません。 19 | THRESHOLD = 5; 20 | // FIXME ^ この行をコメントアウトしましょう 21 | } 22 | -------------------------------------------------------------------------------- /src-old/flow_control/loop/loop.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let mut count = 0u32; 3 | 4 | println!("Let's count until infinity!"); 5 | 6 | // 無限ループ 7 | loop { 8 | count += 1; 9 | 10 | if count == 3 { 11 | println!("three"); 12 | 13 | // 残りの処理をスキップ 14 | continue; 15 | } 16 | 17 | println!("{}", count); 18 | 19 | if count == 5 { 20 | println!("OK, that's enough"); 21 | 22 | // Exit this loop 23 | // ループを抜ける。 24 | break; 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src-old/generics/where/where.rs: -------------------------------------------------------------------------------- 1 | use std::fmt::Debug; 2 | 3 | trait PrintInOption { 4 | fn print_in_option(self); 5 | } 6 | 7 | // `where`句を用いない場合、以下と等価な機能を実装するには、 8 | // ``という形で表現するか、別の直接的でない方法 9 | // を使用するかしなくてはならない。 10 | impl PrintInOption for T where 11 | Option: Debug { 12 | // プリントされるのが`Some(self)`であるため、この関数の 13 | // ジェネリック境界として`Option: Debug`を使用したい。 14 | fn print_in_option(self) { 15 | println!("{:?}", Some(self)); 16 | } 17 | } 18 | 19 | fn main() { 20 | let vec = vec![1, 2, 3]; 21 | 22 | vec.print_in_option(); 23 | } 24 | -------------------------------------------------------------------------------- /src-old/variable_bindings/input.md: -------------------------------------------------------------------------------- 1 | 5 | Rustは静的(`static`)な型付けゆえに型安全です。変数は宣言時に型を明示できます。とはいえたいていの場合は、コンパイラは変数の型をコンテキストから推測することができますので、常に苦労して明示する必要があるわけではありません。 6 | 7 | 8 | 10 | 値は（リテラルに似て）`let`を用いて変数に束縛されることができる。 11 | 12 | {variable_bindings.play} 13 | -------------------------------------------------------------------------------- /src-old/scope/raii/raii.rs: -------------------------------------------------------------------------------- 1 | // raii.rs 2 | fn create_box() { 3 | // 整数をヒープ上に確保 4 | let _box1 = Box::new(3i32); 5 | 6 | // `_box1`はここで破棄され、メモリは解放される。 7 | } 8 | 9 | fn main() { 10 | // 整数をヒープ上に確保 11 | let _box2 = Box::new(5i32); 12 | 13 | // ネストしたスコープ 14 | { 15 | // 整数をヒープ上に確保 16 | let _box3 = Box::new(4i32); 17 | 18 | // `_box3`はここで破棄され、メモリは解放される。 19 | } 20 | 21 | // お遊びで大量のボックスを作る。 22 | // もちろん手動で開放する必要はないよ！ 23 | for _ in 0u32..1_000 { 24 | create_box(); 25 | } 26 | 27 | // `_box2`はここで破棄され、メモリは解放される。 28 | } 29 | -------------------------------------------------------------------------------- /src-old/std_misc/process/process.rs: -------------------------------------------------------------------------------- 1 | use std::process::Command; 2 | 3 | fn main() { 4 | let output = Command::new("rustc") 5 | .arg("--version") 6 | .output().unwrap_or_else(|e| { 7 | panic!("failed to execute process: {}", e) 8 | }); 9 | 10 | if output.status.success() { 11 | let s = String::from_utf8_lossy(&output.stdout); 12 | 13 | print!("rustc succeeded and stdout was:\n{}", s); 14 | } else { 15 | let s = String::from_utf8_lossy(&output.stderr); 16 | 17 | print!("rustc failed and stderr was:\n{}", s); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /book.toml: -------------------------------------------------------------------------------- 1 | [book] 2 | title = "Rust By Example 日本語版" 3 | description = "Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries." 4 | author = "The Rust Community" 5 | language = "ja" 6 | 7 | [build] 8 | build-dir = "docs" 9 | 10 | [output.html.playpen] 11 | editable = true 12 | editor = "ace" 13 | line-numbers = true 14 | 15 | [output.html.fold] 16 | enable = true 17 | 18 | [output.html] 19 | git-repository-url = "https://github.com/rust-lang-ja/rust-by-example-ja" 20 | additional-css = ["css/custom.css"] 21 | 22 | [rust] 23 | edition = "2021" 24 | -------------------------------------------------------------------------------- /src-old/custom_types/enum/c_like/c_like.rs: -------------------------------------------------------------------------------- 1 | // 使用されていないコードによる警告を抑えるアトリビュート 2 | #![allow(dead_code)] 3 | 4 | // 値を明示しない場合、0から整数が順に入る。 5 | enum Number { 6 | Zero, 7 | One, 8 | Two, 9 | } 10 | 11 | // 値を明示する場合 12 | enum Color { 13 | Red = 0xff0000, 14 | Green = 0x00ff00, 15 | Blue = 0x0000ff, 16 | } 17 | 18 | fn main() { 19 | // 列挙型の中身を整数としてキャストする。 20 | println!("zero is {}", Number::Zero as i32); 21 | println!("one is {}", Number::One as i32); 22 | 23 | println!("roses are #{:06x}", Color::Red as i32); 24 | println!("violets are #{:06x}", Color::Blue as i32); 25 | } 26 | -------------------------------------------------------------------------------- /src-old/macros/dry/input.md: -------------------------------------------------------------------------------- 1 | 4 | マクロは関数やテストなどにおいて、共通の部分を抽出することでDRYなコードを書くのに役立ちます。ここでは`+=`、`*=`、`-=`、`Vec`を実装、テストするにあたって、マクロがどのように役立つかを見ていきます。 5 | 6 | {dry.rs} 7 | 8 | ``` 9 | $ rustc --test dry.rs && ./dry 10 | running 3 tests 11 | test test::mul_assign ... ok 12 | test test::add_assign ... ok 13 | test test::sub_assign ... ok 14 | 15 | test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured 16 | ``` 17 | -------------------------------------------------------------------------------- /src-old/std/option/input.md: -------------------------------------------------------------------------------- 1 | 3 | プログラムの一部が失敗した際、`panic!`するよりも、エラーを補足する方が望ましい場合があります。これは`Option`という列挙型を用いることで可能になります。 4 | 5 | 6 | 列挙型`Option`には2つの値があります。 7 | 8 | 10 | * `None`、これは実行の失敗か値の欠如を示します。 11 | * `Some(value)`、型`T`の`value`をラップするタプルです。 12 | 13 | {option.play} 14 | -------------------------------------------------------------------------------- /src-old/cast/input.md: -------------------------------------------------------------------------------- 1 | 3 | Rustはプリミティブ型における強制的な型変換を暗黙に行うことはありません。しかし明示的に行うこと（`casting`）は可能です。その場合`as`キーワードを使用します。 4 | 5 | 8 | 整数型から整数型へ型変換する場合、C言語で可能なケースの場合はC言語と同じです。 9 | C言語で未定義の場合の挙動も、Rustでは完全に定義されています。 10 | 11 | 12 | {cast.play} 13 | -------------------------------------------------------------------------------- /src-old/generics/multi_bounds/multi.rs: -------------------------------------------------------------------------------- 1 | use std::fmt::{Debug, Display}; 2 | 3 | fn compare_prints(t: &T) { 4 | println!("Debug: `{:?}`", t); 5 | println!("Display: `{}`", t); 6 | } 7 | 8 | fn compare_types(t: &T, u: &U) { 9 | println!("t: `{:?}", t); 10 | println!("u: `{:?}", u); 11 | } 12 | 13 | fn main() { 14 | let string = "words"; 15 | let array = [1, 2, 3]; 16 | let vec = vec![1, 2, 3]; 17 | 18 | compare_prints(&string); 19 | //compare_prints(&array); 20 | // TODO ^ ここをアンコメントしてみましょう。 21 | 22 | compare_types(&array, &vec); 23 | } 24 | -------------------------------------------------------------------------------- /src-old/macros/repeat/input.md: -------------------------------------------------------------------------------- 1 | 4 | マクロは引数のリストの中で`+`を使うことができ、そうすることによって、引数が少なくとも1回以上繰り返されるということを示すことができます。同様に`*`の場合は、0以上を示します。 5 | 6 | 9 | 以下の例では、マッチ対象を `$(...),+`で囲むことにより、カンマで区切られた1つ以上の式文とマッチします。最後のセミコロンは必須ではないことに注目しましょう。 10 | 11 | {repeat.play} 12 | -------------------------------------------------------------------------------- /src-old/attribute/cfg/cfg.rs: -------------------------------------------------------------------------------- 1 | // この関数はターゲットOSがLinuxの時のみコンパイルされる。 2 | #[cfg(target_os = "linux")] 3 | fn are_you_on_linux() { 4 | println!("You are running linux!") 5 | } 6 | 7 | // そしてこの関数はターゲットOSがLinux*ではない*ときのみコンパイルされる。 8 | #[cfg(not(target_os = "linux"))] 9 | fn are_you_on_linux() { 10 | println!("You are *not* running linux!") 11 | } 12 | 13 | fn main() { 14 | are_you_on_linux(); 15 | 16 | println!("Are you sure?"); 17 | if cfg!(target_os = "linux") { 18 | println!("Yes. It's definitely linux!"); 19 | } else { 20 | println!("Yes. It's definitely *not* linux!"); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src-old/trait/clone/input.md: -------------------------------------------------------------------------------- 1 | 4 | メモリ上の資源を扱う際、変数束縛や関数呼び出しを介して移動させるのがデフォルトの挙動です。しかしながら、場合によっては資源のコピーを作るのが適切なこともあります。 5 | 6 | 8 | [`Clone`][clone]トレイトはまさにこのためにあります。普通は`Clone`トレイトで定義されている`.clone()`を用います。 9 | 10 | {clone.play} 11 | 12 | [clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html 13 | -------------------------------------------------------------------------------- /src-old/variable_bindings/variable_bindings.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let an_integer = 1u32; 3 | let a_boolean = true; 4 | let unit = (); 5 | 6 | // `an_integer`を`copied_integer`へとコピー 7 | let copied_integer = an_integer; 8 | 9 | println!("An integer: {:?}", copied_integer); 10 | println!("A boolean: {:?}", a_boolean); 11 | println!("Meet the unit value: {:?}", unit); 12 | 13 | // 使用されていない変数があると、コンパイラは警告を出します。 14 | // 変数名の頭に`_`(アンダーバー)を付けると警告を消すことができます。 15 | let _unused_variable = 3u32; 16 | 17 | let noisy_unused_variable = 2u32; 18 | // FIXME ^ 頭にアンダーバーを付けて、警告を抑えましょう。 19 | } 20 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_structures/struct.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | struct Foo { x: (u32, u32), y: u32 } 3 | 4 | // 構造体のメンバをデストラクト 5 | let foo = Foo { x: (1, 2), y: 3 }; 6 | let Foo { x: (a, b), y } = foo; 7 | 8 | println!("a = {}, b = {}, y = {} ", a, b, y); 9 | 10 | // 構造体をデストラクトして変数をリネーム 11 | // 順番は重要ではない。 12 | 13 | let Foo { y: i, x: j } = foo; 14 | println!("i = {:?}, j = {:?}", i, j); 15 | 16 | // 一部の変数を無視することもできる。 17 | let Foo { y, .. } = foo; 18 | println!("y = {}", y); 19 | 20 | // `x`に言及していないため、以下はエラーになる。 21 | // let Foo { y } = foo; 22 | } 23 | -------------------------------------------------------------------------------- /src-old/macros/input.md: -------------------------------------------------------------------------------- 1 | 5 | Rustはメタプログラミングを可能にする、パワフルなマクロシステムを備えています。これまで見てきたように、マクロは`!`で終わることを除けば関数のように見えます。関数と違うのは関数呼び出し(`function call`)を生成する代わりに、ソースコード中に展開され、周囲のプログラムとともにコンパイルされる点です。 6 | 7 | 8 | マクロを作成するには`macro_rules!`というマクロを使用します。 9 | 10 | {simple.play} 11 | -------------------------------------------------------------------------------- /src-old/crates/lib/input.md: -------------------------------------------------------------------------------- 1 | 2 | ではライブラリを作成し、それを別のクレイトにリンクする方法を見ていきましょう。 3 | 4 | {rary.rs} 5 | 6 | ``` 7 | $ rustc --crate-type=lib rary.rs 8 | $ ls lib* 9 | library.rlib 10 | ``` 11 | 12 | 15 | ライブラリは「lib」が頭につき、デフォルトでは、その後ろに元となったクレイトファイル名をつけます。(訳注: ここでは`lib` + `rary`)この振る舞いは[`crate_name`アトリビュート][crate-name]を用いてオーバーライドできます。 16 | 17 | [crate-name]: ../attribute/crate.html 18 | -------------------------------------------------------------------------------- /src-old/hello/comment/comment.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // こちらはラインコメントです 3 | // 一番左にスラッシュが2つある行と、何も書かれていない行は 4 | // どちらもコンパイラによって無視されます。試しに実行してみてください 5 | 6 | // println!("Hello, world!"); 7 | 8 | // でしょ？では次に、左のスラッシュを消去してから実行してください 9 | 10 | /* 11 | * こちらはもう一つのタイプのコメントでブロックコメントと呼ばれます。 12 | * 普通はラインコメントの方が優れているのですが、こちらはデバッグ時に 13 | * 役立つ場合があります。 14 | */ 15 | 16 | /* 17 | このように、`*`は、実際にはコメントの前後に１つずつあれば十分です。 18 | */ 19 | 20 | // ではブロックコメントがどのようにデバッグに役立つか見てみましょう。 21 | // 例えば下の例の場合、ブロックコメントがなくなれば結果が変わります。 22 | let x = 5 + /* 90 + */ 5; 23 | println!("Is `x` 10 or 100? x = {}", x); 24 | } 25 | -------------------------------------------------------------------------------- /src-old/cast/literals/literals.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // サフィックスを指定したリテラル。型は初期化とともに確定する。 3 | let x = 1u8; 4 | let y = 2u32; 5 | let z = 3f32; 6 | 7 | // サフィックスを指定しないリテラル。型は使用方法に依存する。 8 | let i = 1; 9 | let f = 1.0; 10 | 11 | // `size_of_val` 関数は変数のサイズをバイトで返す。 12 | println!("size of `x` in bytes: {}", std::mem::size_of_val(&x)); 13 | println!("size of `y` in bytes: {}", std::mem::size_of_val(&y)); 14 | println!("size of `z` in bytes: {}", std::mem::size_of_val(&z)); 15 | println!("size of `i` in bytes: {}", std::mem::size_of_val(&i)); 16 | println!("size of `f` in bytes: {}", std::mem::size_of_val(&f)); 17 | } 18 | -------------------------------------------------------------------------------- /src-old/std_misc/input.md: -------------------------------------------------------------------------------- 1 | 3 | 他にも、様々な型がstdライブラリの中で提供されています。例えば以下の機能を果たすための物があります。 4 | 5 | 8 | 9 | * スレッド 10 | * チャネル 11 | * ファイルI/O 12 | 13 | 14 | これらにより[基本データ型][primitives]の提供する機能よりも遥かに豊かなことが実現できます。 15 | 16 | 19 | ### 参照 20 | 21 | 22 | [基本データ型][primitives]、[stdライブラリ][std] 23 | 24 | [primitives]: ../primitives.html 25 | [std]: http://doc.rust-lang.org/std/ 26 | -------------------------------------------------------------------------------- /src-old/generics/bounds/testcase_empty/input.md: -------------------------------------------------------------------------------- 1 | 4 | トレイト境界の仕組みから、「トレイトがなにも機能を持っていなくとも境界条件として使用できることには変わりはない」という帰結がもたらされます。`Eq`と`Ord`は`std`ライブラリにおけるそのような例です。 5 | 6 | {empty.play} 7 | 8 | 11 | ### 参照 12 | 13 | [`std::cmp::Eq`][eq], [`std::cmp::Ord`s][ord], [トレイト][traits] 14 | 15 | [eq]: http://doc.rust-lang.org/std/cmp/trait.Eq.html 16 | [ord]: http://doc.rust-lang.org/std/cmp/trait.Ord.html 17 | [traits]: ../trait.html 18 | -------------------------------------------------------------------------------- /src-old/flow_control/match/binding/binding.rs: -------------------------------------------------------------------------------- 1 | // `age`関数は`u32`の値を返す。 2 | fn age() -> u32 { 3 | 15 4 | } 5 | 6 | fn main() { 7 | println!("Tell me type of person you are"); 8 | 9 | match age() { 10 | 0 => println!("I'm not born yet I guess"), 11 | 12 | // `1 ... 12`の値を一挙に`match`させることができる。 13 | // しかしその場合、子供は正確には何歳? 14 | // マッチした値を`n`にバインディングすることで値を使用できる。 15 | n @ 1 ... 12 => println!("I'm a child of age {:?}", n), 16 | n @ 13 ... 19 => println!("I'm a teen of age {:?}", n), 17 | // マッチしなかった場合の処理 18 | n => println!("I'm an old person of age {:?}", n), 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src-old/std_misc/ffi/input.md: -------------------------------------------------------------------------------- 1 | 4 | RustはCのライブラリを呼び出すために他言語関数インターフェイス(Foreign Function Interface, FFI)を持っています。他言語の関数を使用する際には、そのライブラリ名を`#[link]`アトリビュートに渡し、更にそれでアノテーションされた`extern`ブロック内で宣言する必要があります。 5 | 6 | {ffi.rs} 7 | 8 | {ffi.out} 9 | 10 | 12 | 他言語関数呼び出しは安全でない(unsafe)ので、安全にするためのラッパーを書くことが一般的です。 13 | 14 | {safe.rs} 15 | 16 | {safe.out} 17 | -------------------------------------------------------------------------------- /src-old/error/result_alias/alias.rs: -------------------------------------------------------------------------------- 1 | use std::num::ParseIntError; 2 | use std::result; 3 | 4 | // `ParseIntError`を`Err`の型として持つ全ての`Result`のジェネリックエイリアス 5 | type Result = result::Result; 6 | 7 | // 上で定義したエイリアス(この場所特有の`Result`型)を使用 8 | fn double_number(number_str: &str) -> Result { 9 | number_str.parse::().map(|n| 2 * n) 10 | } 11 | 12 | // もう一度使用。エイリアスによって再度明記する必要性がない。 13 | fn print(result: Result) { 14 | match result { 15 | Ok(n) => println!("n is {}", n), 16 | Err(e) => println!("Error: {}", e), 17 | } 18 | } 19 | 20 | fn main() { 21 | print(double_number("10")); 22 | print(double_number("t")); 23 | } 24 | -------------------------------------------------------------------------------- /src-old/attribute/unused/input.md: -------------------------------------------------------------------------------- 1 | 4 | コンパイラは`dead_code`と呼ばれる[リント][lint]機能を持つため、使用されていない関数が存在するときに警告を出します。*アトリビュート*によってこの機能を無効化することができます。 5 | 6 | {unused.play} 7 | 8 | 11 | 実際のコード中では、使用されていないコードが有る場合はそれを除外するべきです。この文書中では随所でアトリビュートによって警告を抑制していますが、それはあくまでインタラクティブな例を皆さんに提供するためです。 12 | 13 | [lint]: https://en.wikipedia.org/wiki/Lint_%28software%29 14 | -------------------------------------------------------------------------------- /src-old/flow_control/while_let/while_let.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // `Option`の`optional`を作成 3 | let mut optional = Some(0); 4 | 5 | // これは次のように読める。「`let`が`optional`を`Some(i)`にデストラクトしている間は 6 | // ブロック内(`{}`)を評価せよ。さもなくば`break`せよ。」 7 | while let Some(i) = optional { 8 | if i > 9 { 9 | println!("Greater than 9, quit!"); 10 | optional = None; 11 | } else { 12 | println!("`i` is `{:?}`. Try again.", i); 13 | optional = Some(i + 1); 14 | } 15 | // ^ インデントが少なく、デストラクト失敗時の処理を追加で書く必要がない。 16 | } 17 | // ^ `if let`の場合は`else`/`else if`句が一つ余分にあったが、 18 | // `while let`では必要が無い。 19 | } 20 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/elision/elision.rs: -------------------------------------------------------------------------------- 1 | // `elided_input`のライフタイムはコンパイラによって自動的に付与されるため 2 | // 以下の2つは同一のライフタイムシグネチャを持つ。 3 | fn elided_input(x: &i32) { 4 | println!("`elided_input`: {}", x) 5 | } 6 | 7 | fn annotated_input<'a>(x: &'a i32) { 8 | println!("`annotated_input`: {}", x) 9 | } 10 | 11 | // 同様に、以下の2つの関数も全く同じライフタイムシグネチャを持つ。 12 | fn elided_pass(x: &i32) -> &i32 { x } 13 | 14 | fn annotated_pass<'a>(x: &'a i32) -> &'a i32 { x } 15 | 16 | fn main() { 17 | let x = 3; 18 | 19 | elided_input(&x); 20 | annotated_input(&x); 21 | 22 | println!("`elided_pass`: {}", elided_pass(&x)); 23 | println!("`annotated_pass`: {}", annotated_pass(&x)); 24 | } 25 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/lifetime_coercion/coercion.rs: -------------------------------------------------------------------------------- 1 | // ここではRustはライフタイムを出来る限り短く見積もり、 2 | // 2つの参照をそのライフタイムに押し込める。 3 | fn multiply<'a>(first: &'a i32, second: &'a i32) -> i32 { 4 | first * second 5 | } 6 | 7 | // `<'a: 'b, 'b>`は「ライフタイム`'a`は最低でも`'b`と同じ長さ」と読める。 8 | // ここでは、`&'a i32`をとり、`&'b i32`に圧縮して返す。 9 | fn choose_first<'a: 'b, 'b>(first: &'a i32, _: &'b i32) -> &'b i32 { 10 | first 11 | } 12 | 13 | fn main() { 14 | let first = 2; // 長いライフタイム 15 | 16 | { 17 | let second = 3; // 短いライフタイム 18 | 19 | println!("The product is {}", multiply(&first, &second)); 20 | println!("{} is the first", choose_first(&first, &second)); 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src-old/trait/input.md: -------------------------------------------------------------------------------- 1 | 3 | トレイト(`trait`)とは任意の型となりうる`Self`に対して定義されたメソッドの集合のことです。同じトレイト内で宣言されたメソッド同士はお互いにアクセスすることができます。 4 | 5 | 9 | トレイトはあらゆるデータ型に実装することができます。以下の例ではまず`Animal`というメソッドの集合を定義し、その後`Animal`トレイトを`Sheep`というデータ型に対して実装します。これにより`Animal`のメソッドを`Sheep`が使用することが可能になります。 10 | 11 | {trait.play} 12 | -------------------------------------------------------------------------------- /src-old/attribute/crate/input.md: -------------------------------------------------------------------------------- 1 | 4 | `crate_type`アトリビュートは、そのクレイトがライブラリ、バイナリのいずれにコンパイルされるべきかをコンパイラに伝えるために使用します。ライブラリの場合は、どのタイプのライブラリであるかも伝えることができます。`crate_name`はクレイトの名前を決定するのに使用します。 5 | 6 | {lib.rs} 7 | 8 | 10 | `crate_type`アトリビュートが使用されているときは、`rustc`に`--crate-type`フラグを伝える必要はありません。 11 | 12 | ``` 13 | $ rustc lib.rs 14 | $ ls lib* 15 | library.rlib 16 | ``` 17 | -------------------------------------------------------------------------------- /src-old/cast/inference/input.md: -------------------------------------------------------------------------------- 1 | 6 | Rustの型推論エンジンはなかなか賢くできています。初期化の際に右辺値([`r-value`][rvalue])の型をチェックするだけでなく、その後にどのような使われ方をしているかを見て推論します。以下がその例です。 7 | 8 | {inference.play} 9 | 10 | 12 | このように、変数の型アノテーションは必要ありません。これでコンパイラもプログラマもハッピーですね！ 13 | 14 | [rvalue]: https://en.wikipedia.org/wiki/Value_%28computer_science%29#lrvalue 15 | -------------------------------------------------------------------------------- /src-old/error/option_with_result/option_result.rs: -------------------------------------------------------------------------------- 1 | // まずは単純に`unwrap`を用いてみましょう。これは前述の好ましくない 2 | // エラーメッセージを引き起こします。 3 | fn double_first(vec: Vec<&str>) -> i32 { 4 | // ベクタが空の場合どうなる？ 5 | let first = vec.first().unwrap(); 6 | 7 | // 要素が数値にパースできない場合、どうなる？ 8 | 2 * first.parse::().unwrap() 9 | } 10 | 11 | fn main() { 12 | let numbers = vec!["93", "18"]; 13 | let empty = vec![]; 14 | let strings = vec!["tofu", "93", "18"]; 15 | 16 | println!("The first doubled is {}", double_first(numbers)); 17 | println!("The first doubled is {}", double_first(empty)); 18 | // ^ ２つ目のエラーを見たければこの行をコメントアウトしましょう。 19 | println!("The first doubled is {}", double_first(strings)); 20 | } 21 | -------------------------------------------------------------------------------- /src-old/flow_control/for/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | `for in`文を用いることで、イテレータ(`Iterator`)のそれぞれの要素に対して処理をすることが可能です。イテレータを作る最も単純な方法は`a..b`のような書き方をすることです。これは「`a`」から「`b`のひとつ前」までの要素を順に産出(`yield`)するというものです。 6 | 7 | 8 | では`for`と`while`を用いてFizzBuzzを書いてみましょう。 9 | 10 | {for.play} 11 | 12 | 15 | ### 参照 16 | 17 | [イテレータ][iter] 18 | 19 | [iter]: ../trait/iter.html 20 | -------------------------------------------------------------------------------- /src-old/custom_types/enum/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 列挙型(`enum`)はいくつかの異なる型の中から1つを選ぶような場合に使用する。構造体（`struct`）の定義を満たすものならば何でも`enum` 内の型として使用できる 5 | 6 | {enum.play} 7 | 8 | 11 | ### 参照 12 | 13 | [アトリビュート(`attributes`)][attributes], [マッチ(`match`)][match], [関数(`fn`)][fn], and [文字列(`String`)][str] 14 | 15 | [attributes]: ../attribute.html 16 | [c_struct]: http://en.wikipedia.org/wiki/Struct_(C_programming_language) 17 | [match]: ../flow_control/match.html 18 | [fn]: ../fn.html 19 | [str]: ../std/str.html 20 | -------------------------------------------------------------------------------- /src-old/mod/struct_visibility/input.md: -------------------------------------------------------------------------------- 1 | 5 | 構造体はそれ自身に加え、フィールドごとにもパブリック・プライベートを設定することができます。デフォルトではプライベートですが、`pub`宣言をすることで、フィールドをパブリックにすることができます。これは、構造体がモジュールの外から参照される時に限り意味のあるもので、情報の隠蔽（カプセル化）を達成するための機能です。 6 | 7 | 8 | {struct.play} 9 | 10 | 13 | ### 参照 14 | 15 | [ジェネリック型][generics]、 [メソッド][methods] 16 | 17 | [generics]: ../generics.html 18 | [methods]: ../fn/methods.html 19 | -------------------------------------------------------------------------------- /src/std_misc.md: -------------------------------------------------------------------------------- 1 | 4 | # 標準ライブラリのその他 5 | 6 | 10 | 他にも、様々な型がstdライブラリの中で提供されています。例えば以下の機能を果たすための物があります。 11 | 12 | 17 | * スレッド 18 | * チャネル 19 | * ファイルI/O 20 | 21 | 24 | これらにより[基本データ型][primitives]の提供する機能よりも遥かに豊かなことが実現できます。 25 | 26 | 29 | ### 参照 30 | 31 | 34 | [基本データ型][primitives], [stdライブラリ][std] 35 | 36 | [primitives]: primitives.md 37 | [std]: https://doc.rust-lang.org/std/ 38 | -------------------------------------------------------------------------------- /src-old/fn/closures/closure_examples/iter_any/iter_any.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let vec1 = vec![1, 2, 3]; 3 | let vec2 = vec![4, 5, 6]; 4 | 5 | // ベクトル型に対する`iter`は`&i32`を`yield`するので、`i32`へとデストラクト 6 | println!("2 in vec1: {}", vec1.iter() .any(|&x| x == 2)); 7 | // `into_iter()`の場合は`i32`を`yield`するので、デストラクトする必要はない。 8 | println!("2 in vec2: {}", vec2.into_iter().any(| x| x == 2)); 9 | 10 | let array1 = [1, 2, 3]; 11 | let array2 = [4, 5, 6]; 12 | 13 | // 配列に対する`iter()`は`&i32`をyieldする。 14 | println!("2 in array1: {}", array1.iter() .any(|&x| x == 2)); 15 | // 配列に`into_iter()`を使うと例外的に`&i32`を`yield`する。 16 | println!("2 in array2: {}", array2.into_iter().any(|&x| x == 2)); 17 | } 18 | -------------------------------------------------------------------------------- /src-old/std_misc/file/input.md: -------------------------------------------------------------------------------- 1 | 6 | `File`構造体は開かれたファイルを表し(実際にはファイルディスクリプタのラッパーです)、読み込み・書き込み権限のどちらか一方、あるいは両方を提供します。 7 | 8 | 11 | これはI/Oに関するオペレーションの失敗をより明瞭にします。このおかげでプログラマは直面した失敗を全て見ることができ、より生産的な方法でそれらを扱うことが可能になります。 12 | -------------------------------------------------------------------------------- /src-old/cast/alias/alias.rs: -------------------------------------------------------------------------------- 1 | // `NanoSecond` を `u64`の別名として使用する。 2 | type NanoSecond = u64; 3 | type Inch = u64; 4 | 5 | // 警告を抑えるアトリビュートを使用。 6 | #[allow(non_camel_case_types)] 7 | type u64_t = u64; 8 | // TODO ^ アトリビュートを使用しない場合、どうなるか見てみましょう。 9 | // こちらも警告を抑えるアトリビュート 10 | #[allow(trivial_numeric_casts)] 11 | fn main() { 12 | // `NanoSecond` = `Inch` = `u64_t` = `u64`. 13 | let nanoseconds: NanoSecond = 5 as u64_t; 14 | let inches: Inch = 2 as u64_t; 15 | // 型のエイリアスは、元の型をより型安全にしてくれる **わけではない** ことに注意しましょう。 16 | // なぜならば、エイリアスは新たな型を定義している **わけではない** からです。 17 | println!("{} nanoseconds + {} inches = {} unit?", 18 | nanoseconds, 19 | inches, 20 | nanoseconds + inches); 21 | } 22 | -------------------------------------------------------------------------------- /src-old/std/box/input.md: -------------------------------------------------------------------------------- 1 | 5 | Rustにおいて、すべての値はデフォルトでスタックに割り当てられます。`Box`を作成することで、値を*ボックス化*、すなわちヒープ上に割り当てることができます。ボックスとは正確にはヒープ上におかれた`T`の値へのスマートポインタです。ボックスがスコープを抜けると、デストラクタが呼ばれて内包するオブジェクトが破棄され、ヒープメモリが解放されます。 6 | 7 | 9 | ボックス化された値は`*`オペレータを用いてデリファレンスすることができます。これにより一段と直接的な操作が可能になります。 10 | 11 | {box.play} 12 | -------------------------------------------------------------------------------- /src/meta.md: -------------------------------------------------------------------------------- 1 | 4 | # 周辺情報 5 | 6 | 11 | この章では、プログラミングそれ自体に関係はないけれども、色々と人々の役に立つ機能やインフラについて説明していきます。例えば: 12 | 13 | 18 | - [ドキュメンテーション][doc]: Rust付属コマンド`rustdoc`を用いて、ライブラリのドキュメントを生成します。 19 | - [プレイグラウンド][playground]: あなたのドキュメンテーションにRust Playgroundを組み込めます。 20 | 21 | [doc]: meta/doc.md 22 | [playground]: meta/playground.md 23 | -------------------------------------------------------------------------------- /src-old/cast/alias/input.md: -------------------------------------------------------------------------------- 1 | 4 | `type`文を使用することで既存の型に新しい名前(`alias`)を付けることができます。その場合、名前は`CamelCase`でなくてはなりません。さもなくばコンパイラがエラーを出します。唯一の例外は`usize`や`f32`のようなプリミティブ型です。 5 | 6 | {alias.play} 7 | 8 | 10 | このようにエイリアスを付ける一番の理由はタイプ量を減らすことです。例えば`IoResult`型は`Result`の別名です。 11 | 12 | 13 | 16 | ### 参照 17 | 18 | [アトリビュート](../attribute.html) 19 | -------------------------------------------------------------------------------- /src-old/crates/link/input.md: -------------------------------------------------------------------------------- 1 | 5 | クレイトをこの新しいライブラリにリンクするには、`extern crate`宣言を使用する必要があります。これはライブラリをリンクするだけでなく、その要素を全てライブラリと同じ名前のモジュールにインポートします。モジュールにおけるパブリック・プライベートなどのスコープのルールは全て、ライブラリにおいても当てはまります。 6 | 7 | {executable.rs} 8 | 9 | ``` 10 | # `-L .`を引数として与えることで、カレントディレクトリをライブラリのサーチパスに追加します。 11 | $ rustc -L . executable.rs && ./executable 12 | called rary's `public_function()` 13 | called rary's `indirect_access()`, that 14 | > called rary's `private_function()` 15 | ``` 16 | -------------------------------------------------------------------------------- /src-old/fn/input.md: -------------------------------------------------------------------------------- 1 | 4 | 関数は`fn`キーワードを用いて定義することができます。引数は変数と同様に型を指定する必要があり、もし関数が値を返すならば`->`の後にその型も指定する必要があります。 5 | 6 | 9 | 関数内の最後の式文が返り値となります。関数の途中で値を返したい場合は`return`文を使用します。`loop`の最中や`if`文の中からも値を返すことができます。 10 | 11 | 12 | では、もう一度FizzBuzz問題を解く関数を書いてみましょう！ 13 | 14 | {fn.play} 15 | -------------------------------------------------------------------------------- /src-old/meta/test/unit_test.rs: -------------------------------------------------------------------------------- 1 | // テストを実行しない時に限り、`main`をコンパイルする。 2 | #[cfg(not(test))] 3 | fn main() { 4 | println!("If you see this, the tests were not compiled nor ran!"); 5 | } 6 | 7 | // テストを実行するときのみ`test`モジュールをコンパイルする。 8 | #[cfg(test)] 9 | mod test { 10 | // `distance_test`が必要とするヘルパーメソッド 11 | fn distance(a: (f32, f32), b: (f32, f32)) -> f32 { 12 | ( 13 | (b.0 - a.0).powi(2) + 14 | (b.1 - a.1).powi(2) 15 | ).sqrt() 16 | } 17 | 18 | #[test] 19 | fn distance_test() { 20 | assert!(distance((0f32, 0f32), (1f32, 1f32)) == (2f32).sqrt()); 21 | } 22 | 23 | #[test] 24 | #[should_panic] 25 | fn failing_test() { 26 | assert!(1i32 == 2i32); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src-old/flow_control/match/destructuring/destructure_references/ref.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // 通常の2つの値からスタート 3 | let value = 5; 4 | let mut mut_value = 6; 5 | 6 | // `&5`(5へのリファレンス)へとデストラクトする場合、`ref`キーワードを使う。 7 | match value { 8 | // `println!`は通常の値でもリファレンスでも扱うことができる 9 | // ため、どちらを渡すかは重要ではない。`r`の型は`&i32`になる。 10 | ref r => println!("Got a reference to a value: {:?}", r), 11 | } 12 | 13 | // 同様にミュータブルなリファレンスである`&mut 6`を 14 | // 取得するためには`ref mut`を使用する。 15 | match mut_value { 16 | ref mut m => { 17 | // リファレンスを取得。 18 | // 値を変更するためにはデリファレンスする必要がある。 19 | *m += 10; 20 | println!("We added 10. `mut_value`: {:?}", m); 21 | }, 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src-old/generics/gen_trait/trait.rs: -------------------------------------------------------------------------------- 1 | // コピー不可な型 2 | // 訳注: `clone()`メソッドを用いないかぎり、値のコピーではなくムーブが起きる型 3 | struct Empty; 4 | struct Null; 5 | 6 | // ジェネリック型 `T`に対するトレイト 7 | trait DoubleDrop { 8 | // `self`に加えてもう一つジェネリック型を受け取り、 9 | // 何もしないメソッドのシグネチャを定義 10 | fn double_drop(self, _: T); 11 | } 12 | 13 | // `U`を`self`として、`T`をもう一つの引数として受け取る`DoubleDrop` 14 | // を実装する。`U`,`T`はいずれもジェネリック型 15 | impl DoubleDrop for U { 16 | // このメソッドは2つの引数の所有権を取り、メモリ上から開放する。 17 | fn double_drop(self, _: T) {} 18 | } 19 | 20 | fn main() { 21 | let empty = Empty; 22 | let null = Null; 23 | 24 | // `empty`と`null`を開放 25 | empty.double_drop(null); 26 | 27 | //empty; 28 | //null; 29 | // ^ TODO: これらの行をアンコメントしてみましょう。 30 | } 31 | -------------------------------------------------------------------------------- /src-old/std/input.md: -------------------------------------------------------------------------------- 1 | 3 | `std`ライブラリは、基本データ型を劇的に拡張するカスタム型を数多く提供します。例えば以下です。 4 | 5 | 10 | * 拡張可能な文字列である`String`。例えば: `"hello world"` 11 | * オプション型: `Option` 12 | * エラーハンドリング用の`Result` 13 | * ヒープ上資源のポインタ`Box` 14 | 15 | 18 | ### 参照 19 | 20 | [基本データ型][primitives], [`std`ライブラリ][std] 21 | 22 | [primitives]: ../primitives.html 23 | [std]: http://doc.rust-lang.org/std/ 24 | -------------------------------------------------------------------------------- /src-old/attribute/cfg/input.md: -------------------------------------------------------------------------------- 1 | 7 | 環境に応じたコンパイルをするには2種類の方法があります。 8 | 9 | * `cfg`アトリビュート: `#[cfg(...)]`をアトリビュートとして使用する。 10 | * `cfg!`マクロ: `cfg!(...)`をブーリアンとして評価する。 11 | 12 | いずれの場合も適切なシンタックスで記述する必要があります。 13 | 14 | {cfg.play} 15 | 16 | 19 | ### 参照 20 | 21 | [参照(`reference`)][ref], [`cfg!`][cfg], [マクロ][macros]. 22 | 23 | [cfg]: http://doc.rust-lang.org/std/macro.cfg!.html 24 | [macros]: ./macros.html 25 | [ref]: http://doc.rust-lang.org/reference.html#conditional-compilation 26 | -------------------------------------------------------------------------------- /src-old/flow_control/match/match.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let number = 13; 3 | 4 | println!("Tell me about {}", number); 5 | match number { 6 | // 単一の値とのマッチをチェック 7 | 1 => println!("One!"), 8 | // いくつかの値とのマッチをチェック 9 | 2 | 3 | 5 | 7 | 11 => println!("This is a prime"), 10 | // 特定の範囲の値とのマッチをチェック 11 | 13...19 => println!("A teen"), 12 | // その他の場合の処理 13 | _ => println!("Ain't special"), 14 | } 15 | 16 | let boolean = true; 17 | // マッチは式文でもある。 18 | let binary = match boolean { 19 | // マッチは全ての可能な値をカバーしなくてはならない 20 | false => 0, 21 | true => 1, 22 | // TODO ^ 試しに片方をコメントアウトしてみましょう。 23 | }; 24 | 25 | println!("{} -> {}", boolean, binary); 26 | } 27 | -------------------------------------------------------------------------------- /src-old/macros/overload/overload.rs: -------------------------------------------------------------------------------- 1 | // `test!`は`$left`と`$right`を異なる呼び出し方に応じて 2 | // 比較する。 3 | macro_rules! test { 4 | // 引数はカンマでくぎらなくてもよい 5 | // テンプレートの形態は自由！ 6 | ($left:expr; and $right:expr) => ( 7 | println!("{:?} and {:?} is {:?}", 8 | stringify!($left), 9 | stringify!($right), 10 | $left && $right) 11 | ); 12 | // それぞれの`=>`節はセミコロンで終わる必要がある。 13 | ($left:expr; or $right:expr) => ( 14 | println!("{:?} or {:?} is {:?}", 15 | stringify!($left), 16 | stringify!($right), 17 | $left || $right) 18 | ); 19 | } 20 | 21 | fn main() { 22 | test!(1i32 + 1 == 2i32; and 2i32 * 2 == 4i32); 23 | test!(true; or false); 24 | } 25 | -------------------------------------------------------------------------------- /src-old/scope/borrow/input.md: -------------------------------------------------------------------------------- 1 | 4 | 実際には、データの所有権を完全に受け渡すことなく一時的にアクセスしたいという場合がほとんどです。そのために、Rustでは*借用(`borrowing`)*という仕組みを用います。値そのもの(`T`)を受け渡すのではなく、そのリファレンス(`&T`)を渡すのです。 5 | 6 | 7 | 9 | コンパイラは借用チェッカを用いてリファレンスが*常に*有効なオブジェクトへの参照であることを、コンパイル時に保証します。つまり、あるオブジェクトへのリファレンスが存在しているならば、そのオブジェクトを破壊することはできないということです。 10 | 11 | {borrow.play} 12 | -------------------------------------------------------------------------------- /src/scope/lifetime/methods.md: -------------------------------------------------------------------------------- 1 | 4 | # メソッド 5 | 6 | 9 | メソッドのライフタイムは関数に似ている。 10 | 11 | ```rust,editable 12 | struct Owner(i32); 13 | 14 | impl Owner { 15 | // Annotate lifetimes as in a standalone function. 16 | // 通常の関数と同様にライフタイムを明示 17 | fn add_one<'a>(&'a mut self) { self.0 += 1; } 18 | fn print<'a>(&'a self) { 19 | println!("`print`: {}", self.0); 20 | } 21 | } 22 | 23 | fn main() { 24 | let mut owner = Owner(18); 25 | 26 | owner.add_one(); 27 | owner.print(); 28 | } 29 | ``` 30 | 31 | 34 | ### 参照 35 | 36 | 39 | [メソッド][methods] 40 | 41 | [methods]: ../../fn/methods.md 42 | -------------------------------------------------------------------------------- /src-old/meta/input.md: -------------------------------------------------------------------------------- 1 | 4 | この章では、プログラミングそれ自体に関係はないけれども、色々と人々の役に立つ機能やインフラについて説明していきます。例えば: 5 | 6 | 12 | * ドキュメンテーション: Rust付属コマンド`rustdoc`を用いて、ライブラリのドキュメントを生成します。 13 | * テスト: 自作ライブラリが、想定する動作をしていることを保証するためのテストスイートを作成します。 14 | * ベンチマーク: 関数の実行速度が要件を満たすことに確信を持つためのベンチマークを作成します。 15 | -------------------------------------------------------------------------------- /src-old/std/result/try/input.md: -------------------------------------------------------------------------------- 1 | 5 | マッチを使用して結果をチェインするのは中々面倒です。幸いなことに、`try!`マクロを使用すればイケてるコードに戻すことができます。`try!`マクロはマッチ構文に展開され、`Err(err)`を返す分岐は早い段階で`return Err(err)`し、`Ok(ok)`を返す分岐は`ok`に展開されます。 6 | 7 | {try.play} 8 | 9 | 11 | [公式ドキュメント][docs]をチェックすることをオススメします。`Result`型を扱う関数や`Result`型のメソッドが多く挙げられています。 12 | 13 | [docs]: http://doc.rust-lang.org/std/result/index.html 14 | -------------------------------------------------------------------------------- /src/flow_control/loop/return.md: -------------------------------------------------------------------------------- 1 | 4 | # loopが返す値 5 | 6 | 12 | `loop`の用途のひとつに「成功するまである処理を再試行する」ことがあります。もしその処理が値を返すならば、それをコードの他の部分に渡す必要があるでしょう。`break`の後に値を置くと、それが`loop`式の値として返されます。 13 | 14 | ```rust,editable 15 | fn main() { 16 | let mut counter = 0; 17 | 18 | let result = loop { 19 | counter += 1; 20 | 21 | if counter == 10 { 22 | break counter * 2; 23 | } 24 | }; 25 | 26 | assert_eq!(result, 20); 27 | } 28 | ``` 29 | -------------------------------------------------------------------------------- /src/std_misc/process/wait.md: -------------------------------------------------------------------------------- 1 | 4 | # dropの延期 5 | 6 | 10 | `process::Child`が終了するのを待ちたい場合は、 11 | `process::ExitStatus`を返す`Child::wait`を呼び出さなくてはなりません。 12 | 13 | ```rust,ignore 14 | use std::process::Command; 15 | 16 | fn main() { 17 | let mut child = Command::new("sleep").arg("5").spawn().unwrap(); 18 | let _result = child.wait().unwrap(); 19 | 20 | println!("reached end of main"); 21 | } 22 | ``` 23 | 24 | ```bash 25 | $ rustc wait.rs && ./wait 26 | # `wait` keeps running for 5 seconds until the `sleep 5` command finishes 27 | # `wait`は`sleep 5`コマンドが終了するまで５秒間実行され続ける。 28 | reached end of main 29 | ``` 30 | -------------------------------------------------------------------------------- /src/std_misc/file.md: -------------------------------------------------------------------------------- 1 | 4 | # ファイル I/O 5 | 6 | 13 | `File`構造体は開かれたファイルを表し（実際にはファイルディスクリプタのラッパーです）、読み込み・書き込み権限のどちらか一方、あるいは両方を提供します。 14 | 15 | 20 | これはI/Oに関するオペレーションの失敗をより明瞭にします。このおかげでプログラマは直面した失敗を全て見ることができ、より生産的な方法でそれらを扱うことが可能になります。 21 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/lifetime_bounds/bounds.rs: -------------------------------------------------------------------------------- 1 | use std::fmt::Debug; // ライフタイムを紐付けるトレイト 2 | 3 | #[derive(Debug)] 4 | struct Ref<'a, T: 'a>(&'a T); 5 | // `Ref`は`'a`というライフタイムを持つジェネリック型`T`に対する参照を持ち、 6 | // `T`の値*に対する参照*は必ず`'a`よりも長生きでなくてはならない。 7 | // さらに、`Ref`のライフタイムは`'a`を超えてはならない。 8 | 9 | // `Debug`トレイトを利用してプリントを行うジェネリック関数 10 | fn print(t: T) where 11 | T: Debug { 12 | println!("`print`: t is {:?}", t); 13 | } 14 | 15 | // `Debug`を実装している`T`への参照を取る。`T`への*参照*は 16 | // 必ず`'a`よりも長生きでなくてはならない。さらに、`'a`は 17 | // 関数自体よりも長生きでなくてはならない。 18 | fn print_ref<'a, T>(t: &'a T) where 19 | T: Debug + 'a { 20 | println!("`print_ref`: t is {:?}", t); 21 | } 22 | 23 | fn main() { 24 | let x = 7; 25 | let ref_x = Ref(&x); 26 | 27 | print_ref(&ref_x); 28 | print(ref_x); 29 | } 30 | -------------------------------------------------------------------------------- /src-old/std_misc/arg/matching/input.md: -------------------------------------------------------------------------------- 1 | 2 | matchを用いて簡単な引数をパースできます。 3 | 4 | {match_args.play} 5 | 6 | ``` 7 | $ ./match_args Rust 8 | This is not the answer. 9 | $ ./match_args 42 10 | This is the answer! 11 | $ ./match_args do something 12 | error: second argument not an integer 13 | usage: 14 | match_args 15 | Check whether given string is the answer. 16 | match_args {increase|decrease} 17 | Increase or decrease given integer by one. 18 | $ ./match_args do 42 19 | error: invalid command 20 | usage: 21 | match_args 22 | Check whether given string is the answer. 23 | match_args {increase|decrease} 24 | Increase or decrease given integer by one. 25 | $ ./match_args increase 42 26 | 43 27 | ``` 28 | -------------------------------------------------------------------------------- /src/types.md: -------------------------------------------------------------------------------- 1 | 4 | # 型 5 | 6 | 10 | Rustには、プリミティブ型やユーザ定義型を定義したり変換したりする様々な方法があります。 11 | この章は以下の内容を扱います: 12 | 18 | * プリミティブ型の間で[キャスト]を行う 19 | * [リテラル]の型をどれにしたいか指定する 20 | * [型推論]を使う 21 | * 型を[エイリアス]する 22 | 23 | 29 | [キャスト]: types/cast.md 30 | [リテラル]: types/literals.md 31 | [型推論]: types/inference.md 32 | [エイリアス]: types/alias.md 33 | -------------------------------------------------------------------------------- /src-old/generics/assoc_items/input.md: -------------------------------------------------------------------------------- 1 | 4 | 関連要素(Associated Items)とは複数の型の[要素(items)][items]に関係のある規則の総称です。トレイトの拡張機能であり、トレイトの中で新しい要素を定義することを可能にします。 5 | 6 | 8 | そのように定義する要素の一つに**関連型**があります。これにより、ジェネリックなコンテナ型に対するトレイトを使用する際に、よりシンプルな書き方ができるようになります。 9 | 10 | 13 | ### 参照 14 | 15 | [RFC][RFC] 16 | 17 | [items]: http://doc.rust-lang.org/reference.html#items 18 | [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md 19 | -------------------------------------------------------------------------------- /src-old/std_misc/ffi/safe.rs: -------------------------------------------------------------------------------- 1 | use std::fmt; 2 | 3 | #[link(name = "m")] 4 | extern { 5 | fn ccosf(z: Complex) -> Complex; 6 | } 7 | 8 | // 型安全ににするためのラッパ 9 | fn cos(z: Complex) -> Complex { 10 | unsafe { ccosf(z) } 11 | } 12 | 13 | fn main() { 14 | // z = 0 + 1i 15 | let z = Complex { re: 0., im: 1. }; 16 | 17 | println!("cos({:?}) = {:?}", z, cos(z)); 18 | } 19 | 20 | // 単精度浮動小数の複素数型の最小限の実装 21 | #[repr(C)] 22 | #[derive(Clone, Copy)] 23 | struct Complex { 24 | re: f32, 25 | im: f32, 26 | } 27 | 28 | impl fmt::Debug for Complex { 29 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 30 | if self.im < 0. { 31 | write!(f, "{}-{}i", self.re, -self.im) 32 | } else { 33 | write!(f, "{}+{}i", self.re, self.im) 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src-old/generics/impl/input.md: -------------------------------------------------------------------------------- 1 | 2 | 関数と同様、`impl`でメソッドを実装する際にもジェネリック型特有の記法が必要です。 3 | 4 | 5 | ```rust 6 | struct S; // 具象型`S` 7 | struct GenericVal(T,); // ジェネリック型`GenericVal` 8 | 9 | // 型パラメータを指定したうえで、GenericValにメソッドを実装 10 | impl GenericVal {} // `f32`の場合のメソッド 11 | impl GenericVal {} // 上で定義した`S`への実装 12 | 13 | // ジェネリック型のまま扱うには``が先に来る必要がある。 14 | impl GenericVal {} 15 | ``` 16 | 17 | {impl.play} 18 | 19 | 22 | ### 参照 23 | 24 | [参照を返す関数][fn], [`impl`][methods], [`struct`][structs] 25 | 26 | 27 | [fn]: /scope/lifetime/fn.html 28 | [methods]: /fn/methods.html 29 | [specialization_plans]: http://blog.rust-lang.org/2015/05/11/traits.html#the-future 30 | [structs]: /custom_types/structs.html 31 | -------------------------------------------------------------------------------- /src-old/flow_control/if_else/if_else.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let n = 5; 3 | 4 | if n < 0 { 5 | print!("{} is negative", n); 6 | } else if n > 0 { 7 | print!("{} is positive", n); 8 | } else { 9 | print!("{} is zero", n); 10 | } 11 | 12 | let big_n = 13 | if n < 10 && n > -10 { 14 | println!(", and is a small number, increase ten-fold"); 15 | 16 | // この式は`i32`を返す。 17 | 10 * n 18 | } else { 19 | println!(", and is a big number, reduce by two"); 20 | 21 | // ここでも返り値の型は`i32`でなくてはならない。 22 | n / 2 23 | // TODO ^ セミコロン(`;`)をつけて、返り値を返さないようにしてみましょう 24 | }; 25 | // ここにセミコロンを付けるのを忘れないように! 26 | // `let`による変数束縛の際には必ず必要です! 27 | 28 | println!("{} -> {}", n, big_n); 29 | } 30 | -------------------------------------------------------------------------------- /src/flow_control/match/destructuring.md: -------------------------------------------------------------------------------- 1 | 4 | # デストラクト 5 | 6 | 9 | `match`は値をさまざまなやり方でデストラクトすることができます。 10 | 11 | 18 | * [タプルのデストラクト][tuple] 19 | * [配列とスライスのデストラクト][slice] 20 | * [列挙型のデストラクト][enum] 21 | * [ポインタのデストラクト][refs] 22 | * [構造体のデストラクト][struct] 23 | 24 | 25 | [enum]: destructuring/destructure_enum.md 26 | [refs]: destructuring/destructure_pointers.md 27 | [struct]: destructuring/destructure_structures.md 28 | [tuple]: destructuring/destructure_tuple.md 29 | [slice]: destructuring/destructure_slice.md 30 | -------------------------------------------------------------------------------- /src-old/hello/print/print_debug/debug.rs: -------------------------------------------------------------------------------- 1 | // `Structure`という構造体のための`fmt::Debug`をderiveしています。 2 | // `Structure`は単一の`i32`をメンバに持っています。 3 | #[derive(Debug)] 4 | struct Structure(i32); 5 | 6 | // `Deep`という構造体の中に`Structure`を入れます。 7 | // また、これをプリント可能にしています。 8 | #[derive(Debug)] 9 | struct Deep(Structure); 10 | 11 | fn main() { 12 | // `{:?}`によるプリントは `{}`に似ています。 13 | println!("{:?} months in a year.", 12); 14 | println!("{1:?} {0:?} is the {actor:?} name.", 15 | "Slater", 16 | "Christian", 17 | actor="actor's"); 18 | 19 | // `Structure`はプリント可能です！ 20 | println!("Now {:?} will print!", Structure(3)); 21 | 22 | // `derive`を用いることの問題は、結果がどのように見えるか 23 | // コントロールする方法がないことです。 24 | // 出力を`7`だけにするためにはどうしたらよいでしょう？ 25 | println!("Now {:?} will print!", Deep(Structure(7))); 26 | } 27 | -------------------------------------------------------------------------------- /src-old/generics/bounds/testcase_empty/empty.rs: -------------------------------------------------------------------------------- 1 | struct Cardinal; 2 | struct BlueJay; 3 | struct Turkey; 4 | 5 | trait Red {} 6 | trait Blue {} 7 | 8 | impl Red for Cardinal {} 9 | impl Blue for BlueJay {} 10 | 11 | // 以下の関数はトレイト境界を設けているが、そのトレイトが空である 12 | // か否かとは関係がない。 13 | fn red(_: &T) -> &'static str { "red" } 14 | fn blue(_: &T) -> &'static str { "blue" } 15 | 16 | fn main() { 17 | // 訳注: 以下は全て鳥の名前 18 | let cardinal = Cardinal; // 猩々紅冠鳥 19 | let blue_jay = BlueJay; // アオカケス 20 | let _turkey = Turkey; // 七面鳥 21 | 22 | // トレイト境界のため、`red`は`blue_jay`に対しては使用できない。 23 | // `blue`と`Cardinal`も同様、 24 | println!("A cardinal is {}", red(&cardinal)); 25 | println!("A blue jay is {}", blue(&blue_jay)); 26 | //println!("A turkey is {}", red(&_turkey)); 27 | // ^ TODO: この行をアンコメントしてみましょう。 28 | } 29 | -------------------------------------------------------------------------------- /src-old/primitives/literals/literals.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // 整数の足し算 3 | println!("1 + 2 = {}", 1u32 + 2); 4 | 5 | // 整数の引き算 6 | println!("1 - 2 = {}", 1i32 - 2); 7 | // TODO ^ 型が重要であることを実感するため`1i32`を`1u32`に変更してみましょう。 8 | 9 | // 単純な論理演算子 10 | println!("true AND false is {}", true && false); 11 | println!("true OR false is {}", true || false); 12 | println!("NOT true is {}", !true); 13 | 14 | // ビットワイズ演算 15 | println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101); 16 | println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101); 17 | println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101); 18 | println!("1 << 5 is {}", 1u32 << 5); 19 | println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2); 20 | 21 | // 可読性のための`_`（アンダースコア）の使用 22 | println!("One million is written as {}", 1_000_000u32); 23 | } 24 | -------------------------------------------------------------------------------- /src/scope/move/mut.md: -------------------------------------------------------------------------------- 1 | 4 | # ミュータビリティ 5 | 6 | 9 | データのミュータビリティは所有権を移譲した際に変更できます。 10 | 11 | ```rust,editable 12 | fn main() { 13 | let immutable_box = Box::new(5u32); 14 | 15 | println!("immutable_box contains {}", immutable_box); 16 | 17 | // Mutability error 18 | // ミュータビリティエラー 19 | //*immutable_box = 4; 20 | 21 | // *Move* the box, changing the ownership (and mutability) 22 | // boxを *ムーブ* する、同時に所有権とミュータビリティを変更する。 23 | let mut mutable_box = immutable_box; 24 | 25 | println!("mutable_box contains {}", mutable_box); 26 | 27 | // Modify the contents of the box 28 | // boxの内容を変更 29 | *mutable_box = 4; 30 | 31 | println!("mutable_box now contains {}", mutable_box); 32 | } 33 | ``` 34 | -------------------------------------------------------------------------------- /src-old/custom_types/structs/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | `struct`というキーワードを用いて作成できる構造体(「structre」)には3種類あります。 4 | 5 | 6 | 7 | 8 | * タプル。（ほとんどの場合は名前付きタプル） 9 | * クラシックな[C言語スタイルの構造体。][c_struct] 10 | * ユニット。これはフィールドを持たず、ジェネリック型を扱う際に有効です。 11 | 12 | {structs.play} 13 | 14 | 17 | ### 参照 18 | 19 | [アトリビュート(`attributes`)][attributes] and [デストラクト][destructuring] 20 | 21 | [attributes]: ./attribute.html 22 | [c_struct]: http://en.wikipedia.org/wiki/Struct_(C_programming_language) 23 | [destructuring]: ./flow_control/match/destructuring.html 24 | -------------------------------------------------------------------------------- /src-old/mod/split/input.md: -------------------------------------------------------------------------------- 1 | 3 | モジュールはファイル・ディレクトリ間の階層構造と対応関係にあります。モジュールに[お互いがどのように見えているか][visibility]、以下の様なファイルを例に詳しく見ていきましょう。 4 | 5 | ``` 6 | $ tree . 7 | . 8 | |-- my 9 | | |-- inaccessible.rs 10 | | |-- mod.rs 11 | | `-- nested.rs 12 | `-- split.rs 13 | ``` 14 | 15 | {split.rs} 16 | 17 | {my/mod.rs} 18 | 19 | {my/nested.rs} 20 | 21 | {my/inaccessible.rs} 22 | 23 | 24 | では、以前と同じように実行できるか確認しましょう。 25 | 26 | ``` 27 | $ rustc split.rs && ./split 28 | called `my::function()` 29 | called `function()` 30 | called `my::indirect_access()`, that 31 | > called `my::private_function()` 32 | called `my::nested::function()` 33 | ``` 34 | 35 | [visibility]: ../mod/visibility.html 36 | -------------------------------------------------------------------------------- /src-old/std_misc/file/open/input.md: -------------------------------------------------------------------------------- 1 | 2 | スタティックメソッドの`open`を用いることで読み込み専用モードでファイルを開くことが可能です。 3 | 4 | 6 | `File`はファイルディスクリプタという資源を保持しており、`drop`時にはファイルを閉じるところまで面倒を見てくれます。 7 | 8 | {open.rs} 9 | 10 | 11 | 以下が成功時に期待されるアウトプットです。 12 | 13 | ``` 14 | $ echo "Hello World!" > hello.txt 15 | $ rustc open.rs && ./open 16 | hello.txt contains: 17 | Hello World! 18 | ``` 19 | 20 | 23 | (気が向いたなら、上記の例を様々な形で失敗させてみましょう。例えば`hello.txt`が存在しないとか、読み込み権限がないとか、そういった状況で実行してみてください。) 24 | -------------------------------------------------------------------------------- /src/conversion.md: -------------------------------------------------------------------------------- 1 | 4 | # 型変換 5 | 6 | 9 | プリミティブ型同士は[キャスト][casting]を用いて変換できます。 10 | 11 | 18 | Rustはカスタム型（例えば`struct`や`enum`）間の変換を[トレイト][traits]を用いて行います。ジェネリックな型変換には[`From`]および[`Into`]トレイトを使用します。しかし、よくあるケースにおいて、特に`String`との相互の型変換では、特殊なトレイトが使用されます。 19 | 20 | [casting]: types/cast.md 21 | [traits]: trait.md 22 | [`From`]: https://doc.rust-lang.org/std/convert/trait.From.html 23 | [`Into`]: https://doc.rust-lang.org/std/convert/trait.Into.html 24 | -------------------------------------------------------------------------------- /src/error/panic.md: -------------------------------------------------------------------------------- 1 | # `panic` 2 | 3 | 8 | `panic`は、最もシンプルなエラーハンドリングの仕組みです。エラーメッセージの出力、スタックの巻き戻し、そして多くの場合プログラムの終了を実行します。 9 | 例として、エラー条件に対して明示的に`panic`を呼び出してみましょう。 10 | 11 | ```rust,editable,ignore,mdbook-runnable 12 | fn drink(beverage: &str) { 13 | // You shouldn't drink too much sugary beverages. 14 | // Princesses hate snakes, so we need to stop if she disapproves! 15 | // 甘すぎる飲み物を飲むべきではありません。 16 | if beverage == "lemonade" { panic!("AAAaaaaa!!!!"); } 17 | 18 | println!("Some refreshing {} is all I need.", beverage); 19 | } 20 | 21 | fn main() { 22 | drink("water"); 23 | drink("lemonade"); 24 | } 25 | ``` 26 | -------------------------------------------------------------------------------- /src-old/fn/fn.rs: -------------------------------------------------------------------------------- 1 | // C/C++とは違い、関数の定義を行う順番に制限はない。 2 | fn main() { 3 | // ここで関数を使用し、後ほど定義してもかまわない。 4 | fizzbuzz_to(100); 5 | } 6 | 7 | // ブーリアン型を返す関数 8 | fn is_divisible_by(lhs: u32, rhs: u32) -> bool { 9 | // 例外的な引数を受けた場合、早めに返す。 10 | if rhs == 0 { 11 | return false; 12 | } 13 | 14 | // これは式文であり、`return`キーワードは必要ではない。 15 | lhs % rhs == 0 16 | } 17 | 18 | // 値を「返さない」関数、実際にはユニット型(`()`)を返している。 19 | fn fizzbuzz(n: u32) -> () { 20 | if is_divisible_by(n, 15) { 21 | println!("fizzbuzz"); 22 | } else if is_divisible_by(n, 3) { 23 | println!("fizz"); 24 | } else if is_divisible_by(n, 5) { 25 | println!("buzz"); 26 | } else { 27 | println!("{}", n); 28 | } 29 | } 30 | 31 | // 関数が`()`を返すとき、返り値の方を書く必要はない。 32 | fn fizzbuzz_to(n: u32) { 33 | for n in 1..n + 1 { 34 | fizzbuzz(n); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/attribute/cfg/custom.md: -------------------------------------------------------------------------------- 1 | 4 | # 条件の追加 5 | 6 | 10 | `target_os`のように、いくつかの条件分岐は`rustc`が暗黙のうちに提供しています。条件を独自に追加する場合には`--cfg`フラグを用いて`rustc`に伝える必要があります。 11 | 12 | ```rust,editable,ignore,mdbook-runnable 13 | #[cfg(some_condition)] 14 | fn conditional_function() { 15 | println!("condition met!"); 16 | } 17 | 18 | fn main() { 19 | conditional_function(); 20 | } 21 | ``` 22 | 23 | 26 | 独自の`cfg`フラグを用いない場合、何が起きるかやってみてください。 27 | 28 | 31 | `cfg`フラグがある場合: 32 | 33 | ```shell 34 | $ rustc --cfg some_condition custom.rs && ./custom 35 | condition met! 36 | ``` 37 | -------------------------------------------------------------------------------- /src/generics/assoc_items.md: -------------------------------------------------------------------------------- 1 | 4 | # 関連型 5 | 6 | 11 | 関連要素(Associated Items)とは複数の型の[要素(items)][items]に関係のある規則の総称です。トレイトの拡張機能であり、トレイトの中で新しい要素を定義することを可能にします。 12 | 13 | 17 | そのように定義する要素の一つに **関連型** があります。これにより、ジェネリックなコンテナ型に対するトレイトを使用する際に、よりシンプルな書き方ができるようになります。 18 | 19 | 22 | ### 参照 23 | 24 | [RFC][RFC] 25 | 26 | [items]: https://doc.rust-lang.org/reference/items.html 27 | [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md 28 | -------------------------------------------------------------------------------- /src/std.md: -------------------------------------------------------------------------------- 1 | 4 | # 標準ライブラリの型 5 | 6 | 10 | `std`ライブラリは、基本データ型を劇的に拡張するカスタム型を数多く提供します。例えば以下です。 11 | 12 | 19 | * 拡張可能な文字列である`String`。例えば: `"hello world"` 20 | * オプション型: `Option` 21 | * エラーハンドリング用の`Result` 22 | * ヒープ上資源のポインタ`Box` 23 | 24 | 27 | ### 参照 28 | 29 | 32 | [基本データ型][primitives], [`std`ライブラリ][std] 33 | 34 | [primitives]: primitives.md 35 | [std]: https://doc.rust-lang.org/std/ 36 | -------------------------------------------------------------------------------- /src-old/custom_types/enum/enum_use/use.rs: -------------------------------------------------------------------------------- 1 | // 使用されていないコードよる警告を隠すアトリビュート 2 | #![allow(dead_code)] 3 | 4 | enum Status { 5 | Rich, 6 | Poor, 7 | } 8 | 9 | enum Work { 10 | Civilian, 11 | Soldier, 12 | } 13 | 14 | fn main() { 15 | // `use`することで絶対名でなくとも使用可能になる。 16 | use Status::{Poor, Rich}; 17 | // `Work`の中の名前をすべて`use`する 18 | use Work::*; 19 | 20 | // `use`しているため、`Status::Poor`と書いていることに等しい 21 | let status = Poor; 22 | // `Work::Civilian`に等しい 23 | let work = Civilian; 24 | 25 | match status { 26 | // `use`しているのでスコープを明示していない 27 | Rich => println!("The rich have lots of money!"), 28 | Poor => println!("The poor have no money..."), 29 | } 30 | 31 | match work { 32 | // こちらも同じ 33 | Civilian => println!("Civilians work!"), 34 | Soldier => println!("Soldiers fight!"), 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/cargo.md: -------------------------------------------------------------------------------- 1 | 4 | # Cargo 5 | 6 | 10 | `cargo`はRustの公式パッケージ管理ツールです。とても便利な機能が多くあり、コードの品質や開発速度の向上に役立ちます。以下はその例です。 11 | 12 | 18 | - 依存関係の管理と[crates.io](https://crates.io)（Rustの公式パッケージレジストリ）とのインテグレーション 19 | - ユニットテスト 20 | - ベンチマーク 21 | 22 | 26 | この章では、簡単な基本機能を説明します。包括的なドキュメントは[The Cargo Book](https://doc.rust-lang.org/cargo/)を参照してください。 27 | -------------------------------------------------------------------------------- /src-old/mod/use/use.rs: -------------------------------------------------------------------------------- 1 | // `deeply::nested::function`を`other_function`にバインド 2 | use deeply::nested::function as other_function; 3 | 4 | fn function() { 5 | println!("called `function()`"); 6 | } 7 | 8 | mod deeply { 9 | pub mod nested { 10 | pub fn function() { 11 | println!("called `deeply::nested::function()`") 12 | } 13 | } 14 | } 15 | 16 | fn main() { 17 | // `deeply::nested::function`へ、より簡潔にアクセス 18 | other_function(); 19 | 20 | println!("Entering block"); 21 | { 22 | // これは`use deeply::nested::function as function`と同等 23 | // この`function()`は外の`function()`をシャドウイングする 24 | use deeply::nested::function; 25 | function(); 26 | 27 | // `use`バインディングは局所的なスコープを持つ。 28 | // この場合には`function()`のシャドウイングはこのブロック内のみ 29 | println!("Leaving block"); 30 | } 31 | 32 | function(); 33 | } 34 | -------------------------------------------------------------------------------- /src-old/variable_bindings/scope/scope.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // この変数はmain関数内が生息域です。 3 | let long_lived_binding = 1; 4 | 5 | // ここから下が`main`より小さいスコープを持つブロックとなります。 6 | { 7 | // この変数はこのブロック内のみに存在します。 8 | let short_lived_binding = 2; 9 | 10 | println!("inner short: {}", short_lived_binding); 11 | 12 | // この変数はスコープ外の同名の変数を*シャドーイング*します。 13 | let long_lived_binding = 5_f32; 14 | 15 | println!("inner long: {}", long_lived_binding); 16 | } 17 | // ブロックの終わり 18 | 19 | // `short_lived_binding`はこのスコープ内には存在しませんのでエラーとなります。 20 | println!("outer short: {}", short_lived_binding); 21 | // FIXME ^ コメントアウトしましょう 22 | 23 | println!("outer long: {}", long_lived_binding); 24 | 25 | // この変数バインディングも以前に定義した変数を*シャドーイング*します 26 | let long_lived_binding = 'a'; 27 | 28 | println!("outer long: {}", long_lived_binding); 29 | } 30 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/static_lifetime/static_lifetime.rs: -------------------------------------------------------------------------------- 1 | // `'static`ライフタイムを持つ定数を作成 2 | static NUM: i32 = 18; 3 | 4 | // `NUM`への参照を返す。ライフタイムは`'static`から引数の 5 | // ライフタイムへと圧縮されている。 6 | fn coerce_static<'a>(_: &'a i32) -> &'a i32 { 7 | &NUM 8 | } 9 | 10 | fn main() { 11 | { 12 | // 文字列リテラルを用いて変数を作成し、プリントする 13 | let static_string = "I'm in read-only memory"; 14 | println!("static_string: {}", static_string); 15 | 16 | // `static_string`がスコープから抜けると、参照は使用することが 17 | // できなくなるが、データはバイナリ中に残る。 18 | } 19 | 20 | { 21 | // `coerce_static`関数を呼び出すために、整数を作成 22 | let lifetime_num = 9; 23 | 24 | // `NUM`を`lifetime_num`のライフタイムへと圧縮 25 | let coerced_static = coerce_static(&lifetime_num); 26 | 27 | println!("coerced_static: {}", coerced_static); 28 | } 29 | 30 | println!("NUM: {} stays accessible!", NUM); 31 | } 32 | -------------------------------------------------------------------------------- /src-old/generics/generics.rs: -------------------------------------------------------------------------------- 1 | // `A`という具象型 2 | struct A; 3 | 4 | // `Single`という型を定義する際に`A`を使用しているが、その最初の使用よりも 5 | // 先に``がないため、また、`A`自身も具象型であるため、`Single`は具象型となる。 6 | struct Single(A); 7 | // ^ Singleによる`A`の一番最初の使用はここ 8 | 9 | // ここでは``が一番初めの`T`の使用よりも先に来ている。よって`SingleGen`はジェネリック型 10 | // となる。なぜならば型パラメータ`T`がジェネリックだからである。`T`はどんな型にもなりえるため、 11 | // 上で定義した`A`を受け取ることもできる。 12 | struct SingleGen(T); 13 | 14 | fn main() { 15 | // `Single`は具象型で、`A`のみを受け取る。 16 | let _s = Single(A); 17 | 18 | // `_char`という名の変数を生成する。これは`SingleGen` 19 | // という型で、値は`SingleGen('a')`となる。ここでは、`SingleGen`には明示的な型パラメータ 20 | // が与えられている。 21 | let _char: SingleGen = SingleGen('a'); 22 | 23 | // `SingleGen`型の変数には明示的に型パラメータを与えなくてもよい。 24 | let _t = SingleGen(A); // 上で定義した`A`を使用 25 | let _i32 = SingleGen(6); // `i32`を使用 26 | let _char = SingleGen('a'); // `char`を使用 27 | } 28 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/fn/input.md: -------------------------------------------------------------------------------- 1 | 2 | [省略][elision]をしない場合、ライフタイムのシグネチャ(e.g. `<'a>`)を持つ関数にはいくつかの制限があります。 3 | 4 | 7 | * 全ての変数においてライフタイムを明示しなくてはならない。 8 | * 返り値となる参照はすべて引数と同じライフタイムか、`static`ライフタイムを持たなくてはならない 9 | 10 | 13 | 加えて、引数のない関数から参照を返す場合、それが結果的に無効なデータへの参照になるならば、禁止されている 14 | 15 | {fn.play} 16 | 17 | 20 | ### 参照 21 | 22 | [functions][fn] 23 | 24 | [elision]: /scope/lifetime/elision.html 25 | [fn]: /fn.html 26 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/struct/struct.rs: -------------------------------------------------------------------------------- 1 | // `i32`への参照をメンバに持つ`Borrowed`型。 2 | // 参照は`Borrowed`自体よりも長生きでなくてはならない。 3 | #[derive(Debug)] 4 | struct Borrowed<'a>(&'a i32); 5 | 6 | // 同様に、ここでも参照は構造体よりも長生きでなくてはならない。 7 | #[derive(Debug)] 8 | struct NamedBorrowed<'a> { 9 | x: &'a i32, 10 | y: &'a i32, 11 | } 12 | 13 | // `i32`、あるいは`i32`への参照のいずれかとなる列挙型 14 | #[derive(Debug)] 15 | enum Either<'a> { 16 | Num(i32), 17 | Ref(&'a i32), 18 | } 19 | 20 | fn main() { 21 | let x = 18; 22 | let y = 15; 23 | 24 | let single = Borrowed(&x); 25 | let double = NamedBorrowed { x: &x, y: &y }; 26 | let reference = Either::Ref(&x); 27 | let number = Either::Num(y); 28 | 29 | println!("x is borrowed in {:?}", single); 30 | println!("x and y are borrowed in {:?}", double); 31 | println!("x is borrowed in {:?}", reference); 32 | println!("y is *not* borrowed in {:?}", number); 33 | } 34 | -------------------------------------------------------------------------------- /src-old/fn/closures/closure_examples/iter_find/iter_find.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | let vec1 = vec![1, 2, 3]; 3 | let vec2 = vec![4, 5, 6]; 4 | 5 | // ベクトル型に対する`iter`は`&i32`を`yield`する。 6 | let mut iter = vec1.iter(); 7 | // `inter_iter()`の場合は`i32`を`yield`する。 8 | let mut into_iter = vec2.into_iter(); 9 | 10 | // `yield`された要素へのリファレンスは`&&i32`となる。`i32`へとデストラクトする。 11 | println!("Find 2 in vec1: {:?}", iter .find(|&&x| x == 2)); 12 | // `into_iter`の場合は`&i32`が要素のリファレンス。 13 | println!("Find 2 in vec2: {:?}", into_iter.find(| &x| x == 2)); 14 | 15 | let array1 = [1, 2, 3]; 16 | let array2 = [4, 5, 6]; 17 | 18 | // 配列に対する`iter`も`&i32`を`yield`する。 19 | println!("Find 2 in array1: {:?}", array1.iter() .find(|&&x| x == 2)); 20 | // 配列に`into_iter()`を使うと例外的に`&i32`を`yield`する。 21 | println!("Find 2 in array2: {:?}", array2.into_iter().find(|&&x| x == 2)); 22 | } 23 | 24 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/elision/input.md: -------------------------------------------------------------------------------- 1 | 5 | ライフタイムのパターンのうちのいくつかは、他と比べてあまりにも一般的に使用されるため、明示的に入力せずとも借用チェッカーが暗黙のうちに補完してくれます。これにより可読性とタイプ量を減らすことができます。 6 | 7 | 8 | 10 | 以下のコードでは省略の例を幾つかお見せします。より完全な説明を見たい場合は、「プログラミング言語Rust」の[ライフタイムの省略](elision-ja)の項を見てください。 11 | 12 | {elision.play} 13 | 14 | 17 | ### 参照 18 | 19 | [ライフタイムの省略][elision-ja] 20 | 21 | [elision-ja]: https://rust-lang-ja.github.io/the-rust-programming-language-ja/1.6/book/lifetimes.html#ライフタイムの省略 22 | -------------------------------------------------------------------------------- /src-old/scope/borrow/borrow.rs: -------------------------------------------------------------------------------- 1 | // この関数はボックスの所有権を奪い、破棄する。 2 | fn eat_box(boxed_int: Box) { 3 | println!("Destroying box that contains {}", boxed_int); 4 | } 5 | 6 | // この関数はi32を借用する 7 | fn borrow_box(borrowed_int: &i32) { 8 | println!("This int is: {}", borrowed_int); 9 | } 10 | 11 | fn main() { 12 | // ボックス化された整数を作成 13 | let boxed_int = Box::new(5); 14 | 15 | // Boxの中身を借用。所有権を奪うわけではないため、 16 | // 直後にもう一度借用できる。 17 | borrow_box(&boxed_int); 18 | borrow_box(&boxed_int); 19 | 20 | { 21 | // ボックス内の要素に対する参照を取得 22 | let _ref_to_int: &i32 = &boxed_int; 23 | 24 | // エラー! 25 | // ボックス内の要素が借用されているため、`boxed_int`を破棄する 26 | // ことはできない。 27 | eat_box(boxed_int); 28 | // FIXME ^ この行をコメントアウトしましょう。 29 | 30 | // ここで`_ref_to_int`はスコープを抜け、借用もなくなります。 31 | } 32 | 33 | // ここでようやく、`eat_box`は所有権を移譲し、破棄することができます。 34 | eat_box(boxed_int); 35 | } 36 | -------------------------------------------------------------------------------- /src-old/std_misc/ffi/ffi.rs: -------------------------------------------------------------------------------- 1 | use std::fmt; 2 | 3 | // このexternブロックはlibmライブラリをリンクする。 4 | #[link(name = "m")] 5 | extern { 6 | // 他言語の関数宣言。 7 | // この関数は単精度浮動小数の複素数型の平方根を計算するためのもの 8 | fn csqrtf(z: Complex) -> Complex; 9 | } 10 | 11 | fn main() { 12 | // z = -1 + 0i 13 | let z = Complex { re: -1., im: 0. }; 14 | 15 | // 安全でない方法で他言語関数を呼び出す。 16 | let z_sqrt = unsafe { 17 | csqrtf(z) 18 | }; 19 | 20 | println!("the square root of {:?} is {:?}", z, z_sqrt); 21 | } 22 | 23 | // 単精度浮動小数の複素数型の最小限の実装 24 | #[repr(C)] 25 | #[derive(Clone, Copy)] 26 | struct Complex { 27 | re: f32, 28 | im: f32, 29 | } 30 | 31 | impl fmt::Debug for Complex { 32 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 33 | if self.im < 0. { 34 | write!(f, "{}-{}i", self.re, -self.im) 35 | } else { 36 | write!(f, "{}+{}i", self.re, self.im) 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src-old/fn/closures/closure_examples/iter_any/input.md: -------------------------------------------------------------------------------- 1 | 4 | `iterator::any`は、イテレータ内に一つでも条件を満たす要素があれば、`true`を返し、さもなくば`false`を返すイテレータです。以下がそのシグネチャです 5 | 6 | ```rust 7 | pub trait Iterator { 8 | // イテレートされる値の型 9 | type Item; 10 | 11 | // `any`は`&mut self`を取るため、イテレータを呼び出した値を借用し 12 | // 変更しますが、消費し尽くすことはありません。 13 | fn any(&mut self, f: F) -> bool where 14 | // `FnMut`はクロージャによって補足される変数が変更される 15 | // 事はあっても消費されることはないということを示します。 16 | // `&Self::Item`はクロージャが変数を参照として取ることを示します。 17 | F: FnMut(Self::Item) -> bool {} 18 | } 19 | ``` 20 | 21 | {iter_any.play} 22 | 23 | 26 | ### 参照 27 | 28 | [`std::iter::Iterator::any`][any] 29 | 30 | [any]: http://doc.rust-lang.org/std/iter/trait.Iterator.html#method.any 31 | -------------------------------------------------------------------------------- /src-old/generics/gen_fn/input.md: -------------------------------------------------------------------------------- 1 | 3 | 「型`T`はその前に``があるとジェネリック型になる」というルールは関数に対しても当てはまります。 4 | 5 | 9 | ジェネリック関数を使用する際、以下の様な場合には型パラメータを明示する必要があります。 10 | 11 | * 返り値がジェネリック型である場合。 12 | * コンパイラが型パラメータを推論するのに十分な情報がない場合 13 | 14 | 16 | 型パラメータを明示したうえでの関数呼び出しの構文は`fun::()`のようになります。 17 | 18 | {fn.play} 19 | 20 | 23 | ### 参照 24 | 25 | [関数][fn] and [構造体][structs] 26 | 27 | [fn]:../fn.html 28 | [structs]: ../custom_types/structs.html 29 | -------------------------------------------------------------------------------- /src/variable_bindings/mut.md: -------------------------------------------------------------------------------- 1 | 4 | # ミュータビリティ 5 | 6 | 10 | 変数はデフォルトでイミュータブル（変更不可能）ですが`mut`構文を使用することでミュータブルになります。 11 | 12 | ```rust,editable,ignore,mdbook-runnable 13 | fn main() { 14 | let _immutable_binding = 1; 15 | let mut mutable_binding = 1; 16 | 17 | println!("Before mutation: {}", mutable_binding); 18 | 19 | // Ok 20 | mutable_binding += 1; 21 | 22 | println!("After mutation: {}", mutable_binding); 23 | 24 | // Error! Cannot assign a new value to an immutable variable 25 | // エラー! イミュータブルな変数には新しい値を代入できません 26 | _immutable_binding += 1; 27 | // FIXME ^ Comment out this line 28 | // FIXME ^ この行をコメントアウトしましょう 29 | } 30 | ``` 31 | 32 | 35 | コンパイラはミュータビリティに関するエラーの詳細を出してくれます。 36 | -------------------------------------------------------------------------------- /src-old/hello/print/print_display/testcase_list/testcase_list.rs: -------------------------------------------------------------------------------- 1 | use std::fmt; // Import the `fmt` module. 2 | 3 | // `Vec`を含む`List`という名の構造体を定義 4 | struct List(Vec); 5 | 6 | impl fmt::Display for List { 7 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 8 | // `self`をデリファレンスし、 デストラクトすることで 9 | // `vec`へのリファレンスを作成する 10 | let List(ref vec) = *self; 11 | 12 | try!(write!(f, "[")); 13 | 14 | // `v`を介して`vec`をイテレーションし、同時にカウントを 15 | // `enumerate`で取得する 16 | for (count, v) in vec.iter().enumerate() { 17 | // 初回を除き、`write!`を呼ぶ前にカンマを加える。 18 | // エラーを返すために`try!`を使用する 19 | if count != 0 { try!(write!(f, ", ")); } 20 | try!(write!(f, "{}", v)); 21 | } 22 | 23 | // 開きっぱなしのブラケットを閉じて、`fmt::Result`の値を返す。 24 | write!(f, "]") 25 | } 26 | } 27 | 28 | fn main() { 29 | let v = List(vec![1, 2, 3]); 30 | println!("{}", v); 31 | } 32 | -------------------------------------------------------------------------------- /src-old/std/vec/input.md: -------------------------------------------------------------------------------- 1 | 7 | 「ベクタ」はサイズを変更可能な配列です。スライスと同様、そのサイズはコンパイル時には不定ですが、いつでも要素を追加したり削除したりすることができます。ベクタは3つの要素で、その特徴が完全に決まります。 8 | 9 | 1. データへのポインタ 10 | 2. 長さ 11 | 3. 容量 ... あらかじめメモリ上にベクタのために確保された領域 12 | 13 | ベクタはその容量を超えない限りにおいて長くしていくことができます。超えた場合には、より大きな容量を持つように割り当てなおされます。 14 | 15 | 16 | {vec.play} 17 | 18 | 20 | `Vec`型のメソッドの一覧は[std::vec][vec]モジュールを見てください。 21 | 22 | [vec]: http://doc.rust-lang.org/std/vec/ 23 | -------------------------------------------------------------------------------- /src-old/fn/closures/closure_examples/iter_find/input.md: -------------------------------------------------------------------------------- 1 | 4 | `Iterator::find`はイテレータに渡される関数で、条件を満たす最初の値を`Option`として返します。型シグネチャは以下のようになります。 5 | 6 | ```rust 7 | pub trait Iterator { 8 | // イテレートされる値の型 9 | type Item; 10 | 11 | // `find`は`&mut self`を取るため、イテレータを呼び出した値を借用し 12 | // 変更しますが、消費し尽くすことはありません。 13 | fn find

(&mut self, predicate: P) -> Option where 14 | // `FnMut`はクロージャによって補足される変数が変更される 15 | // 事はあっても消費されることはないということを示します。 16 | // `&Self::Item`はクロージャが変数を参照として取ることを示します。 17 | P: FnMut(&Self::Item) -> bool {} 18 | } 19 | ``` 20 | 21 | {iter_find.play} 22 | 23 | 26 | ### 参照 27 | 28 | [`std::iter::Iterator::find`][find] 29 | 30 | [find]: http://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find 31 | -------------------------------------------------------------------------------- /src-old/std_misc/fs/input.md: -------------------------------------------------------------------------------- 1 | 3 | `std::io::fs`モジュールはファイルシステムとやり取りするための関数をいくつか持っています。 4 | 5 | {fs.rs} 6 | 7 | 8 | 以下が成功時に期待されるアウトプットです。 9 | 10 | ``` 11 | $ rustc fs.rs && ./fs 12 | `mkdir a` 13 | `echo hello > a/b.txt` 14 | `mkdir -p a/c/d` 15 | `touch a/c/e.txt` 16 | `ln -s ../b.txt a/c/b.txt` 17 | `cat a/c/b.txt` 18 | > hello 19 | `ls a` 20 | > a/b.txt 21 | > a/c 22 | `walk a` 23 | > a/c 24 | > a/c/b.txt 25 | > a/c/e.txt 26 | > a/c/d 27 | > a/b.txt 28 | `rm a/c/e.txt` 29 | `rmdir a/c/d` 30 | ``` 31 | 32 | 33 | 最終的な`a`ディレクトリの状態は以下です。 34 | 35 | ``` 36 | $ tree a 37 | a 38 | |-- b.txt 39 | `-- c 40 | `-- b.txt -> ../b.txt 41 | 42 | 1 directory, 2 files 43 | ``` 44 | 45 | 48 | ### 参照 49 | 50 | [`cfg!`][cfg] 51 | 52 | [cfg]: ../attribute/cfg.html 53 | -------------------------------------------------------------------------------- /src-old/crates/input.md: -------------------------------------------------------------------------------- 1 | 6 | クレイトはRustにおけるコンパイルの単位です。`rustc some_file.rs`が呼ばれると、`some_file.rs`は必ず*クレイトファイル*として扱われます。もし`some_file.rs`が`mod`宣言を含んでいるのならば、コンパイルの*前に*モジュールファイルの中身は、クレイトファイルと結合されます。言い換えると、それぞれのモジュールが独立にコンパイルされるということはありませんが、それぞれのクレートは互いに独立にコンパイルされるということです。 7 | 8 | 11 | クレイトはバイナリあるいはライブラリ形式でコンパイルされることが可能です。デフォルトでは`rustc`はクレイトからバイナリを作り出しますが、この振る舞いは`--crate-type`フラグを`rustc`に渡すことでオーバーライドできます。 12 | -------------------------------------------------------------------------------- /src-old/trait/drop/input.md: -------------------------------------------------------------------------------- 1 | 4 | [`Drop`][Drop]トレイトにはメソッドが一つだけしかありません。`drop`です。これは、オブジェクトがスコープから抜けた時に自動で呼ばれます。`Drop`トレイトの主な使用目的は、インスタンスが所有する資源を開放することです。 5 | 6 | 7 | 10 | `Drop`トレイトを実装している型の例としては`Box`、`Vec`、`String`、`File`、`Process`等があげられます。`Drop`トレイトは任意の型に対して手動で実装することができます。 11 | 12 | 14 | 以下の例では`drop`メソッドにコンソールへの出力を追加することで、`drop`が呼ばれたタイミングが分かるようにしています。 15 | 16 | {drop.play} 17 | 18 | [Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html 19 | -------------------------------------------------------------------------------- /src-old/fn/closures/input.md: -------------------------------------------------------------------------------- 1 | 4 | Rustのクロージャはラムダ(`lambda`)とも呼ばれ、自身が定義された環境の外側の変数を参照できるような関数のことを指します。クロージャの文法と性質はサッと何かを仕上げたいときに非常に有用です。以下がクロージャの性質の一部です。 5 | 6 | 7 | 14 | * 引数の周りを、`()`の代わりに`||`で囲む。 15 | * 引数と返り値の*型*の*両方*を推測してくれる。 16 | * 引数の*名前*は明示しなくてはならない。 17 | * 関数が１文で終わるときは`{}`で関数のbodyを囲む必要はない。複数文の場合は必須。 18 | * 外側の環境の変数を参照することができる。 19 | * クロージャの呼び出しは関数と全く一緒である。例: `call(var)` 20 | 21 | {closures.play} 22 | -------------------------------------------------------------------------------- /src/scope/lifetime/trait.md: -------------------------------------------------------------------------------- 1 | 4 | # トレイト 5 | 6 | 10 | トレイトのメソッドにおけるライフタイムのアノテーションは、 11 | 基本的には関数に似ています。 12 | `impl`にもライフタイムのアノテーションがあることに注意してください。 13 | 14 | ```rust,editable 15 | // A struct with annotation of lifetimes. 16 | // ライフタイムのアノテーションつき構造体。 17 | #[derive(Debug)] 18 | struct Borrowed<'a> { 19 | x: &'a i32, 20 | } 21 | 22 | // Annotate lifetimes to impl. 23 | // ライフタイムのアノテーションつきimpl。 24 | impl<'a> Default for Borrowed<'a> { 25 | fn default() -> Self { 26 | Self { 27 | x: &10, 28 | } 29 | } 30 | } 31 | 32 | fn main() { 33 | let b: Borrowed = Default::default(); 34 | println!("b is {:?}", b); 35 | } 36 | ``` 37 | 38 | 41 | ### 参照 42 | 43 | 46 | [トレイト][trait] 47 | 48 | 49 | [trait]: ../../trait.md 50 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/static_lifetime/input.md: -------------------------------------------------------------------------------- 1 | 6 | `'static`ライフタイムは全てのライフタイムの中で最長で、プログラムが動作している間、常に有効になります。`'static`であっても、より短いライフタイムに圧縮されることはあります。`'static`なライフタイムをもつ変数を作成する方法は2つあり、いずれも実行バイナリの一部としてROM上に保存されます。 7 | 8 | 10 | * `static`宣言とともに定数を作成する。 11 | * 文字列リテラル で`&'static str`型を持つ変数を作成する。 12 | 13 | 14 | では、それぞれの方法の例を見ていきましょう。 15 | 16 | {static_lifetime.play} 17 | 18 | 21 | ### 参照 22 | 23 | [`'static` 定数s][static_const] 24 | 25 | [static_const]: /custom_types/constants.html 26 | -------------------------------------------------------------------------------- /src-old/std/vec/vec.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // イテレータは要素を収集してベクタにすることができる。 3 | let collected_iterator: Vec = (0..10).collect(); 4 | println!("Collected (0..10) into: {:?}", collected_iterator); 5 | 6 | // ベクタの初期化には`vec!`マクロが使用できる。 7 | let mut xs = vec![1i32, 2, 3]; 8 | println!("Initial vector: {:?}", xs); 9 | 10 | // 新しい要素をベクタの最後に挿入することができる。 11 | println!("Push 4 into the vector"); 12 | xs.push(4); 13 | println!("Vector: {:?}", xs); 14 | 15 | // エラー！イミュータブルなベクタは成長できない 16 | collected_iterator.push(0); 17 | // FIXME ^ この行をコメントアウトしましょう。 18 | 19 | // `len`メソッドは現在のベクタのサイズを返す。 20 | println!("Vector size: {}", xs.len()); 21 | 22 | // 鍵括弧(`[]`)を用いてインデックスによる要素へのアクセスができる 23 | // (インデックスは0から開始する) 24 | println!("Second element: {}", xs[1]); 25 | 26 | // `pop`はベクタの最後の要素を削除すると同時に返す。 27 | println!("Pop last element: {:?}", xs.pop()); 28 | 29 | // 不正なインデックスアクセスはpanicを引き起こします。 30 | println!("Fourth element: {}", xs[3]); 31 | } 32 | -------------------------------------------------------------------------------- /src-old/trait/drop/drop.rs: -------------------------------------------------------------------------------- 1 | struct Droppable { 2 | name: &'static str, 3 | } 4 | 5 | // このちょっとした実装で、`drop`にコンソール出力機能がつきます。 6 | impl Drop for Droppable { 7 | fn drop(&mut self) { 8 | println!("> Dropping {}", self.name); 9 | } 10 | } 11 | 12 | fn main() { 13 | let _a = Droppable { name: "a" }; 14 | 15 | // block A 16 | { 17 | let _b = Droppable { name: "b" }; 18 | 19 | // block B 20 | { 21 | let _c = Droppable { name: "c" }; 22 | let _d = Droppable { name: "d" }; 23 | 24 | println!("Exiting block B"); 25 | } 26 | println!("Just exited block B"); 27 | 28 | println!("Exiting block A"); 29 | } 30 | println!("Just exited block A"); 31 | 32 | // `drop`関数を用いて変数を手動で開放することもできます。 33 | drop(_a); 34 | // TODO ^ この行をコメントアウトしてみましょう。 35 | 36 | println!("end of the main function"); 37 | 38 | // `_a`はここで`drop`されることは*ない*。なぜならば、上ですでに 39 | // (手動で)`drop`されているため。 40 | } 41 | -------------------------------------------------------------------------------- /src/flow_control/while.md: -------------------------------------------------------------------------------- 1 | # while 2 | 3 | 6 | `while`キーワードは条件が真である限り実行され続けるループのために使用します。 7 | 8 | 11 | 悪名高い[FizzBuzz問題][fizzbuzz]を`while`を用いて解いてみましょう。 12 | 13 | ```rust,editable 14 | fn main() { 15 | // A counter variable 16 | // カウンタとなる変数 17 | let mut n = 1; 18 | 19 | // Loop while `n` is less than 101 20 | // `n`が101以下である場合のループ 21 | while n < 101 { 22 | if n % 15 == 0 { 23 | println!("fizzbuzz"); 24 | } else if n % 3 == 0 { 25 | println!("fizz"); 26 | } else if n % 5 == 0 { 27 | println!("buzz"); 28 | } else { 29 | println!("{}", n); 30 | } 31 | 32 | // Increment counter 33 | // カウンタに1を追加 34 | n += 1; 35 | } 36 | } 37 | ``` 38 | 39 | [fizzbuzz]: https://en.wikipedia.org/wiki/Fizz_buzz 40 | -------------------------------------------------------------------------------- /docs/404.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: "404 Not Found" 3 | permalink: /404.html 4 | --- 5 | 6 | ## 404 Not Found 7 | 8 |

12 | 13 | 33 | -------------------------------------------------------------------------------- /docs/editor.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | window.editors = []; 3 | (function(editors) { 4 | if (typeof(ace) === 'undefined' || !ace) { 5 | return; 6 | } 7 | 8 | Array.from(document.querySelectorAll('.editable')).forEach(function(editable) { 9 | let display_line_numbers = window.playground_line_numbers || false; 10 | 11 | let editor = ace.edit(editable); 12 | editor.setOptions({ 13 | highlightActiveLine: false, 14 | showPrintMargin: false, 15 | showLineNumbers: display_line_numbers, 16 | showGutter: display_line_numbers, 17 | maxLines: Infinity, 18 | fontSize: "0.875em" // please adjust the font size of the code in general.css 19 | }); 20 | 21 | editor.$blockScrolling = Infinity; 22 | 23 | editor.getSession().setMode("ace/mode/rust"); 24 | 25 | editor.originalCode = editor.getValue(); 26 | 27 | editors.push(editor); 28 | }); 29 | })(window.editors); 30 | -------------------------------------------------------------------------------- /patches/404.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: "404 Not Found" 3 | permalink: /404.html 4 | --- 5 | 6 | ## 404 Not Found 7 | 8 |
9 | お探しのページは存在しません。 10 | トップページからご利用ください。 11 |
12 | 13 | 33 | -------------------------------------------------------------------------------- /src-old/error/option_with_result/combinator_combinations/input.md: -------------------------------------------------------------------------------- 1 | 3 | 複数の`Result`がお互いに関係しあう必要がある場合はどうでしょう？扱いやすさに変わりはないでしょうか？実際に見てみるとわかりますが、そうでもありません。 4 | 5 | {result_try.play} 6 | 7 | 10 | このアプローチでは、値をラップする`Ok`を除外せずにそのまま扱おうとしています。時にはこれが良いアプローチである場合もありますが。今回は非常にぎこちないものとなってしまっています。`panic`を引き起こす可能性なしに、`unwrap`することができたらどうでしょう？次のステップではその方法を見ていきます。 11 | 12 | 15 | ### 参照 16 | 17 | [`Result`][result]、[`io::Result`][io_result] 18 | 19 | [result]: http://doc.rust-lang.org/std/result/enum.Result.html 20 | [io_result]: http://doc.rust-lang.org/std/io/type.Result.html 21 | -------------------------------------------------------------------------------- /src-old/primitives/array/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 配列は`T`という単一の型(訳注: [ジェネリック型](https://rust-lang-ja.github.io/the-rust-programming-language-ja/1.6/book/generics.html)でも可)のオブジェクトの集合です。それらのオブジェクトはメモリ上の連続した領域に保存されます。配列は`[]`を用いて生成されます。サイズはコンパイル時には決定されていて、`[T; size]`という形で指定できます。 5 | 6 | 7 | 8 | 9 | 10 | スライスは配列に似ていますが、コンパイル時にサイズが決定されていません。2つの部分からなり、1つは別のデータへのポインタ、もう1つはスライスの長さです。配列の一部を借用するのに使用され`&[T]`という型シグネチャを持ちます。 11 | 12 | {array.play} 13 | -------------------------------------------------------------------------------- /src-old/error/result_map/result.rs: -------------------------------------------------------------------------------- 1 | use std::num::ParseIntError; 2 | 3 | // 返り値の型を書き直し、`unwrap()`を用いないパターンマッチに変更したが、 4 | // まだ少しごちゃごちゃしている。`Option`の場合と同様に 5 | // スッキリさせられないだろうか？答えはYes 6 | fn double_number(number_str: &str) -> Result { 7 | match number_str.parse::() { 8 | Ok(n) => Ok(2 * n), 9 | Err(e) => Err(e), 10 | } 11 | } 12 | 13 | // 上と全く同じ機能を、`map()`を用いて記述する。 14 | // 値がparse可能な時のみその値を変更し、そうでなければエラーを返す。 15 | fn double_number_map(number_str: &str) -> Result { 16 | number_str.parse::().map(|n| 2 * n) 17 | } 18 | 19 | fn print(result: Result) { 20 | match result { 21 | Ok(n) => println!("n is {}", n), 22 | Err(e) => println!("Error: {}", e), 23 | } 24 | } 25 | 26 | fn main() { 27 | // 以前と同様、問題なく想定通りの値を表示する。 28 | let twenty = double_number("10"); 29 | print(twenty); 30 | 31 | // 以前の`panic`の内容よりも遥かに良い。 32 | let tt = double_number_map("t"); 33 | print(tt); 34 | } 35 | -------------------------------------------------------------------------------- /docs/css/print.css: -------------------------------------------------------------------------------- 1 | 2 | #sidebar, 3 | #menu-bar, 4 | .nav-chapters, 5 | .mobile-nav-chapters { 6 | display: none; 7 | } 8 | 9 | #page-wrapper.page-wrapper { 10 | transform: none; 11 | margin-left: 0px; 12 | overflow-y: initial; 13 | } 14 | 15 | #content { 16 | max-width: none; 17 | margin: 0; 18 | padding: 0; 19 | } 20 | 21 | .page { 22 | overflow-y: initial; 23 | } 24 | 25 | code { 26 | background-color: #666666; 27 | border-radius: 5px; 28 | 29 | /* Force background to be printed in Chrome */ 30 | -webkit-print-color-adjust: exact; 31 | } 32 | 33 | pre > .buttons { 34 | z-index: 2; 35 | } 36 | 37 | a, a:visited, a:active, a:hover { 38 | color: #4183c4; 39 | text-decoration: none; 40 | } 41 | 42 | h1, h2, h3, h4, h5, h6 { 43 | page-break-inside: avoid; 44 | page-break-after: avoid; 45 | } 46 | 47 | pre, code { 48 | page-break-inside: avoid; 49 | white-space: pre-wrap; 50 | } 51 | 52 | .fa { 53 | display: none !important; 54 | } 55 | -------------------------------------------------------------------------------- /src-old/flow_control/if_let/input.md: -------------------------------------------------------------------------------- 1 | 2 | 場合によっては`match`を使用すると不自然な書き方になってしまう場合があります。例えば... 3 | 4 | ```rust 5 | // `optional`という変数の型を`Option`に指定 6 | let optional = Some(7); 7 | 8 | match optional { 9 | Some(i) => { 10 | println!("This is a really long string and `{:?}`", i); 11 | // ^ `i`をoption型からデストラクトするためだけに 12 | // インデントが一つ増えてしまっている。 13 | }, 14 | _ => {}, 15 | // ^ `match`は全ての型に対して網羅的でなくてはならないので必要。 16 | // 冗長に見えませんか？ 17 | }; 18 | 19 | ``` 20 | 21 | 22 | 23 | この場合は`if let`を用いたほうが美しく、失敗時の処理も柔軟に行うことができます。 24 | 25 | {if_let.play} 26 | 27 | 30 | ### 参照 31 | 32 | [列挙型][enum], [オプション][option], [RFC][if_let_rfc] 33 | 34 | [enum]: ../custom_types/enum.html 35 | [if_let_rfc]: https://github.com/rust-lang/rfcs/pull/160 36 | [option]: ../std/option.html 37 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Rust By Example 2 | 3 | [Rust by Example](https://github.com/rust-lang/rust-by-example)の和訳リポジトリ [![CircleCI](https://circleci.com/gh/rust-lang-ja/rust-by-example-ja.svg?style=svg)](https://circleci.com/gh/rust-lang-ja/rust-by-example-ja) 4 | 5 | 和訳版は[こちら](https://doc.rust-jp.rs/rust-by-example-ja/)から読めます。 6 | 7 | # ビルド方法 8 | 9 | 安定版（stable版）のRustをインストールしてください。 10 | [rustup](https://www.rustup.rs/)がオススメです。 11 | 12 | ```bash 13 | $ git clone https://github.com/rust-lang-ja/rust-by-example-ja 14 | $ cd rust-by-example-ja 15 | $ cargo install mdbook 16 | $ mdbook build 17 | $ mdbook serve 18 | ``` 19 | 20 | # テスト方法 21 | 22 | ```bash 23 | $ cd rust-by-example-ja 24 | $ cargo install mdbook-transcheck 25 | $ mdbook test 26 | $ git submodule init 27 | $ git submodule update 28 | $ mdbook-transcheck src-en src 29 | ``` 30 | 31 | `mdbook test`はドキュメント内のソースコードがコンパイル可能かどうかを、 32 | `mdbook-transcheck`はコメントアウトされた原文とソースコードがオリジナルと一致するかどうかをテストします。 33 | 34 | # 翻訳の仕方 35 | 36 | [CONTRIBUTING](./CONTRIBUTING.md)を参照してください。 37 | -------------------------------------------------------------------------------- /src-old/meta/doc/doc.rs: -------------------------------------------------------------------------------- 1 | /// あらゆる人物はここに代表されます。 2 | pub struct Person { 3 | /// ジュリエットがどんなに名前というものを嫌っていようと、 4 | /// 人物には名前が必要です。 5 | name: String, 6 | } 7 | 8 | impl Person { 9 | /// 与えられた名前を持つpersonをを返します。 10 | /// 11 | /// # Arguments 12 | /// 13 | /// * `name` - `person`の名前を表す文字列のスライス 14 | /// 15 | /// # Example 16 | /// 17 | /// ``` 18 | /// // バッククォートによってRustのコードをコメント中に挟むこと 19 | /// // もできます。Rustdocに--testを渡せば、テストも行えます！ 20 | /// // (訳注: pythonのdoctestと同じです。) 21 | /// let person = Person::new("name"); 22 | /// ``` 23 | pub fn new(name: &str) -> Person { 24 | Person { 25 | name: name.to_string(), 26 | } 27 | } 28 | 29 | /// フレンドリーに挨拶しましょう！ 30 | /// 31 | /// このメソッドを呼び出した`Person`に対して"Hello, [name]" 32 | /// と話しかけます。 33 | pub fn hello(& self) { 34 | println!("Hello, {}!", self.name); 35 | } 36 | } 37 | 38 | fn main() { 39 | let john = Person::new("John"); 40 | 41 | john.hello(); 42 | } 43 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/explicit/explicit.rs: -------------------------------------------------------------------------------- 1 | // `print_refs`は`i32`への参照を2つとり、それぞれ`'a`と`'b`という 2 | // ライフタイムを持つ。これらのライフタイムは最短でも`print_refs` 3 | // 関数と同じになる。 4 | fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) { 5 | println!("x is {} and y is {}", x, y); 6 | } 7 | 8 | // 引数を取らないがライフタイムパラメータ`'a`を持つ関数。 9 | fn failed_borrow<'a>() { 10 | let _x = 12; 11 | 12 | // エラー: `_x`の寿命が短すぎる。 13 | //let y: &'a i32 = &_x; 14 | // `&_x`のライフタイムは`y`のそれよりも短いため、関数内で`'a`を使用して 15 | // 変数のライフタイムを指定しようとすると失敗する。つまり、短いライフタイム 16 | // を持つ参照をより長いものに強制的に代入することはできない。 17 | } 18 | 19 | fn main() { 20 | // 下で借用するための変数を作成 21 | let (four, nine) = (4, 9); 22 | 23 | // 2つの変数の借用(`&`)が関数に渡される。 24 | print_refs(&four, &nine); 25 | // 借用された変数の寿命は、借り手のそれよりも長くなくてはならない。 26 | // つまり、`four`、`nine`のライフタイムは`print_refs`のそれよりも 27 | // 長くなくてはならない。 28 | 29 | failed_borrow(); 30 | // `failed_borrow`は関数のライフタイムよりも`'a`を長くさせるような 31 | // 参照を持たないが、それでも`'a`のほうが長くなる。なぜならそのような 32 | // 場合`'a`はデフォルトで`'static`になるからである。 33 | } 34 | -------------------------------------------------------------------------------- /src-old/hello/comment/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | あらゆるプログラムにはコメントが必要です。ラストには何種類かのコメントがあります 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | * *通常のコメント* これはコンパイラによって完全に無視されます。 14 | - `// 行末までコメントアウト` 15 | - `/* ブロックによって囲まれた部分をコメントアウト */` 16 | * *ドキュメンテーションコメント* ライブラリのドキュメンテーションとしてhtmlにパースされます。 17 | - `/// このコメントの下の内容に関するドキュメントとなります` 18 | - `//! このコメントを含むソースのドキュメントになります` 19 | 20 | {comment.play} 21 | 22 | 25 | ### 参照 26 | 27 | [ライブラリドキュメンテーション][docs] 28 | 29 | [docs]: ../meta/doc.html 30 | -------------------------------------------------------------------------------- /src-old/std_misc/file/open/open.rs: -------------------------------------------------------------------------------- 1 | use std::error::Error; 2 | use std::fs::File; 3 | use std::io::prelude::*; 4 | use std::path::Path; 5 | 6 | fn main() { 7 | // 目的ファイルに対する`Path`を作成 8 | let path = Path::new("hello.txt"); 9 | let display = path.display(); 10 | 11 | // pathを読み込み専用モードで開く。これは`io::Result`を返す。 12 | let mut file = match File::open(&path) { 13 | // `io::Error`の`description`メソッドはエラーを説明する文字列を返す。 14 | Err(why) => panic!("couldn't open {}: {}", display, 15 | Error::description(&why)), 16 | Ok(file) => file, 17 | }; 18 | 19 | // ファイルの中身を文字列に読み込む。`io::Result`を返す。 20 | let mut s = String::new(); 21 | match file.read_to_string(&mut s) { 22 | Err(why) => panic!("couldn't read {}: {}", display, 23 | Error::description(&why)), 24 | Ok(_) => print!("{} contains:\n{}", display, s), 25 | } 26 | 27 | // `file`がスコープから抜け、"hello.txt"が閉じられる。 28 | } 29 | -------------------------------------------------------------------------------- /src-old/scope/move/input.md: -------------------------------------------------------------------------------- 1 | 5 | 変数には自身の保持する資源を開放する責任があるため、**資源は一度に一つの所有者**しか持つことができません。これはまた、資源を2度以上開放することができないということでもあります。ここで、全ての変数が資源を所有するわけではないということに注意しましょう。(e.g. [参照][references]) 6 | 7 | 10 | 変数をアサインする(`let x = y`)際や、関数に引数を値渡しする(`foo(x)`)際は、資源の*所有権(`ownership`)*が移動します。Rustっぽく言うと、「*ムーブ*」です。 11 | 12 | 14 | 資源を移動すると、それまでの所有者(訳注: 変数などのこと)を使用することはできなくなります。これによりダングリングポインタの発生を防げます。 15 | 16 | {move.play} 17 | 18 | [references]: /flow_control/match/destructuring/destructure_pointers.html 19 | -------------------------------------------------------------------------------- /src-old/std/str/input.md: -------------------------------------------------------------------------------- 1 | 2 | Rustには文字列を扱う型が2つあります。`String`と`&str`です。 3 | 4 | 7 | `String`は有効なUTF-8の配列であることを保証されたバイトのベクタ(`Vec`)として保持されます。ヒープ上に保持され、伸長可能で、末端にnull文字を含みません。 8 | 9 | 11 | `&str`は有効なUTF-8の配列のスライス(`&[u8]`)で、いつでも`String`に変換することができます。`&[T]`がいつでも`Vec`に変換できるのと同様です。 12 | 13 | {str.play} 14 | 15 | 19 | `str`/`String`のメソッドをもっと見たい場合は[std::str][str]、[std::string][string]モジュールを参照してください。 20 | 21 | [str]: http://doc.rust-lang.org/std/str/ 22 | [string]: http://doc.rust-lang.org/std/string/ 23 | -------------------------------------------------------------------------------- /src-old/trait/ops/operator.rs: -------------------------------------------------------------------------------- 1 | use std::ops; 2 | 3 | struct Foo; 4 | struct Bar; 5 | 6 | #[derive(Debug)] 7 | struct FooBar; 8 | 9 | #[derive(Debug)] 10 | struct BarFoo; 11 | 12 | // `std::ops::Add`トレイトは`+`の振る舞いを規定するために使用される 13 | // ここでは`Foo`に対して`Add`を実装する。これは加算時の右辺が`Bar`型 14 | // の時に呼び出されるトレイト。つまり以下は`Foo + Bar = FooBar`という振る舞いを 15 | // もたらす。 16 | impl ops::Add for Foo { 17 | type Output = FooBar; 18 | 19 | fn add(self, _rhs: Bar) -> FooBar { 20 | println!("> Foo.add(Bar) was called"); 21 | 22 | FooBar 23 | } 24 | } 25 | 26 | // 型を反転することで、非可換の加算を実装できる。ここでは`Bar`に対して 27 | // `Add`を実装する。これは加算時の右辺が`Foo`型の時に呼び出されるメソッド。 28 | // つまり以下は`Bar + Foo = BarFoo`という結果をもたらす。 29 | impl ops::Add for Bar { 30 | type Output = BarFoo; 31 | 32 | fn add(self, _rhs: Foo) -> BarFoo { 33 | println!("> Bar.add(Foo) was called"); 34 | 35 | BarFoo 36 | } 37 | } 38 | 39 | fn main() { 40 | println!("Foo + Bar = {:?}", Foo + Bar); 41 | println!("Bar + Foo = {:?}", Bar + Foo); 42 | } 43 | -------------------------------------------------------------------------------- /src-old/fn/closures/closures.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // 関数とクロージャのそれぞれで数値をインクリメントする 3 | fn function (i: i32) -> i32 { i + 1 } 4 | 5 | // 型アノテーションは、通常の関数と同様の方法で行えるが、必須ではない。 6 | // `{}`も必須ではない。 7 | // クロージャは一種の無名関数なので、適切な変数にバインディングしてやるとよい 8 | let closure_annotated = |i: i32| -> i32 { i + 1 }; 9 | let closure_inferred = |i | i + 1 ; 10 | 11 | let i = 1; 12 | 13 | // 関数とクロージャを呼び出す。 14 | println!("function: {}", function(i)); 15 | println!("annotated closure: {}", closure_annotated(i)); 16 | println!("inferred closure: {}", closure_inferred(i)); 17 | 18 | // 返り値の型を推測した結果、`i32`型を返すクロージャ。 19 | // 引数はとらない。 20 | let one = || 1; 21 | println!("closure returning one: {}", one()); 22 | 23 | // クロージャは自身の周囲にある環境の変数を参照することができる。 24 | // 通常の関数では不可能 25 | let professor_x = "Charles Xavier"; 26 | 27 | // 引数をとらず、返り値もないクロージャ。周りの環境にある変数を用いている。 28 | let print = || println!("Professor X's name is: {}", professor_x); 29 | 30 | // クロージャを実行 31 | print(); 32 | } 33 | -------------------------------------------------------------------------------- /src-old/hello/input.md: -------------------------------------------------------------------------------- 1 | 2 | ここでは伝統的な"Hello World!"プログラムのソースを紹介します。　 3 | 4 | {hello.play} 5 | 6 | 7 | 8 | `println!` は文字列をコンソールにプリントするための [*マクロ*][macros]です。 9 | 10 | 11 | バイナリファイルは`rustc`と呼ばれるRustのコンパイラを用いて生成することができます。 12 | 13 | ``` 14 | $ rustc hello.rs 15 | ``` 16 | 17 | 18 | すると`hello`という名前の実行可能なバイナリファイルができます。 19 | 20 | ``` 21 | $ ./hello 22 | Hello World! 23 | ``` 24 | 25 | 26 | ### 演習 27 | 28 | 29 | 30 | 上に書いている'Run'をクリックしてアウトプットを見てみましょう。 31 | 次に、`println!`マクロをもう一行追加してアウトプットがどうなるか見てみましょう。 32 | 33 | shows: 34 | ``` 35 | Hello World! 36 | I'm a Rustacean! 37 | ``` 38 | 39 | [macros]: ./macros.html 40 | -------------------------------------------------------------------------------- /src-old/error/option_with_result/input.md: -------------------------------------------------------------------------------- 1 | 5 | 前項までの例では、`Result`は`Result`と、`Option`は`Option`としか関わらなかったため、非常に扱いやすいものでした。とはいえ、常にこのような扱いやすい場合ばかりではありません。`Option`と`Result`が、あるいは`Result`と`Result`とが関わる場合もあります。 6 | 7 | 9 | 以下は、一方が`Option`を返し、もう一方が`Result`を返すような場合です。`unwrap`が汚いエラーメッセージを返すことを除けば、これは筋の通ったやり方に見えます。 10 | 11 | {option_result.play} 12 | 13 | 16 | ### 参照 17 | 18 | [`Result`][result] 、[`io::Result`][io_result] 19 | 20 | [result]: http://doc.rust-lang.org/std/result/enum.Result.html 21 | [io_result]: http://doc.rust-lang.org/std/io/type.Result.html 22 | -------------------------------------------------------------------------------- /src-old/std/result/input.md: -------------------------------------------------------------------------------- 1 | 5 | これまでの例で、失敗する可能性のある関数の返り値として、列挙型`Option`が使用でき、失敗時の返り値には`None`を用いることを見てきました。しかし、時には**なぜ**そのオペレーションが失敗したのかを明示することが重要な場合があります。そのためには`Result`列挙型を使用します。 6 | 7 | 8 | 列挙型`Result`は2つの値をとりえます。 9 | 10 | 14 | * `Ok(value)` ... これはオペレーションが成功したことを意味し、返り値`value`をラップします。(`value`は型`T`を持ちます。) 15 | * `Err(why)` ... これはオペレーションの失敗を意味します。`why`をラップしており、ここには失敗した理由が(必ずではありませんが)書かれています。(`why`の型は`E`です。) 16 | 17 | {result.play} 18 | -------------------------------------------------------------------------------- /src-old/custom_types/structs/structs.rs: -------------------------------------------------------------------------------- 1 | // ユニット 2 | struct Nil; 3 | 4 | // タプル 5 | struct Pair(i32, f64); 6 | 7 | // 2つのフィールドを持つ（クラシックな）構造体 8 | struct Point { 9 | x: f64, 10 | y: f64, 11 | } 12 | 13 | // 構造体は他の構造体のフィールドになることができる 14 | #[allow(dead_code)] 15 | struct Rectangle { 16 | p1: Point, 17 | p2: Point, 18 | } 19 | 20 | fn main() { 21 | // `Point`型のインスタンスを作成 22 | let point: Point = Point { x: 0.3, y: 0.4 }; 23 | 24 | // pointのフィールドにアクセスする。 25 | println!("point coordinates: ({}, {})", point.x, point.y); 26 | 27 | // `let`を使用してpointをデストラクトする。 28 | let Point { x: my_x, y: my_y } = point; 29 | 30 | let _rectangle = Rectangle { 31 | // 構造体の定義とインスタンスの作成を同時に行う 32 | p1: Point { x: my_y, y: my_x }, 33 | p2: point, 34 | }; 35 | 36 | // ユニットをインスタンス化 37 | let _nil = Nil; 38 | 39 | // タプルをインスタンス化 40 | let pair = Pair(1, 0.1); 41 | 42 | // タプルをデストラクト 43 | let Pair(integer, decimal) = pair; 44 | 45 | println!("pair contains {:?} and {:?}", integer, decimal); 46 | } 47 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/lifetime_bounds/input.md: -------------------------------------------------------------------------------- 1 | 4 | ジェネリック型に境界(bound)を与え、特定のトレイトを実装していることを保証できるのと同様、ライフタイム(それ自身ジェネリック型)にも境界を与えることができます。`:`は、ここでは多少異なる意味を持ちますが`+`は同じです。以下の構文の意味をチェックしてください。 5 | 6 | 9 | 1. `T: 'a`: `T`内の*全ての*参照は`'a`よりも長生きでなくてはならない 10 | 2. `T: Trait + 'a`: 上に加えて`T`は`Trait`という名のトレイトを実装してなくてはならない。 11 | 12 | 13 | 上記の構文を実際に動く例で見ていきましょう。 14 | 15 | {bounds.play} 16 | 17 | 20 | ### 参照 21 | 22 | [ジェネリクス][generics], [ジェネリック境界][bounds], 23 | [境界が複数の場合][multibounds] 24 | 25 | [generics]: /generics.html 26 | [bounds]: /generics/bounds.html 27 | [multibounds]: /generics/multi_bounds.html 28 | -------------------------------------------------------------------------------- /src-old/error/map/input.md: -------------------------------------------------------------------------------- 1 | 4 | `match`は`Option`は扱うのに適したメソッドです。しかし、大量にこれを使用しているとじきに億劫になってくるでしょう。引数の値が有効である(訳注: この場合は`None`でない)必要がある関数を扱う際には特にそうです。 5 | 6 | 8 | `Some -> Some`あるいは`None -> None`の単純な操作を適用する必要がある場合には、`Option`は`map()`というビルトインのメソッドを提供していますので、これを使用しましょう。 9 | 10 | 13 | `map()`のフレキシビリティは、複数の`map()`をチェインしなければならない場合にさらに際立ちます。以下の例では、`process()`が直前の関数全てを用いた場合と同じ機能を、よりコンパクトに果たしているのがわかります。 14 | 15 | {map.play} 16 | 17 | 20 | ### 参照 21 | 22 | [closures][closures] 23 | 24 | [closures]: ../fn/closures.html 25 | -------------------------------------------------------------------------------- /src-old/primitives/array/array.rs: -------------------------------------------------------------------------------- 1 | use std::mem; 2 | 3 | // この関数はスライスを借用する 4 | fn analyze_slice(slice: &[i32]) { 5 | println!("first element of the slice: {}", slice[0]); 6 | println!("the slice has {} elements", slice.len()); 7 | } 8 | 9 | fn main() { 10 | // 固定長の配列（型シグネチャは冗長なので、なくても可） 11 | let xs: [i32; 5] = [1, 2, 3, 4, 5]; 12 | 13 | // すべての要素を0にする場合 14 | let ys: [i32; 500] = [0; 500]; 15 | 16 | // インデックスは０から 17 | println!("first element of the array: {}", xs[0]); 18 | println!("second element of the array: {}", xs[1]); 19 | 20 | // `len`は配列のサイズを返す。 21 | println!("array size: {}", xs.len()); 22 | 23 | // 配列はスタック上に置かれる 24 | println!("array occupies {} bytes", mem::size_of_val(&xs)); 25 | 26 | // 配列は自動的にスライスとして借用される。 27 | println!("borrow the whole array as a slice"); 28 | analyze_slice(&xs); 29 | 30 | // 配列の一部分だけのスライスを渡す 31 | println!("borrow a section of the array as a slice"); 32 | analyze_slice(&ys[1 .. 4]); 33 | 34 | // インデックスの範囲が配列のサイズを超えた場合パニックする 35 | println!("{}", xs[5]); 36 | } 37 | -------------------------------------------------------------------------------- /src/flow_control/loop/nested.md: -------------------------------------------------------------------------------- 1 | 4 | # ネストとラベル 5 | 6 | 11 | ネストしたループを回している時に外側のループを`break`または`continue`したい場合があります。こういった場合には`label`を用いてループにラベルを貼り、`break`/`continue`にそのラベルを渡します。 12 | 13 | ```rust,editable 14 | #![allow(unreachable_code)] 15 | 16 | fn main() { 17 | 'outer: loop { 18 | println!("Entered the outer loop"); 19 | 20 | 'inner: loop { 21 | println!("Entered the inner loop"); 22 | 23 | // This would break only the inner loop 24 | // これは内側のループのみを中断します。 25 | //break; 26 | 27 | // This breaks the outer loop 28 | // こちらは外側を中断します 29 | break 'outer; 30 | } 31 | 32 | println!("This point will never be reached"); 33 | } 34 | 35 | println!("Exited the outer loop"); 36 | } 37 | ``` 38 | -------------------------------------------------------------------------------- /src-old/error/unwrap/unwrap.rs: -------------------------------------------------------------------------------- 1 | // 庶民(commoner)は経験豊富なので、大体どんな状況にも対処できます。 2 | // あらゆる贈り物は`match`を用いて手動で処理されます。 3 | fn give_commoner(gift: Option<&str>) { 4 | // Specify a course of action for each case. 5 | match gift { 6 | Some("snake") => println!("Yuck! I'm throwing that snake in a fire."), 7 | Some(inner) => println!("{}? How nice.", inner), 8 | None => println!("No gift? Oh well."), 9 | } 10 | } 11 | 12 | // 温室育ちのお姫様はヘビを見ると`panic`します。 13 | fn give_princess(gift: Option<&str>) { 14 | // `unwrap`を使用すると値が`None`だった際に`panic`を返します。。 15 | let inside = gift.unwrap(); 16 | if inside == "snake" { panic!("AAAaaaaa!!!!"); } 17 | 18 | println!("I love {}s!!!!!", inside); 19 | } 20 | 21 | fn main() { 22 | let food = Some("chicken"); 23 | let snake = Some("snake"); 24 | let void = None; 25 | 26 | give_commoner(food); 27 | give_commoner(snake); 28 | give_commoner(void); 29 | 30 | let bird = Some("robin"); 31 | let nothing = None; 32 | 33 | give_princess(bird); 34 | give_princess(nothing); 35 | } 36 | -------------------------------------------------------------------------------- /src-old/scope/move/move.rs: -------------------------------------------------------------------------------- 1 | // この関数はヒープメモリ上の資源の所有権を取る。 2 | fn destroy_box(c: Box) { 3 | println!("Destroying a box that contains {}", c); 4 | 5 | // `c`は破棄されメモリは開放される。 6 | } 7 | 8 | fn main() { 9 | // _スタック_上に置かれた整数 10 | let x = 5u32; 11 | 12 | // `x`を`y`に*コピー*する。元の値が移動するわけではない。 13 | let y = x; 14 | 15 | // 両方の値はそれぞれ独立に使うことができる。 16 | println!("x is {}, and y is {}", x, y); 17 | 18 | // `a`は_ヒープ_上の整数へのポインタ 19 | let a = Box::new(5i32); 20 | 21 | println!("a contains: {}", a); 22 | 23 | // `a`を`b`に*ムーブ*する。 24 | let b = a; 25 | // すなわち、`a`の指すメモリ上の番地が`b`にコピーされるため 26 | // いずれもヒープ上の同じ値を指すポインタとなる。しかし所有権は`b`にある。 27 | 28 | // エラー! `a`は所有権を持たないため、ヒープ上のデータにアクセスできない。 29 | //println!("a contains: {}", a); 30 | // TODO ^ 試しにここをアンコメントしてみましょう。 31 | 32 | // この関数はヒープメモリ上の所有権を`b`から取る。 33 | destroy_box(b); 34 | 35 | // この時点でヒープメモリ上の資源は開放されているので、次の操作は解放 36 | // 解放済みメモリをデリファレンスすることになる。しかしそれはコンパイラが許さない。 37 | // エラー! 上述の理由より 38 | //println!("b contains: {}", b); 39 | // TODO ^ 試しにここをアンコメントしてみましょう。 40 | } 41 | -------------------------------------------------------------------------------- /src-old/fn/closures/capture/input.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | クロージャはとてもフレキシブルに動作するように出来ています。クロージャにおいて型アノテーションをする必要が無いのは前述の仕組みのためですが、この仕組みのおかげでユースケースに応じて参照を取得したり値そのものを取得したりといった動作が可能になります。 6 | 7 | クロージャは外側の環境にある要素を、以下の形で取得することができます。 8 | 9 | 10 | 11 | 12 | * リファレンス: `&T` 13 | * ミュータブルなリファレンス: `&mut T` 14 | * 値そのもの: `T` 15 | 16 | 17 | 18 | クロージャは出来る限りリファレンスを取得しようとし、その他2つは必要なときのみ取得します。 19 | 20 | {capture.play} 21 | 22 | 25 | ### 参照 26 | 27 | [`Box`][box] and [`std::mem::drop`][drop] 28 | 29 | [box]: ../../std/box.html 30 | [drop]: http://doc.rust-lang.org/std/mem/fn.drop.html 31 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/fn/fn.rs: -------------------------------------------------------------------------------- 1 | // 引数として`'a`のライフタイムで参照を一つ取る。最低でもこの関数 2 | // と同じだけの長さでなくてはならない。 3 | fn print_one<'a>(x: &'a i32) { 4 | println!("`print_one`: x is {}", x); 5 | } 6 | 7 | // ミュータブルな参照でも同様 8 | fn add_one<'a>(x: &'a mut i32) { 9 | *x += 1; 10 | } 11 | 12 | // 異なるライフタイムを持つ複数の引数がある場合。 13 | // ここでは1種類のライフタイムでも問題はないが、より複雑なケースでは 14 | // 異なるライフタイムが必要になる場合がある。 15 | fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) { 16 | println!("`print_multi`: x is {}, y is {}", x, y); 17 | } 18 | 19 | // 受け取った参照をそのまま返すことに問題はないが、適切なライフタイム 20 | // でなくてはならない。 21 | fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x } 22 | 23 | //fn invalid_output<'a>() -> &'a i32 { &7 } 24 | // `'a`は関数より長くなくてはならないため上の関数は正しくない。 25 | // ここでは、`&7`は`i32`のデータとそれへの参照を作り出す。 26 | // その後データはスコープを抜けるとともに破棄される。そのため、 27 | // 不適切なデータに対する参照を返すことになってしまう。 28 | 29 | fn main() { 30 | let x = 7; 31 | let y = 9; 32 | 33 | print_one(&x); 34 | print_multi(&x, &y); 35 | 36 | let z = pass_x(&x, &y); 37 | print_one(z); 38 | 39 | let mut t = 3; 40 | add_one(&mut t); 41 | print_one(&t); 42 | } 43 | -------------------------------------------------------------------------------- /src-old/fn/hof/hof.rs: -------------------------------------------------------------------------------- 1 | fn is_odd(n: u32) -> bool { 2 | n % 2 == 1 3 | } 4 | 5 | fn main() { 6 | // 1000以下の奇数を2乗した値の合計を求める。 7 | println!("Find the sum of all the squared odd numbers under 1000"); 8 | let upper = 1000; 9 | 10 | // 宣言型プログラミングによるアプローチ 11 | // 値を蓄積する変数を宣言 12 | let mut acc = 0; 13 | // 0から無限までイテレートする 14 | for n in 0.. { 15 | // 値を2乗 16 | let n_squared = n * n; 17 | 18 | if n_squared >= upper { 19 | // 上限に達した場合、ループを終了 20 | break; 21 | } else if is_odd(n_squared) { 22 | // 奇数ならば値を値を足しあわせていく。 23 | acc += n_squared; 24 | } 25 | } 26 | println!("imperative style: {}", acc); 27 | 28 | // 関数型プログラミングによるアプローチ 29 | let sum_of_squared_odd_numbers: u32 = 30 | (0..).map(|n| n * n) // 全自然数を2乗し 31 | .take_while(|&n| n < upper) // そのうち上限より小さい値で 32 | .filter(|n| is_odd(*n)) // かつ奇数のものを 33 | .fold(0, |sum, i| sum + i); // 足し合わせる。 34 | println!("functional style: {}", sum_of_squared_odd_numbers); 35 | } 36 | -------------------------------------------------------------------------------- /src/crates.md: -------------------------------------------------------------------------------- 1 | 4 | # クレート 5 | 6 | 14 | クレートはRustにおけるコンパイルの単位です。`rustc some_file.rs`が呼ばれると、`some_file.rs`は必ず *クレートファイル* として扱われます。もし`some_file.rs`が`mod`宣言を含んでいるのならば、コンパイルの *前に* 、そのモジュールファイルの中身が`mod`の位置に挿入されます。言い換えると、それぞれのモジュールが独立にコンパイルされるということはありませんが、それぞれのクレートは互いに独立にコンパイルされるということです。 15 | 16 | 21 | クレートはバイナリあるいはライブラリ形式でコンパイルされることが可能です。デフォルトでは`rustc`はクレートからバイナリを作り出しますが、この振る舞いは`--crate-type`フラグに`lib`を渡すことでオーバーライドできます。 22 | -------------------------------------------------------------------------------- /src/std_misc/process.md: -------------------------------------------------------------------------------- 1 | 4 | # 子プロセス 5 | 6 | 10 | `process::Output`構造体は終了したプロセスのアウトプットを表し、`process::Command`構造体はプロセスの作成を行います。 11 | 12 | ```rust,editable,ignore 13 | use std::process::Command; 14 | 15 | fn main() { 16 | let output = Command::new("rustc") 17 | .arg("--version") 18 | .output().unwrap_or_else(|e| { 19 | panic!("failed to execute process: {}", e) 20 | }); 21 | 22 | if output.status.success() { 23 | let s = String::from_utf8_lossy(&output.stdout); 24 | 25 | print!("rustc succeeded and stdout was:\n{}", s); 26 | } else { 27 | let s = String::from_utf8_lossy(&output.stderr); 28 | 29 | print!("rustc failed and stderr was:\n{}", s); 30 | } 31 | } 32 | ``` 33 | 34 | 38 | （余裕があれば、上の例で`rustc`に不正なフラグを渡し、どうなるか見てみましょう） 39 | -------------------------------------------------------------------------------- /src-old/error/option_with_result/result_string_errors/input.md: -------------------------------------------------------------------------------- 1 | 5 | 前項の例から`unwrap`を取り除くには(`Result`のみの場合よりも)より多くのケアを必要とします。ここで扱っている型は`Option`と`Result`の２つなので、有効な方法の一つとして、どちらも同じ`Err`型を持つ`Result`にしてしまう、ということが挙げられます。とりあえずは`Err(String)`から始めるのが良さそうに見えますのでこれを用いていきましょう。 6 | 7 | {result_string.play} 8 | 9 | 12 | これはそこまで悪くはないように見えますが、当初のコードに比べるとやはり難があります。問題となるのはこのアプローチの「スケーラビリティ」です。例えば次の例を見てください。 13 | 14 | 17 | ### 参照 18 | 19 | [`Result`][result]、[`io::Result`][io_result] 20 | 21 | [result]: http://doc.rust-lang.org/std/result/enum.Result.html 22 | [io_result]: http://doc.rust-lang.org/std/io/type.Result.html 23 | -------------------------------------------------------------------------------- /src-old/macros/designators/designators.rs: -------------------------------------------------------------------------------- 1 | macro_rules! create_function { 2 | // このマクロは`ident`識別子に対応する値を引数として取り 3 | // `$func_name`という名の関数を作成する。 4 | // `ident`識別子は関数・変数の名前用の識別子である。 5 | ($func_name:ident) => ( 6 | fn $func_name() { 7 | // `stringify!`というマクロは`ident`を文字列に変える。 8 | println!("You called {:?}()", 9 | stringify!($func_name)) 10 | } 11 | ) 12 | } 13 | 14 | // 上のマクロを利用して`foo`、`bar`という名の関数を作成する。 15 | create_function!(foo); 16 | create_function!(bar); 17 | 18 | macro_rules! print_result { 19 | // このマクロは`expr`識別子に対応する値を引数として取り、 20 | // その結果を文字列としてプリントする。 21 | // `expr`識別子は式文に対応する。 22 | ($expression:expr) => ( 23 | // `stringify!`は式文を*そのままの形で*文字列に変換する 24 | println!("{:?} = {:?}", 25 | stringify!($expression), 26 | $expression) 27 | ) 28 | } 29 | 30 | fn main() { 31 | foo(); 32 | bar(); 33 | 34 | print_result!(1u32 + 1); 35 | 36 | // ブロックも式文の一種であることを思い出しましょう! 37 | print_result!({ 38 | let x = 1u32; 39 | 40 | x * x + 2 * x - 1 41 | }); 42 | } 43 | -------------------------------------------------------------------------------- /src/custom_types/enum/c_like.md: -------------------------------------------------------------------------------- 1 | 4 | # C言語ライクな列挙型 5 | 6 | 9 | 列挙型はC言語の列挙型のような使い方をする事もできます。 10 | 11 | ```rust,editable 12 | // An attribute to hide warnings for unused code. 13 | // 使用されていないコードによる警告を抑えるアトリビュート 14 | #![allow(dead_code)] 15 | 16 | // enum with implicit discriminator (starts at 0) 17 | // 値を明示しない場合、0から整数が順に入る。 18 | enum Number { 19 | Zero, 20 | One, 21 | Two, 22 | } 23 | 24 | // enum with explicit discriminator 25 | // 値を明示する場合 26 | enum Color { 27 | Red = 0xff0000, 28 | Green = 0x00ff00, 29 | Blue = 0x0000ff, 30 | } 31 | 32 | fn main() { 33 | // `enums` can be cast as integers. 34 | // 列挙型の中身を整数としてキャストする。 35 | println!("zero is {}", Number::Zero as i32); 36 | println!("one is {}", Number::One as i32); 37 | 38 | println!("roses are #{:06x}", Color::Red as i32); 39 | println!("violets are #{:06x}", Color::Blue as i32); 40 | } 41 | ``` 42 | 43 | 46 | ### 参照 47 | 48 | 51 | [キャスト][cast] 52 | 53 | [cast]: ../../types/cast.md 54 | -------------------------------------------------------------------------------- /src/attribute/unused.md: -------------------------------------------------------------------------------- 1 | # `dead_code` 2 | 3 | 8 | コンパイラは`dead_code`と呼ばれる[リント][lint]機能を持つため、使用されていない関数が存在するときに警告を出します。 *アトリビュート* によってこの機能を無効化することができます。 9 | 10 | ```rust,editable 11 | fn used_function() {} 12 | 13 | // `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint 14 | // `#[allow(dead_code)]`は`dead_code`リントを抑制するアトリビュートです。 15 | #[allow(dead_code)] 16 | fn unused_function() {} 17 | 18 | fn noisy_unused_function() {} 19 | // FIXME ^ Add an attribute to suppress the warning 20 | // FIXME ^ 警告を抑制するアトリビュートを追加しましょう。 21 | 22 | fn main() { 23 | used_function(); 24 | } 25 | ``` 26 | 27 | 32 | 実際のコード中では、使用されていないコードが有る場合はそれを除外するべきです。この文書中では随所でアトリビュートによって警告を抑制していますが、それはあくまでインタラクティブな例を皆さんに提供するためです。 33 | 34 | [lint]: https://en.wikipedia.org/wiki/Lint_%28software%29 35 | -------------------------------------------------------------------------------- /src/variable_bindings/freeze.md: -------------------------------------------------------------------------------- 1 | 4 | # 値の凍結 5 | 6 | 10 | データを同じ名前のイミュータブルな変数に束縛しなおすと、データは*凍結*されます。*凍結*したデータは、イミュータブルな束縛がスコープ外になるまで変更できません。 11 | 12 | ```rust,editable,ignore,mdbook-runnable 13 | fn main() { 14 | let mut _mutable_integer = 7i32; 15 | 16 | { 17 | // Shadowing by immutable `_mutable_integer` 18 | // イミュータブルな`_mutable_integer`でシャドーイングする 19 | let _mutable_integer = _mutable_integer; 20 | 21 | // Error! `_mutable_integer` is frozen in this scope 22 | // エラー! `_mutable_integer`はこのスコープでは凍結している。 23 | _mutable_integer = 50; 24 | // FIXME ^ Comment out this line 25 | // FIXME ^ この行をコメントアウトしましょう。 26 | 27 | // `_mutable_integer` goes out of scope 28 | // `_mutable_integer`はスコープを抜ける 29 | } 30 | 31 | // Ok! `_mutable_integer` is not frozen in this scope 32 | // OK! `_mutable_integer`はこのスコープでは凍結していない。 33 | _mutable_integer = 3; 34 | } 35 | ``` 36 | -------------------------------------------------------------------------------- /src-old/trait/iter/input.md: -------------------------------------------------------------------------------- 1 | 2 | `Iterator`トレイトは、例えば配列のような、要素の集合に対してイテレータを実装するためのトレイトです。 3 | 4 | 7 | このトレイトは`next`の要素に相当するものを決定するためのメソッドのみを要求します。このメソッドは`impl`ブロック内で手動で実装するか、あるいは(配列やrangeのように)自動で定義されます。 8 | 9 | 11 | サッとイテレータを使いたい時は、`for`文で集合からイテレータを作成することが良くあります。これは[`.into_iterator()`][intoiter]メソッドを呼び出しています。 12 | 13 | 15 | `Iterator`トレイトからアクセスできるメソッドの一覧は[ここ][iter]にあります。以下の例ではその一部を使用しています。 16 | 17 | {iter.play} 18 | 19 | [intoiter]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html 20 | [iter]: http://doc.rust-lang.org/core/iter/trait.Iterator.html 21 | -------------------------------------------------------------------------------- /src/crates/lib.md: -------------------------------------------------------------------------------- 1 | 4 | # ライブラリ 5 | 6 | 9 | ではライブラリを作成し、それを別のクレートにリンクする方法を見ていきましょう。 10 | 11 | In `rary.rs`: 12 | 13 | ```rust,ignore 14 | pub fn public_function() { 15 | println!("called rary's `public_function()`"); 16 | } 17 | 18 | fn private_function() { 19 | println!("called rary's `private_function()`"); 20 | } 21 | 22 | pub fn indirect_access() { 23 | print!("called rary's `indirect_access()`, that\n> "); 24 | 25 | private_function(); 26 | } 27 | ``` 28 | 29 | ```shell 30 | $ rustc --crate-type=lib rary.rs 31 | $ ls lib* 32 | library.rlib 33 | ``` 34 | 35 | 41 | ライブラリは「lib」が頭につき、デフォルトでは、その後ろに元となったクレートファイル名をつけます。（訳注: ここでは`lib` + `rary`）この振る舞いは[`crate_name`アトリビュート][crate-name]を用いてオーバーライドできます。 42 | 43 | [crate-name]: ../attribute/crate.md 44 | -------------------------------------------------------------------------------- /src-old/fn/closures/input_functions/input.md: -------------------------------------------------------------------------------- 1 | 5 | これまで、クロージャを引数として渡せることを見てきました。すると次の疑問が浮かんできます 6 | 7 | 「クロージャではない普通の関数を引数として渡すことは可能なのだろうか?」 8 | 9 | 可能です!とはいえ、通常の関数は*絶対に*周辺の変数を補足することができないので、クロージャの方がより柔軟な使い方ができます。ここから、クロージャを引数としてとる関数は、必ず通常の関数を引数としてとることができます。 10 | 11 | {input_functions.play} 12 | 13 | 15 | クロージャによる変数の補足がどのように行われているかを詳しく見たいときは`Fn`、`FnMut`、`FnOnce`を参照してください。 16 | 17 | 20 | ### 参照 21 | 22 | [`Fn`][fn], [`FnMut`][fn_mut], and [`FnOnce`][fn_once] 23 | 24 | [fn]: http://doc.rust-lang.org/std/ops/trait.Fn.html 25 | [fn_mut]: http://doc.rust-lang.org/std/ops/trait.FnMut.html 26 | [fn_once]: http://doc.rust-lang.org/std/ops/trait.FnOnce.html 27 | -------------------------------------------------------------------------------- /src-old/generics/bounds/bounds.rs: -------------------------------------------------------------------------------- 1 | // プリント時のマーカー`{:?}`を実装するトレイト 2 | use std::fmt::Debug; 3 | 4 | trait HasArea { 5 | fn area(&self) -> f64; 6 | } 7 | 8 | impl HasArea for Rectangle { 9 | fn area(&self) -> f64 { self.length * self.height } 10 | } 11 | 12 | #[derive(Debug)] 13 | struct Rectangle { length: f64, height: f64 } 14 | #[allow(dead_code)] 15 | struct Triangle { length: f64, height: f64 } 16 | 17 | // ジェネリック型`T`は`Debug`トレイトを実装していなくてはならない。 18 | // その限りにおいて、`T`がどのような具象型であろうとも次の関数は動作する。 19 | fn print_debug(t: &T) { 20 | println!("{:?}", t); 21 | } 22 | 23 | // 「`T`は`HasArea`を実装していなくてはならない」という境界条件を 24 | // 満たしていれば、`HasArea`の関数`area`にアクセスできる。 25 | fn area(t: &T) -> f64 { t.area() } 26 | 27 | fn main() { 28 | let rectangle = Rectangle { length: 3.0, height: 4.0 }; 29 | let _triangle = Triangle { length: 3.0, height: 4.0 }; 30 | 31 | print_debug(&rectangle); 32 | println!("Area: {}", area(&rectangle)); 33 | 34 | //print_debug(&_triangle); 35 | //println!("Area: {}", area(&_triangle)); 36 | // ^ TODO: これらの行をアンコメントしてみましょう。 37 | // | Error: `Debug` も `HasArea`もどちらも実装されていません! 38 | } 39 | -------------------------------------------------------------------------------- /src/flow_control/loop.md: -------------------------------------------------------------------------------- 1 | # loop 2 | 3 | 6 | Rustには`loop`というキーワードが存在します。これは無限ループを作成するのに使用します。 7 | 8 | > 訳注: `while True`と同じですが、ループのたびに条件を確認しないため、若干高速になります。 9 | 10 | 15 | ループから抜けだす時は`break`, 即座に次のループに移るときは`continue`が使用できます。 16 | 17 | ```rust,editable 18 | fn main() { 19 | let mut count = 0u32; 20 | 21 | println!("Let's count until infinity!"); 22 | 23 | // Infinite loop 24 | // 無限ループ 25 | loop { 26 | count += 1; 27 | 28 | if count == 3 { 29 | println!("three"); 30 | 31 | // Skip the rest of this iteration 32 | // 残りの処理をスキップ 33 | continue; 34 | } 35 | 36 | println!("{}", count); 37 | 38 | if count == 5 { 39 | println!("OK, that's enough"); 40 | 41 | // Exit this loop 42 | // ループを抜ける。 43 | break; 44 | } 45 | } 46 | } 47 | ``` 48 | -------------------------------------------------------------------------------- /src-old/generics/gen_fn/fn.rs: -------------------------------------------------------------------------------- 1 | struct A; // 具象型`A`. 2 | struct S(A); // 具象型`S`. 3 | struct SGen(T); // ジェネリック型`SGen`. 4 | 5 | // 以下の関数は全て変数の所有権をとった後すぐにスコープを抜けて 6 | // 変数をメモリ上から開放する。 7 | 8 | // `S`という型の引数`_s`をとる`reg_fn`という関数を定義 9 | // ``がないのでジェネリック関数ではない 10 | fn reg_fn(_s: S) {} 11 | 12 | // `gen_spec_t`という関数を定義。これは`A`という型を与えられた`Sgen` 13 | // という型の引数`_s`を取る。関数名の直後に``という型パラメータでAが 14 | // ジェネリックであることを明示していないので、この関数はAをジェネリック型 15 | // としては取らない 16 | fn gen_spec_t(_s: SGen) {} 17 | 18 | // `gen_spec_i32`という関数を定義。 19 | // これは明示的な型パラメータとして`i32`を与えられた`Sgen`型の引数`_s`をとる 20 | // この関数もジェネリックではない 21 | fn gen_spec_i32(_s: SGen) {} 22 | 23 | // `generic`という関数を定義。`SGen`という型の引数`_s`を取る。``が`SGen`に 24 | // 先行しているため、これはTに対してジェネリックな関数 25 | fn generic(_s: SGen) {} 26 | 27 | fn main() { 28 | // ジェネリックでない関数を使用する 29 | reg_fn(S(A)); // 具象型 30 | gen_spec_t(SGen(A)); // 型パラメータ`A`を暗黙のうちに受け取る 31 | gen_spec_i32(SGen(6)); // 型パラメータ`i32`を暗黙のうちに受け取る 32 | 33 | // 型パラメータ`char`を明示的に`generic()`に渡す 34 | generic::(SGen('a')); 35 | 36 | // 型パラメータ`char`を暗黙的に`generic()`に渡す 37 | generic(SGen('c')); 38 | } 39 | 40 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Copyright (c) 2014-2020 The Rust Project Developers 2 | 3 | Permission is hereby granted, free of charge, to any 4 | person obtaining a copy of this software and associated 5 | documentation files (the "Software"), to deal in the 6 | Software without restriction, including without 7 | limitation the rights to use, copy, modify, merge, 8 | publish, distribute, sublicense, and/or sell copies of 9 | the Software, and to permit persons to whom the Software 10 | is furnished to do so, subject to the following 11 | conditions: 12 | 13 | The above copyright notice and this permission notice 14 | shall be included in all copies or substantial portions 15 | of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 18 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 19 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 20 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 21 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 22 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 24 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 25 | DEALINGS IN THE SOFTWARE. 26 | -------------------------------------------------------------------------------- /src-old/flow_control/if_let/if_let.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // 全て`Option`型 3 | let number = Some(7); 4 | let letter: Option = None; 5 | let emoticon: Option = None; 6 | 7 | // `if let`文は以下と同じ意味. 8 | // 9 | // もしletがnumberをデストラクトした結果が`Some(i)`になるならば 10 | // ブロック内(`{}`)を実行する。 11 | if let Some(i) = number { 12 | println!("Matched {:?}!", i); 13 | } 14 | 15 | // デストラクトした結果が`Some()`にならない場合の処理を明示したい場合、 16 | // `else`を使用する。 17 | if let Some(i) = letter { 18 | println!("Matched {:?}!", i); 19 | } else { 20 | // デストラクト失敗の場合。このブロック内を実行 21 | println!("Didn't match a number. Let's go with a letter!"); 22 | }; 23 | 24 | // デストラクト失敗時の処理を更に分岐させることもできる 25 | let i_like_letters = false; 26 | 27 | if let Some(i) = emoticon { 28 | println!("Matched {:?}!", i); 29 | // デストラクト失敗。`else if`を評価し、処理をさらに分岐させる。 30 | } else if i_like_letters { 31 | println!("Didn't match a number. Let's go with a letter!"); 32 | } else { 33 | // 今回は`else if`の評価がfalseなので、このブロック内がデフォルト 34 | println!("I don't like letters. Let's go with an emoticon :)!"); 35 | }; 36 | } 37 | -------------------------------------------------------------------------------- /src-old/trait/ops/input.md: -------------------------------------------------------------------------------- 1 | 6 | Rustでは、多くの演算子はトレイトによってオーバーロードすることができます。つまり、一部の演算子は引数となる値の型に応じて異なる役割を果たすことができるということです。これが可能なのは、演算子が実際にはメソッド呼び出しの糖衣構文にすぎないからです。例えば`a + b`における`+`演算子は`add`メソッドを(`a.add(b)`の形で)呼び出します。この`add`メソッドは`Add`トレイトの一部です。それ故、`+`は`Add`トレイトを実装している全ての型に対して有効なのです。 7 | 8 | 9 | `Add`などの、演算子をオーバーロードするトレイトの一覧は[ここ][ops]にあります。 10 | 11 | {operator.play} 12 | 13 | ###See Also 14 | 15 | [Add][add], [構文の索引][syntax] 16 | 17 | [add]: http://doc.rust-lang.org/core/ops/trait.Add.html 18 | [ops]: http://doc.rust-lang.org/core/ops/ 19 | [syntax]: https://rust-lang-ja.github.io/the-rust-programming-language-ja/1.6/book/syntax-index.html 20 | -------------------------------------------------------------------------------- /src-old/std/hash/hashset/hashset.rs: -------------------------------------------------------------------------------- 1 | use std::collections::HashSet; 2 | 3 | fn main() { 4 | let mut a: HashSet = vec!(1i32, 2, 3).into_iter().collect(); 5 | let mut b: HashSet = vec!(2i32, 3, 4).into_iter().collect(); 6 | 7 | assert!(a.insert(4)); 8 | assert!(a.contains(&4)); 9 | 10 | // 既に存在する値を追加しようとすると 11 | // `HashSet::insert()`はfalseを返す。 12 | assert!(b.insert(4), "Value 4 is already in set B!"); 13 | // FIXME ^ この行をコメントアウトしましょう。 14 | 15 | b.insert(5); 16 | 17 | // 集合の要素が、`Debug`を実装している型の場合、 18 | // 集合そのものも`Debug`を実装する。 19 | // 通常は`[elem1, elem2, ...]`のように要素をプリントする。 20 | println!("A: {:?}", a); 21 | println!("B: {:?}", b); 22 | 23 | // [1, 2, 3, 4, 5]を順不同にプリント 24 | println!("Union: {:?}", a.union(&b).collect::>()); 25 | 26 | // これは[1]をプリント 27 | println!("Difference: {:?}", a.difference(&b).collect::>()); 28 | 29 | // [2, 3, 4]を順不同にプリント 30 | println!("Intersection: {:?}", a.intersection(&b).collect::>()); 31 | 32 | // [1, 5]をプリント 33 | println!("Symmetric Difference: {:?}", 34 | a.symmetric_difference(&b).collect::>()); 35 | } 36 | 37 | -------------------------------------------------------------------------------- /src/generics/multi_bounds.md: -------------------------------------------------------------------------------- 1 | 4 | # 複数のジェネリック境界 5 | 6 | 10 | `+`を用いて1つの型に複数のトレイト境界を設けることができます。複数の引数を受け取るときは、通常時と同様、`,`で区切ります。 11 | 12 | ```rust,editable 13 | use std::fmt::{Debug, Display}; 14 | 15 | fn compare_prints(t: &T) { 16 | println!("Debug: `{:?}`", t); 17 | println!("Display: `{}`", t); 18 | } 19 | 20 | fn compare_types(t: &T, u: &U) { 21 | println!("t: `{:?}`", t); 22 | println!("u: `{:?}`", u); 23 | } 24 | 25 | fn main() { 26 | let string = "words"; 27 | let array = [1, 2, 3]; 28 | let vec = vec![1, 2, 3]; 29 | 30 | compare_prints(&string); 31 | //compare_prints(&array); 32 | // TODO ^ Try uncommenting this. 33 | // TODO ^ ここをアンコメントしてみましょう。 34 | 35 | compare_types(&array, &vec); 36 | } 37 | ``` 38 | 39 | 42 | ### 参照 43 | 44 | 47 | [`std::fmt`][fmt], [トレイト][traits] 48 | 49 | [fmt]: ../hello/print.md 50 | [traits]: ../trait.md 51 | -------------------------------------------------------------------------------- /src-old/error/option_with_result/result_string_errors/result_string.rs: -------------------------------------------------------------------------------- 1 | type Result = std::result::Result; 2 | 3 | fn double_first(vec: Vec<&str>) -> Result { 4 | vec.first() 5 | // `Option`が値を持つ場合`Result`に変換する。 6 | // `None`の場合、引数として与えた以下の文字列を持つ`Err`となる。 7 | .ok_or("Please use a vector with at least one element.".to_owned()) 8 | // `parse`は`Result`を返す。 9 | .and_then(|s| s.parse::() 10 | // 返り値の型は`Result`なので、`parse` 11 | // により生じたエラーにのみmapを行い、`String`に変換する 12 | .map_err(|e| e.to_string()) 13 | // 中の値を２倍する 14 | .map(|i| 2 * i)) 15 | } 16 | 17 | fn print(result: Result) { 18 | match result { 19 | Ok(n) => println!("The first doubled is {}", n), 20 | Err(e) => println!("Error: {}", e), 21 | } 22 | } 23 | 24 | fn main() { 25 | let numbers = vec!["93", "18"]; 26 | let empty = vec![]; 27 | let strings = vec!["tofu", "93", "18"]; 28 | 29 | print(double_first(numbers)); 30 | print(double_first(empty)); 31 | print(double_first(strings)); 32 | } 33 | -------------------------------------------------------------------------------- /src-old/std/option/option.rs: -------------------------------------------------------------------------------- 1 | // `panic!`を起こさない整数の割り算 2 | fn checked_division(dividend: i32, divisor: i32) -> Option { 3 | if divisor == 0 { 4 | // 失敗は`None`としてあらわされる。 5 | None 6 | } else { 7 | // 結果は`Some`にラップされる。 8 | Some(dividend / divisor) 9 | } 10 | } 11 | 12 | // この関数は失敗する割り算を扱うことができる 13 | fn try_division(dividend: i32, divisor: i32) { 14 | // `Option` の値は、他のあらゆる列挙型と同様パターンマッチに使用できる。 15 | match checked_division(dividend, divisor) { 16 | None => println!("{} / {} failed!", dividend, divisor), 17 | Some(quotient) => { 18 | println!("{} / {} = {}", dividend, divisor, quotient) 19 | }, 20 | } 21 | } 22 | 23 | fn main() { 24 | try_division(4, 2); 25 | try_division(1, 0); 26 | 27 | // `None`を変数にアサインする際は、型を明示しなくてはならない。 28 | let none: Option = None; 29 | let _equivalent_none = None::; 30 | 31 | let optional_float = Some(0f32); 32 | 33 | // `Some`をアンラップすると中の値を取得できる。 34 | println!("{:?} unwraps to {:?}", optional_float, optional_float.unwrap()); 35 | 36 | // `None`をアンラップしようとすると`panic!` 37 | println!("{:?} unwraps to {:?}", none, none.unwrap()); 38 | } 39 | -------------------------------------------------------------------------------- /src-old/error/result_alias/input.md: -------------------------------------------------------------------------------- 1 | 4 | 特定の`Result`型が何度も何度も使用されると何が起きるでしょう？正解は「型名を書き下すのがすぐに面倒になる」です。このような場合は特定の`Result`のジェネリックエイリアスを定義すると吉です。 5 | 6 | {alias.play} 7 | 8 | 11 | これはモジュールのレベルでは特に役立ちます。というのも特定のモジュールで見つかるエラーは同じ`Err`型(そのモジュール内の**全ての**`Result`を完結に表現する唯一のエイリアス)を持つ可能性があるからです。これは本当に有用なので標準ライブラリ内にもその例があります。IOエラー全般を代表する`io::Result`です。 12 | 13 | > 訳注: ピンと来ない方は[Python プログラマーのための Rust 入門](http://qiita.com/t2y/items/434854fab16159a7c0f7)が参考になるかもしれません。 14 | 15 | 18 | ### 参照 19 | 20 | [`Result`][result]、[`io::Result`][io_result] 21 | 22 | [result]: http://doc.rust-lang.org/std/result/enum.Result.html 23 | [io_result]: http://doc.rust-lang.org/std/io/type.Result.html 24 | -------------------------------------------------------------------------------- /src-old/generics/phantom/input.md: -------------------------------------------------------------------------------- 1 | 3 | 幽霊型(Phantom Type)とは実行時には存在しないけれども、コンパイル時に静的に型チェックされるような型のことです。 4 | 5 | 8 | 構造体などのデータ型は、ジェネリック型パラメータを一つ余分に持ち、それをマーカーとして使ったりコンパイル時の型検査に使ったりすることができます。このマーカーは実際の値を何も持たず、したがって実行時の挙動そのものにはいかなる影響ももたらしません。 9 | 10 | 13 | 以下の例では、そのようなマーカーとして幽霊型([std::marker::PhantomData])を用い、それぞれ異なった型の値を持つタプルを作成します。 14 | 15 | {phantom.play} 16 | 17 | 20 | ### 参照 21 | 22 | [継承(`Derive`)][Derive], [構造体][struct], [タプル][TupleStructs] 23 | 24 | [Derive]: ../trait/derive.html 25 | [struct]: ../custom_types/structs.html 26 | [TupleStructs]: ../custom_types/structs.html 27 | [std::marker::PhantomData]: https://doc.rust-lang.org/std/marker/struct.PhantomData.html 28 | -------------------------------------------------------------------------------- /src-old/trait/derive/derive.rs: -------------------------------------------------------------------------------- 1 | // `Centimeters`は比較可能なタプルになる 2 | #[derive(PartialEq, PartialOrd)] 3 | struct Centimeters(f64); 4 | 5 | // `Inches`はプリント可能なタプルになる 6 | #[derive(Debug)] 7 | struct Inches(i32); 8 | 9 | impl Inches { 10 | fn to_centimeters(&self) -> Centimeters { 11 | let &Inches(inches) = self; 12 | 13 | Centimeters(inches as f64 * 2.54) 14 | } 15 | } 16 | 17 | // `Seconds`には特にアトリビュートを付け加えない。 18 | struct Seconds(i32); 19 | 20 | fn main() { 21 | let _one_second = Seconds(1); 22 | 23 | // エラー: `Seconds`はプリントできない。これは`Debug`トレイトを実装していないため 24 | //println!("One second looks like: {:?}", _one_second); 25 | // TODO ^ この行をアンコメントしてみましょう。 26 | 27 | // エラー: `Seconds`は比較できない。これは`PartialEq`トレイトを実装していないため 28 | //let _this_is_true = (_one_second == _one_second); 29 | // TODO ^ この行をアンコメントしてみましょう 30 | 31 | let foot = Inches(12); 32 | 33 | println!("One foot equals {:?}", foot); 34 | 35 | let meter = Centimeters(100.0); 36 | 37 | let cmp = 38 | if foot.to_centimeters() < meter { 39 | "smaller" 40 | } else { 41 | "bigger" 42 | }; 43 | 44 | println!("One foot is {} than one meter.", cmp); 45 | } 46 | -------------------------------------------------------------------------------- /src-old/generics/assoc_items/types/input.md: -------------------------------------------------------------------------------- 1 | 4 | 関連型を使用すると、コンテナ型の中の要素をトレイトの中に*出力型*として書くことで、全体の可読性を上げることができます。トレイトを定義する際の構文は以下のようになります。 5 | 6 | ```rust 7 | // `A`と`B`は`type`キーワードを用いてトレイト内で宣言されている。 8 | // (注意: この文脈で使用する`type`は型エイリアスを宣言する際の`type`とは 9 | // 異なることに注意しましょう。) 10 | trait Contains { 11 | type A; 12 | type B; 13 | 14 | // これらの新しい型をジェネリックに使用するために、構文が 15 | // アップデートされています。 16 | fn contains(&self, &Self::A, &Self::B) -> bool; 17 | } 18 | ``` 19 | 20 | 22 | `Contains`トレイトを使用する関数において、`A`と`B`を明示する必要がなくなっていることに注目しましょう。 23 | 24 | ```rust 25 | // 関連型を使用しない場合 26 | fn difference(container: &C) -> i32 where 27 | C: Contains { ... } 28 | 29 | // 使用する場合 30 | fn difference(container: &C) -> i32 { ... } 31 | ``` 32 | 33 | 34 | 前セクションの例を関連型を使用して書きなおしてみましょう。 35 | 36 | {types.play} 37 | -------------------------------------------------------------------------------- /tools/circleci/push-to-master.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | # This script pushes the contents of `./docs` directory to 4 | # `origin/master` branch. 5 | # 6 | # Requirements: 7 | # - CI must be configured with write access to the git remote `origin`. 8 | # - The current directory must be the top directory of the CircleCI 9 | # project. 10 | # - The current git branch must be `master` branch. (See circle.yml's 11 | # deployment -> branch) 12 | 13 | set -e 14 | 15 | if [ "x_$CIRCLE_BRANCH" != "x_master" ]; then 16 | echo "This commit was made against the $CIRCLE_BRANCH and not the master. Aborting." 17 | exit 4 18 | fi 19 | 20 | # Get the revision of this branch (master branch) 21 | REVISION=$(git rev-parse --short HEAD) 22 | 23 | cp -p ./patches/404.md ./docs/ 24 | 25 | # If there are anything to commit, do `git commit` and `git push` 26 | # -f flag is needed as docs is listed in .gitignore 27 | git add -f docs 28 | set +e 29 | ret=$(git status | grep -q 'nothing to commit'; echo $?) 30 | set -e 31 | if [ $ret -eq 0 ] ; then 32 | echo "Nothing to push to master." 33 | else 34 | git commit -m "ci: generate pages at ${REVISION} [ci skip]" 35 | echo "Pushing to master." 36 | git push origin master 37 | fi 38 | -------------------------------------------------------------------------------- /src/crates/link.md: -------------------------------------------------------------------------------- 1 | # `extern crate` 2 | 3 | 9 | クレートをこの新しいライブラリにリンクするには、`extern crate`宣言を使用する必要があります。これはライブラリをリンクするだけでなく、その要素を全てライブラリと同じ名前のモジュールにインポートします。モジュールにおけるパブリック・プライベートなどのスコープのルールは全て、ライブラリにおいても当てはまります。 10 | 11 | ```rust,ignore 12 | // Link to `library`, import items under the `rary` module 13 | // `library`にリンクし、`rary`モジュール内の要素を全てインポートする。 14 | extern crate rary; 15 | 16 | fn main() { 17 | rary::public_function(); 18 | 19 | // Error! `private_function` is private 20 | // エラー！`private_function`はプライベート 21 | //rary::private_function(); 22 | 23 | rary::indirect_access(); 24 | } 25 | ``` 26 | 27 | ```txt 28 | # Where library.rlib is the path to the compiled library, assumed that it's 29 | # in the same directory here: 30 | $ rustc executable.rs --extern rary=library.rlib && ./executable 31 | called rary's `public_function()` 32 | called rary's `indirect_access()`, that 33 | > called rary's `private_function()` 34 | ``` 35 | -------------------------------------------------------------------------------- /src-old/std/hash/input.md: -------------------------------------------------------------------------------- 1 | 5 | ベクタ型が値を整数のインデックスで保持するのに対し、`HashMap`ではキーで保持します。`HashMap`のキーはブーリアン、整数、文字列等の`Eq`あるいは`Hash`トレイトを保持する型なら何でもOKです。後でより詳しく見ていきます。 6 | 7 | 12 | ベクタ型と同様、伸長可能ですが、`HashMap`の場合さらに、スペースが余っているときには小さくすることも可能です。`HashMap`を一定の容量のエリアに作成するときは`HashMap::with_capacity(uint)`を、デフォルトの容量で作成するときは`HashMap::new()`を用います。後者が推奨されています。 13 | 14 | {hash.play} 15 | 16 | 19 | ハッシングやハッシュマップ(ハッシュテーブルと呼ばれることもあります)の仕組みについて、より詳しく知りたい場合は[Wikipediaのハッシュテーブルのページ][wiki-hash]を見てください。 20 | 21 | [wiki-hash]: http://en.wikipedia.org/wiki/Hash_table 22 | -------------------------------------------------------------------------------- /src-old/scope/lifetime/lifetime.rs: -------------------------------------------------------------------------------- 1 | // 以下では、変数の作成から破棄までのライフタイムを線で示しています。 2 | // `i`は最長のライフタイムを持ち、そのスコープは`borrow1`および`borrow2` 3 | // のスコープを完全に包含します。`borrow1`と`borrow2`の存続期間は一切重なりません。 4 | fn main() { 5 | let i = 3; // `i`のライフタイムが開始 ────────────────┐ 6 | // │ 7 | { // │ 8 | let borrow1 = &i; // `borrow1`のライフタイム開始 ──┐│ 9 | // ││ 10 | println!("borrow1: {}", borrow1); // ││ 11 | } // `borrow1`が終了 ──────────────────────────────────┘│ 12 | // │ 13 | // │ 14 | { // │ 15 | let borrow2 = &i; // `borrow2`のライフタイム開始 ──┐│ 16 | // ││ 17 | println!("borrow2: {}", borrow2); // ││ 18 | } // `borrow2`が終了 ─────────────────────────────────┘│ 19 | // │ 20 | } // ライフタイムの終了 ─────────────────────────────────────┘ 21 | -------------------------------------------------------------------------------- /src-old/trait/clone/clone.rs: -------------------------------------------------------------------------------- 1 | // いかなる資源も持たない構造体 2 | #[derive(Debug, Clone, Copy)] 3 | struct Nil; 4 | 5 | // `Clone`トレイトを実装する型の変数を資源として持つタプル 6 | #[derive(Clone, Debug)] 7 | struct Pair(Box, Box); 8 | 9 | fn main() { 10 | // `Nil`のインスタンスを作成 11 | let nil = Nil; 12 | // `Nil`をコピー、移動させる資源は存在しない 13 | let copied_nil = nil; 14 | 15 | // いずれの`Nil`も独立に使用できる。 16 | println!("original: {:?}", nil); 17 | println!("copy: {:?}", copied_nil); 18 | 19 | // `Pair`のインスタンスを作成 20 | let pair = Pair(Box::new(1), Box::new(2)); 21 | println!("original: {:?}", pair); 22 | 23 | // `pair`を`moved_pair`にコピー、資源は移動(`move`)する。 24 | let moved_pair = pair; 25 | println!("copy: {:?}", moved_pair); 26 | 27 | // エラー! `pair`は資源を失っている。 28 | //println!("original: {:?}", pair); 29 | // TODO ^ この行をアンコメントしてみましょう。 30 | 31 | // `moved_pair`を`cloned_pair`にクローンする。(資源もクローンされる。) 32 | let cloned_pair = moved_pair.clone(); 33 | // std::mem::dropを用いて元のpairをドロップする 34 | drop(moved_pair); 35 | 36 | // エラー! `moved_pair`はドロップされている。 37 | //println!("copy: {:?}", moved_pair); 38 | // TODO ^ この行をアンコメントしてみましょう。 39 | 40 | // .clone()した値はまだ使用可能！ 41 | println!("clone: {:?}", cloned_pair); 42 | } 43 | -------------------------------------------------------------------------------- /src/crates/using_lib.md: -------------------------------------------------------------------------------- 1 | 4 | # ライブラリの利用 5 | 6 | 11 | クレートをこの新しいライブラリにリンクするには、`rustc`の`--extern`フラグを利用します。 12 | クレートの要素を全てライブラリと同じ名前のモジュールにインポートします。 13 | 一般に、このモジュールは他のモジュールと同じように振る舞います。 14 | 15 | ```rust,ignore 16 | // extern crate rary; // May be required for Rust 2015 edition or earlier 17 | // Rust 2015以前で必要 18 | 19 | fn main() { 20 | rary::public_function(); 21 | 22 | // Error! `private_function` is private 23 | // エラー!`private_function`はプライベート 24 | //rary::private_function(); 25 | 26 | rary::indirect_access(); 27 | } 28 | ``` 29 | 30 | ```txt 31 | # Where library.rlib is the path to the compiled library, assumed that it's 32 | # in the same directory here: 33 | # library.rlibがコンパイルされたライブラリのパスで、 34 | # 同じディレクトリにあるものとする: 35 | $ rustc executable.rs --extern rary=library.rlib && ./executable 36 | called rary's `public_function()` 37 | called rary's `indirect_access()`, that 38 | > called rary's `private_function()` 39 | ``` 40 | --------------------------------------------------------------------------------