Repository: rust-lang/rust-by-example Branch: master Commit: 5383db524711 Files: 217 Total size: 2.5 MB Directory structure: gitextract_2dn170dt/ ├── .gitattributes ├── .github/ │ └── workflows/ │ └── rbe.yml ├── .gitignore ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── TRANSLATING.md ├── TRANSLATING_JA.md ├── TRANSLATING_ZH.md ├── book.toml ├── po/ │ ├── es.po │ ├── ja.po │ ├── ko.po │ └── zh.po ├── src/ │ ├── SUMMARY.md │ ├── attribute/ │ │ ├── cfg/ │ │ │ └── custom.md │ │ ├── cfg.md │ │ ├── crate.md │ │ └── unused.md │ ├── attribute.md │ ├── cargo/ │ │ ├── build_scripts.md │ │ ├── conventions.md │ │ ├── deps.md │ │ └── test.md │ ├── cargo.md │ ├── compatibility/ │ │ └── raw_identifiers.md │ ├── compatibility.md │ ├── conversion/ │ │ ├── from_into.md │ │ ├── string.md │ │ └── try_from_try_into.md │ ├── conversion.md │ ├── crates/ │ │ ├── lib.md │ │ └── using_lib.md │ ├── crates.md │ ├── custom_types/ │ │ ├── constants.md │ │ ├── enum/ │ │ │ ├── c_like.md │ │ │ ├── enum_use.md │ │ │ └── testcase_linked_list.md │ │ ├── enum.md │ │ └── structs.md │ ├── custom_types.md │ ├── error/ │ │ ├── abort_unwind.md │ │ ├── iter_result.md │ │ ├── multiple_error_types/ │ │ │ ├── boxing_errors.md │ │ │ ├── define_error_type.md │ │ │ ├── option_result.md │ │ │ ├── reenter_question_mark.md │ │ │ └── wrap_error.md │ │ ├── multiple_error_types.md │ │ ├── option_unwrap/ │ │ │ ├── and_then.md │ │ │ ├── defaults.md │ │ │ ├── map.md │ │ │ └── question_mark.md │ │ ├── option_unwrap.md │ │ ├── panic.md │ │ ├── result/ │ │ │ ├── early_returns.md │ │ │ ├── enter_question_mark.md │ │ │ ├── result_alias.md │ │ │ └── result_map.md │ │ └── result.md │ ├── error.md │ ├── expression.md │ ├── flow_control/ │ │ ├── for.md │ │ ├── if_else.md │ │ ├── if_let.md │ │ ├── let_else.md │ │ ├── loop/ │ │ │ ├── nested.md │ │ │ └── return.md │ │ ├── loop.md │ │ ├── match/ │ │ │ ├── binding.md │ │ │ ├── destructuring/ │ │ │ │ ├── destructure_enum.md │ │ │ │ ├── destructure_pointers.md │ │ │ │ ├── destructure_slice.md │ │ │ │ ├── destructure_structures.md │ │ │ │ └── destructure_tuple.md │ │ │ ├── destructuring.md │ │ │ └── guard.md │ │ ├── match.md │ │ ├── while.md │ │ └── while_let.md │ ├── flow_control.md │ ├── fn/ │ │ ├── closures/ │ │ │ ├── anonymity.md │ │ │ ├── capture.md │ │ │ ├── closure_examples/ │ │ │ │ ├── iter_any.md │ │ │ │ └── iter_find.md │ │ │ ├── closure_examples.md │ │ │ ├── input_functions.md │ │ │ ├── input_parameters.md │ │ │ └── output_parameters.md │ │ ├── closures.md │ │ ├── diverging.md │ │ ├── hof.md │ │ └── methods.md │ ├── fn.md │ ├── generics/ │ │ ├── assoc_items/ │ │ │ ├── the_problem.md │ │ │ └── types.md │ │ ├── assoc_items.md │ │ ├── bounds/ │ │ │ └── testcase_empty.md │ │ ├── bounds.md │ │ ├── gen_fn.md │ │ ├── gen_trait.md │ │ ├── impl.md │ │ ├── multi_bounds.md │ │ ├── new_types.md │ │ ├── phantom/ │ │ │ └── testcase_units.md │ │ ├── phantom.md │ │ └── where.md │ ├── generics.md │ ├── hello/ │ │ ├── comment.md │ │ ├── print/ │ │ │ ├── fmt.md │ │ │ ├── print_debug.md │ │ │ ├── print_display/ │ │ │ │ └── testcase_list.md │ │ │ └── print_display.md │ │ └── print.md │ ├── hello.md │ ├── index.md │ ├── macros/ │ │ ├── designators.md │ │ ├── dry.md │ │ ├── dsl.md │ │ ├── overload.md │ │ ├── repeat.md │ │ ├── syntax.md │ │ └── variadics.md │ ├── macros.md │ ├── meta/ │ │ ├── doc.md │ │ └── playground.md │ ├── meta.md │ ├── mod/ │ │ ├── split.md │ │ ├── struct_visibility.md │ │ ├── super.md │ │ ├── use.md │ │ └── visibility.md │ ├── mod.md │ ├── primitives/ │ │ ├── array.md │ │ ├── literals.md │ │ └── tuples.md │ ├── primitives.md │ ├── scope/ │ │ ├── borrow/ │ │ │ ├── alias.md │ │ │ ├── mut.md │ │ │ └── ref.md │ │ ├── borrow.md │ │ ├── lifetime/ │ │ │ ├── elision.md │ │ │ ├── explicit.md │ │ │ ├── fn.md │ │ │ ├── lifetime_bounds.md │ │ │ ├── lifetime_coercion.md │ │ │ ├── methods.md │ │ │ ├── static_lifetime.md │ │ │ ├── struct.md │ │ │ └── trait.md │ │ ├── lifetime.md │ │ ├── move/ │ │ │ ├── mut.md │ │ │ └── partial_move.md │ │ ├── move.md │ │ └── raii.md │ ├── scope.md │ ├── std/ │ │ ├── arc.md │ │ ├── box.md │ │ ├── hash/ │ │ │ ├── alt_key_types.md │ │ │ └── hashset.md │ │ ├── hash.md │ │ ├── option.md │ │ ├── panic.md │ │ ├── rc.md │ │ ├── result/ │ │ │ └── question_mark.md │ │ ├── result.md │ │ ├── str.md │ │ └── vec.md │ ├── std.md │ ├── std_misc/ │ │ ├── arg/ │ │ │ └── matching.md │ │ ├── arg.md │ │ ├── channels.md │ │ ├── ffi.md │ │ ├── file/ │ │ │ ├── create.md │ │ │ ├── open.md │ │ │ └── read_lines.md │ │ ├── file.md │ │ ├── fs.md │ │ ├── path.md │ │ ├── process/ │ │ │ ├── pipe.md │ │ │ └── wait.md │ │ ├── process.md │ │ ├── threads/ │ │ │ └── testcase_mapreduce.md │ │ └── threads.md │ ├── std_misc.md │ ├── testing/ │ │ ├── dev_dependencies.md │ │ ├── doc_testing.md │ │ ├── integration_testing.md │ │ └── unit_testing.md │ ├── testing.md │ ├── trait/ │ │ ├── clone.md │ │ ├── derive.md │ │ ├── disambiguating.md │ │ ├── drop.md │ │ ├── dyn.md │ │ ├── impl_trait.md │ │ ├── iter.md │ │ ├── ops.md │ │ └── supertraits.md │ ├── trait.md │ ├── types/ │ │ ├── alias.md │ │ ├── cast.md │ │ ├── inference.md │ │ └── literals.md │ ├── types.md │ ├── unsafe/ │ │ └── asm.md │ ├── unsafe.md │ ├── variable_bindings/ │ │ ├── declare.md │ │ ├── freeze.md │ │ ├── mut.md │ │ └── scope.md │ └── variable_bindings.md ├── theme/ │ ├── css/ │ │ └── language-picker.css │ └── head.hbs └── triagebot.toml ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitattributes ================================================ # Set the default behavior, in case people don't have core.autocrlf set. * text=auto eol=lf ================================================ FILE: .github/workflows/rbe.yml ================================================ name: CI on: [push, pull_request] env: # Update the language picker in index.hbs to link new languages. LANGUAGES: ja zh es ko MDBOOK_VERSION: 0.5.1 jobs: test: name: Run tests runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: # We need the full history below. fetch-depth: 0 - name: Update rustup run: rustup self update - name: Install Rust run: | rustup set profile minimal rustup toolchain install nightly -c rust-docs rustup default nightly - name: Install mdbook run: | mkdir bin curl -sSL https://github.com/rust-lang/mdBook/releases/download/v${MDBOOK_VERSION}/mdbook-v${MDBOOK_VERSION}-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=bin echo "$(pwd)/bin" >> ${GITHUB_PATH} - name: Install mdbook-i18n-helpers run: | cargo install mdbook-i18n-helpers --locked --version 0.4.0 - name: Report versions run: | rustup --version rustc -Vv mdbook --version - name: Run tests run: mdbook test - name: Build HTML run: mdbook build - name: Check for broken links run: | curl -sSLo linkcheck.sh \ https://raw.githubusercontent.com/rust-lang/rust/master/src/tools/linkchecker/linkcheck.sh sh linkcheck.sh --all rust-by-example - name: Build all translations run: | for po_lang in ${{ env.LANGUAGES }}; do echo "::group::Building $po_lang translation" # Set language and adjust site URL. Clear the redirects # since they are in sync with the source files, not the # translation. MDBOOK_BOOK__LANGUAGE=$po_lang \ mdbook build -d book/$po_lang echo "::endgroup::" done - name: Check all translations for broken links run: | for po_lang in ${{ env.LANGUAGES }}; do MDBOOK_BOOK__LANGUAGE=$po_lang \ sh linkcheck.sh --all rust-by-example done - name: Upload Artifact uses: actions/upload-artifact@v4 with: name: rust-by-example path: book ================================================ FILE: .gitignore ================================================ book po/messages.pot .vscode/ # Auto-generated files from macOS .DS_Store ================================================ FILE: CODE_OF_CONDUCT.md ================================================ # The Rust Code of Conduct A version of this document [can be found online](https://www.rust-lang.org/conduct.html). ## Conduct **Contact**: [rust-mods@rust-lang.org](mailto:rust-mods@rust-lang.org) * We are committed to providing a friendly, safe and welcoming environment for all, regardless of level of experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or other similar characteristic. * On IRC, please avoid using overtly sexual nicknames or other nicknames that might detract from a friendly, safe and welcoming environment for all. * Please be kind and courteous. There's no need to be mean or rude. * Respect that people have differences of opinion and that every design or implementation choice carries a trade-off and numerous costs. There is seldom a right answer. * Please keep unstructured critique to a minimum. If you have solid ideas you want to experiment with, make a fork and see how it works. * We will exclude you from interaction if you insult, demean or harass anyone. That is not welcome behavior. We interpret the term "harassment" as including the definition in the [Citizen Code of Conduct](http://citizencodeofconduct.org/); if you have any lack of clarity about what might be included in that concept, please read their definition. In particular, we don't tolerate behavior that excludes people in socially marginalized groups. * Private harassment is also unacceptable. No matter who you are, if you feel you have been or are being harassed or made uncomfortable by a community member, please contact one of the channel ops or any of the [Rust moderation team][mod_team] immediately. Whether you're a regular contributor or a newcomer, we care about making this community a safe place for you and we've got your back. * Likewise any spamming, trolling, flaming, baiting or other attention-stealing behavior is not welcome. ## Moderation These are the policies for upholding our community's standards of conduct. If you feel that a thread needs moderation, please contact the [Rust moderation team][mod_team]. 1. Remarks that violate the Rust standards of conduct, including hateful, hurtful, oppressive, or exclusionary remarks, are not allowed. (Cursing is allowed, but never targeting another user, and never in a hateful manner.) 2. Remarks that moderators find inappropriate, whether listed in the code of conduct or not, are also not allowed. 3. Moderators will first respond to such remarks with a warning. 4. If the warning is unheeded, the user will be "kicked," i.e., kicked out of the communication channel to cool off. 5. If the user comes back and continues to make trouble, they will be banned, i.e., indefinitely excluded. 6. Moderators may choose at their discretion to un-ban the user if it was a first offense and they offer the offended party a genuine apology. 7. If a moderator bans someone and you think it was unjustified, please take it up with that moderator, or with a different moderator, **in private**. Complaints about bans in-channel are not allowed. 8. Moderators are held to a higher standard than other community members. If a moderator creates an inappropriate situation, they should expect less leeway than others. In the Rust community we strive to go the extra step to look out for each other. Don't just aim to be technically unimpeachable, try to be your best self. In particular, avoid flirting with offensive or sensitive issues, particularly if they're off-topic; this all too often leads to unnecessary fights, hurt feelings, and damaged trust; worse, it can drive people away from the community entirely. And if someone takes issue with something you said or did, resist the urge to be defensive. Just stop doing what it was they complained about and apologize. Even if you feel you were misinterpreted or unfairly accused, chances are good there was something you could've communicated better — remember that it's your responsibility to make your fellow Rustaceans comfortable. Everyone wants to get along and we are all here first and foremost because we want to talk about cool technology. You will find that people will be eager to assume good intent and forgive as long as you earn their trust. The enforcement policies listed above apply to all official Rust venues; including official IRC channels (#rust, #rust-internals, #rust-tools, #rust-libs, #rustc, #rust-beginners, #rust-docs, #rust-community, #rust-lang, and #cargo); GitHub repositories under rust-lang, rust-lang-nursery, and rust-lang-deprecated; and all forums under rust-lang.org (users.rust-lang.org, internals.rust-lang.org). For other projects adopting the Rust Code of Conduct, please contact the maintainers of those projects for enforcement. If you wish to use this code of conduct for your own project, consider explicitly mentioning your moderation policy or making a copy with your own moderation policy so as to avoid confusion. *Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) as well as the [Contributor Covenant v1.3.0](https://www.contributor-covenant.org/version/1/3/0/).* [mod_team]: https://www.rust-lang.org/team.html#Moderation-team ================================================ FILE: CONTRIBUTING.md ================================================ # Rust by Example contribution guidelines Thank you for your interest in making Rust by Example (also known as RBE) better! We'd love to have your contribution. We expect all contributors to abide by the [Rust code of conduct], which you can find at that link or in the [`CODE_OF_CONDUCT.md`] file in this repository. [Rust code of conduct]: https://www.rust-lang.org/policies/code-of-conduct [`CODE_OF_CONDUCT.md`]: https://github.com/rust-lang/rust-by-example/blob/master/CODE_OF_CONDUCT.md ## License RBE is dual licensed under the MIT and Apache 2.0 licenses, and so are all contributions. Please see the [`LICENSE-MIT`] and [`LICENSE-APACHE`] files in this directory for more details. [`LICENSE-MIT`]: https://github.com/rust-lang/rust-by-example/blob/master/LICENSE-MIT [`LICENSE-APACHE`]: https://github.com/rust-lang/rust-by-example/blob/master/LICENSE-APACHE ## Pull Requests To make changes to RBE, please send in pull requests on GitHub to the `master` branch. We'll review them and either merge or request changes. Travis CI tests everything as well, so you may get feedback from it too. If you make additions or other changes to a pull request, feel free to either amend previous commits or only add new ones, however you prefer. We may ask you to squash your commits before merging, depending. ## Issue Tracker You can find the issue tracker [on GitHub](https://github.com/rust-lang/rust-by-example/issues). If you've found a problem with RBE, please open an issue there. We use the following labels: * `enhancement`: This is for any request for new sections or functionality. * `bug`: This is for anything that's in RBE, but incorrect or not working. * `discussion`: A discussion about improving something in RBE; this may lead to new enhancement or bug issues. * `E-mentor`: This issue has someone dedicated to helping a new contributor fix it! Can apply to both enhancement or bug issues. ## Development workflow To build RBE, [install Rust](https://www.rust-lang.org/tools/install), and then: ```bash $ git clone https://github.com/rust-lang/rust-by-example $ cd rust-by-example $ cargo install mdbook $ mdbook build ``` **The following warnings can be ignored safely.** ```text WARN The command `mdbook-gettext` for preprocessor `gettext` was not found, but is marked as optional. ``` [install Rust]: http://rust-lang.org/install.html The files will be in the `book` directory at the top-level; `mdbook serve` will open the contents in your web browser ([localhost:3000](http://localhost:3000) by default). To run the tests: ```bash $ mdbook test ``` If you're adding a new chapter, you'll need to edit `src\SUMMARY.md` to add it. If you're tweaking an existing example, you'll need to edit the corresponding file; check `src\SUMMARY.md` to see a mapping of where chapters go to files. ================================================ FILE: LICENSE-APACHE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================ FILE: LICENSE-MIT ================================================ Copyright (c) 2014 Jorge Aparicio Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ # Rust By Example [![Build Status](https://github.com/rust-lang/rust-by-example/actions/workflows/rbe.yml/badge.svg)](https://github.com/rust-lang/rust-by-example/actions) Learn Rust with examples (Live code editor included) ## Using If you'd like to read Rust by Example, you can visit to read it online. If you'd like to read it locally, [install Rust], and then: ```bash git clone https://github.com/rust-lang/rust-by-example cd rust-by-example cargo install mdbook mdbook build mdbook serve ``` [install Rust]: https://www.rust-lang.org/tools/install To be able to run the examples, you must be connected to the internet; you can read all content offline, however! **The following warnings can be ignored safely.** ```text WARN The command `mdbook-gettext` for preprocessor `gettext` was not found, but is marked as optional. ``` ### Using translated version If there is a translated resource in `po/` directory, it can be specified through `MDBOOK_BOOK__LANGUAGE` like below: ```bash git clone https://github.com/rust-lang/rust-by-example cd rust-by-example cargo install mdbook MDBOOK_BOOK__LANGUAGE=ja mdbook build MDBOOK_BOOK__LANGUAGE=ja mdbook serve ``` ## Contributing Please see the [CONTRIBUTING.md] file for more details. [CONTRIBUTING.md]: https://github.com/rust-lang/rust-by-example/blob/master/CONTRIBUTING.md ## Translating Please see the [TRANSLATING.md] file for more details. [TRANSLATING.md]: https://github.com/rust-lang/rust-by-example/blob/master/TRANSLATING.md ### Translating guide for each languages * Japanese/日本語: [TRANSLATING_JA.md] [TRANSLATING_JA.md]: https://github.com/rust-lang/rust-by-example/blob/master/TRANSLATING_JA.md * Chinese/中文: [TRANSLATING_ZH.md] [TRANSLATING_ZH.md]: https://github.com/rust-lang/rust-by-example/blob/master/TRANSLATING_ZH.md ## Translations to other languages * [Bulgarian](https://github.com/kberov/rust-by-example-bg) * [French](https://github.com/Songbird0/FR_RBE) * [Russian](https://github.com/ruRust/rust-by-example) * [Vietnamese](https://github.com/EyesCrypto-Insights/rust-by-example-vn) * [Portuguese](https://github.com/nazarepiedady/rust-com-exemplos) ## License Rust by Example is licensed under either of * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or ) * MIT license ([LICENSE-MIT](LICENSE-MIT) or ) at your option. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Rust by Example by you, as defined in the Apache-2.0 license, shall be dually licensed as above, without any additional terms or conditions. ================================================ FILE: TRANSLATING.md ================================================ # Rust by Example translation guidelines Please see the [CONTRIBUTING.md] file for general contribution guidelines. This file describes about the translation workflow. [CONTRIBUTING.md]: https://github.com/rust-lang/rust-by-example/blob/master/CONTRIBUTING.md ## Translation workflow ### Preparation RBE uses [mdbook-i18n-helpers](https://github.com/google/mdbook-i18n-helpers) as a translation framework. The following tools are required. * GNU gettext utilities ( `msgmerge` and `msgcat` ) * mdbook-i18n-helpers ( `cargo install mdbook-i18n-helpers` ) ### Creating and Updating Translations Please see the [mdbook-i18n-helpers USAGE](https://github.com/google/mdbook-i18n-helpers/blob/main/i18n-helpers/USAGE.md) file for the detailed usage of mdbook-i18n-helpers. The summarized command list is below: #### Generating a message template The generated message templete `po/messages.pot` is required to create or update translations. ```bash MDBOOK_OUTPUT='{"xgettext": {"pot-file": "messages.pot"}}' \ mdbook build -d po ``` #### Creating a new translation resource `xx` is [ISO 639](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) language code. ```bash msginit -i po/messages.pot -l xx -o po/xx.po ``` #### Updating the existing translation resource ```bash msgmerge --update po/xx.po po/messages.pot ``` #### Tracking translation progress ```bash msgfmt --statistics po/xx.po ``` ### Editing translation resources After generating a translation resource `po/xx.po`, you can write translation messages in `msgstr` entry of `po/xx.po`. To build a translated book, the following command can be used. ```bash MDBOOK_BOOK__LANGUAGE=xx mdbook build MDBOOK_BOOK__LANGUAGE=xx mdbook serve ``` ### Add a language entry Please add a language entry in `.github/workflows/rbe.yml`, `theme/head.hbs`, and `src/bootstrap/src/core/build_steps/doc.rs` in [rust-lang/rust](https://github.com/rust-lang/rust) like below: * `rbe.yml` ```yml env: # Update the language picker in index.hbs to link new languages. LANGUAGES: xx yy zz ``` * `head.hbs` ```html ``` * `src/bootstrap/src/core/build_steps/doc.rs` in [rust-lang/rust](https://github.com/rust-lang/rust) ```rust RustByExample, "src/doc/rust-by-example", "rust-by-example", &["xx", "yy", "zz"], submodule; ``` ================================================ FILE: TRANSLATING_JA.md ================================================ # Rust by Example 日本語版 翻訳ガイド 日本語版の翻訳は https://github.com/rust-lang-ja/rust-by-example にて日本語のレビューを行います。 翻訳に貢献される方は以下のフローに従ってください。 * https://github.com/rust-lang/rust-by-example を自身のアカウントにフォークする * `po/ja.po` に訳文を追加・変更する * https://github.com/rust-lang-ja/rust-by-example （の`ja`ブランチ）にプルリクエストを出す + 直接オリジナルのリポジトリに出しても訳文自体のレビューができないので rust-lang-ja で一旦レビューします + 上記リポジトリは`ja`ブランチがデフォルトなので通常通りプルリクエストを作成すれば`ja`ブランチ向けになります rust-lang-ja のレビュワーは以下のように作業します。 * プルリクエストをレビューし、問題なければ`ja`ブランチにマージ * https://github.com/rust-lang/rust-by-example にプルリクエストを出す 最終的に https://github.com/rust-lang/rust-by-example でマージされれば公開されます。 ## 翻訳の方法 ### 全般的なこと * 文体は「です・ます」調 * 記号類は原則として全角（括弧`（）`やコロン`：`など） ### 対訳表 * カタカナ語のままで違和感のない用語はカタカナ語のまま使う + 気持としては「無理矢理和訳」を避けたい。そのための基準。 + カタカナ語の方が用語として認識しやすい * カタカナ語の末尾の長音記号「ー」は省く(JIS規格) * 構文キーワードなどはそのままアルファベットを使う | English | 日本語 | :------------------------------- | :------------- | (lockの) acquire | 獲得 | (lockの) release | 解放 | Intrinsics | Intrinsic | Lang Items | Lang Item | Universal Function Call Syntax | 共通の関数呼び出し構文 | abort | アボート | activity | 実践 | aggregate type | 合成型 | alignment | アラインメント | allocator | アロケータ | antipattern | アンチパターン | application | アプリケーション | argument type | 引数タイプ | arity | アリティ | array | 配列 | assignment | 代入 | associated - | 関連- | atomic | アトミック | attribute | アトリビュート | binary | バイナリ | binding | 束縛 | block | ブロック | borrow checker | 借用チェッカー | borrowing | 借用 | bounds | 境界 | bug | バグ | capture | キャプチャ | case analysis | 場合分け | casting | キャスト | channel | チャネル | closure | クロージャ | code bloat | コードの膨張 | coercion | 型強制 | color model | カラーモデル | combinator | コンビネータ | comma | カンマ | command line | コマンドライン | compile-time error | コンパイル時エラー | compiler | コンパイラ | composable | 合成可能 | computer science | コンピュータサイエンス | concurrency | 並行性 | constant | 定数 | constructor | コンストラクタ | continuous integration | 継続的インテグレーション | crate | クレート | custom type | カスタム型 | dangling | ダングリング | data race | データ競合 | deadlock | デッドロック | declaration statement | 宣言文 | dereferencing | 参照外し | derive | 導出 | designator | 識別子 | destructor | デストラクタ | destructuring | 分配 | directive | ディレクティブ | directory | ディレクトリ | discriminant | 判別子 | distribution | 配布物 | diverge | ダイバージ | diverging | ダイバージング | diverging function | 発散する関数 | documentation comment | ドキュメンテーションコメント | documentation test | ドキュメンテーションテスト | early return | 早期リターン | empty tuple | 空タプル | encode | エンコード | endpoint | エンドポイント | entry point | エントリポイント | enum | 列挙型 | equality | 等値性 | ergonomic | エルゴノミック（人間にとって扱いやすいもの） | error | エラー | error handling | エラーハンドリング | executable | 実行可能形式 | existentially quantified type | 存在量型 | expression statement | 式文 | exterior | 外側の | feature | フィーチャ | field | フィールド | foreign | 他言語 | free-standing function | フリースタンディングな関数 | full path | 絶対パス | generic parameter | ジェネリックパラメータ | generics | ジェネリクス | glob | グロブ | growable | 伸張可能 | guard | ガード | handle | ハンドル | hash | ハッシュ | hash set | ハッシュ集合 | higher order functions | 高階関数 | identifier | 識別子 | immutability | イミュータビリティ | immutable | イミュータブル | implement | 実装する | initialize | 初期化する | input lifetime | 入力ライフタイム | install | インストール | installer | インストーラ | interior | 内側の | interpolate | インターポーレートする | interpolation | インターポーレーション | key | キー | keyword | キーワード | leak | リーク | least significant bit | 最下位ビット | lending | 貸付け | library | ライブラリ | lifetime | ライフタイム | lifetime coercion | ライフタイムの圧縮 | lifetime elision | ライフタイムの省略 | lifetime parameter | ライフタイムパラメータ | link | リンク | lint | リント | mangling | マングリング | match | マッチ | memory | メモリ | method | メソッド | monomorphization | 単相化 | move | ムーブ | mutability | ミュータビリティ | mutable | ミュータブル | mutable binding | ミュータブルな束縛 | mutual-exclusion | 相互排他 | null | ヌル | numeric literal | 数値リテラル | object-safe | オブジェクト安全 | offline | オフライン | opaque | オペーク | open source | オープンソース | option | オプション | output lifetime | 出力ライフタイム | output type | アウトプット型 | overflow | オーバーフロー | owner | 所有者 | ownership | 所有権 | panic | パニック | parameter | パラメータ | parametric polymorphism | パラメトリック多相 | parse | パース、パースする | partial moves | 部分的ムーブ | patch | パッチ | pattern | パターン | performance | パフォーマンス | phantom type | 幽霊型 | platform | プラットフォーム | pointer | ポインタ | primitive type | プリミティブ型 | private | プライベート | process | プロセス | public | パブリック | r-value | 右辺値 | range | レンジ | raw pointer | 生ポインタ | raw identifier | 生識別子 | re-assignment | 再代入 | rebind | 再束縛 | reference count | 参照カウント | regression | リグレッション | release | リリース | return | 返す | return type | リターン型 | return value | 戻り値 | runtime | 実行時 | safe | 安全 | safety check | 安全性検査 | scope | スコープ | scoped | スコープ化された | script | スクリプト | semantics | セマンティクス | shadow | 覆い隠す | shadowing | シャドーイング | signature | シグネチャ | signed | 符号付き | slice | スライス | slicing | スライシング | specialized | 特殊化された | standard library | 標準ライブラリ | string | 文字列 | string interpolation | 文字列インターポーレーション | struct | 構造体 | structure | 構造体 | sum type | 直和型 | subtrait | サブトレイト | supertrait | スーパートレイト | symbol | シンボル | syntactic sugar | 糖衣構文 | syntax tree | 構文木 | system | システム | tagged union | タグ付き共用体 | term | 項 | thread-locality | スレッドローカル性 | threadsafe | スレッドセーフ | tick | クオート | token trees | トークン木 | trait | トレイト | transmute | トランスミュート | tuple | タプル | tuple struct | タプル | type alias | 型エイリアス | type erasure | 型消去 | type family | 型族 | type inference | 型推論 | type parameter | 型パラメータ | uninstall | アンインストール | unit 注: `()` の読み | ユニット | unsafe | アンセーフ | unsigned | 符号無し | unsized type | サイズ不定型 | unwinding | 巻き戻し | unwrap | アンラップ | value constructor | 値コンストラクタ | variable | 変数 | variable binding | 変数束縛 | variant | ヴァリアント | vector | ベクタ | version | バージョン | warning | ウォーニング | wildcard | ワイルドカード | wrapper | ラッパ ================================================ FILE: TRANSLATING_ZH.md ================================================ # Rust by Example 中文版翻译指南 Rust by Example 中文版的翻译在 https://github.com/rust-lang-cn/rust-by-example 仓库进行审核和校对。 如果您希望参与翻译，请按照以下流程操作： 1. 复刻（fork）https://github.com/rust-lang/rust-by-example 仓库。 2. 在 `po/zh.po` 文件中添加或修改译文。 3. 向 https://github.com/rust-lang-cn/rust-by-example 仓库的 `zh` 分支提交 PR（Pull Request）。 - 先在 rust-lang-cn 仓库进行审校，而非直接向原始仓库提交 PR，这样可以更方便进行译文讨论。 - 中文社区仓库的默认分支为 `zh`，因此正常创建 PR 时会自动指向该分支。 rust-lang-cn 翻译组成员的维护流程： 1. 审核并校对提交的 PR，先合并到 `zh` 分支。 2. 向 https://github.com/rust-lang/rust-by-example 原始仓库提交 PR。 ## 翻译规范 ### 总体原则 * 文风应保持正式、清晰、简洁 * 标点符号原则上使用全角（如括号"（）"和冒号"："等） ### 术语翻译指南 * 对于已经广泛接受的技术术语，保留英文或使用通用的中文翻译 * 避免生硬的直译，优先考虑符合中文语境的自然表达 * 保持术语翻译的一致性，可参考 [Rust 语言术语中英文对照表](https://github.com/rust-lang-cn/english-chinese-glossary-of-rust/blob/master/rust-glossary.md) ================================================ FILE: book.toml ================================================ [book] title = "Rust By Example" description = "Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries." authors = ["The Rust Community"] [output.html.playpen] editable = true line-numbers = true [output.html.fold] enable = true [output.html] git-repository-url = "https://github.com/rust-lang/rust-by-example" edit-url-template = "https://github.com/rust-lang/rust-by-example/edit/master/{path}" hash-files = true additional-css = [ "theme/css/language-picker.css", ] [output.html.search] use-boolean-and = true [rust] edition = "2021" [build] extra-watch-dirs = ["po"] [preprocessor.gettext] optional = true after = ["links"] ================================================ FILE: po/es.po ================================================ msgid "" msgstr "" "Project-Id-Version: Rust By Example\n" "POT-Creation-Date: 2025-01-30T21:37:19-06:00\n" "PO-Revision-Date: 2025-01-30 21:37-06:00\n" "Last-Translator: mrg \n" "Language-Team: Spanish \n" "Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" #: src/SUMMARY.md:1 msgid "Summary" msgstr "Resumen" #: src/SUMMARY.md:3 msgid "Introduction" msgstr "Introducción" #: src/SUMMARY.md:5 src/hello.md:1 msgid "Hello World" msgstr "Hola Mundo" #: src/SUMMARY.md:6 src/hello/comment.md:1 msgid "Comments" msgstr "Comentarios" #: src/SUMMARY.md:7 src/hello/print.md:1 msgid "Formatted print" msgstr "Imprimir con formatos" #: src/SUMMARY.md:8 src/hello/print/print_debug.md:1 msgid "Debug" msgstr "Depuración" #: src/SUMMARY.md:9 src/hello/print/print_display.md:1 msgid "Display" msgstr "" #: src/SUMMARY.md:10 src/hello/print/print_display/testcase_list.md:1 msgid "Testcase: List" msgstr "Ejemplot: Lista" #: src/SUMMARY.md:11 src/hello/print/fmt.md:1 msgid "Formatting" msgstr "Formateo" #: src/SUMMARY.md:13 src/primitives.md:1 msgid "Primitives" msgstr "Primitivas" #: src/SUMMARY.md:14 src/primitives/literals.md:1 msgid "Literals and operators" msgstr "Operadores y Literales" #: src/SUMMARY.md:15 src/primitives/tuples.md:1 msgid "Tuples" msgstr "Tuplas" #: src/SUMMARY.md:16 src/primitives/array.md:1 msgid "Arrays and Slices" msgstr "Arreglos y slices" #: src/SUMMARY.md:18 src/custom_types.md:1 msgid "Custom Types" msgstr "Tipos Personalizados" #: src/SUMMARY.md:19 src/custom_types/structs.md:1 msgid "Structures" msgstr "Estructuras" #: src/SUMMARY.md:20 src/custom_types/enum.md:1 msgid "Enums" msgstr "Enums" #: src/SUMMARY.md:21 src/custom_types/enum/enum_use.md:1 msgid "use" msgstr "" #: src/SUMMARY.md:22 src/custom_types/enum/c_like.md:1 msgid "C-like" msgstr "Herencias de C" #: src/SUMMARY.md:23 src/custom_types/enum/testcase_linked_list.md:1 msgid "Testcase: linked-list" msgstr "Ejemplo: lista ligada" #: src/SUMMARY.md:24 src/custom_types/constants.md:1 msgid "constants" msgstr "constantes" #: src/SUMMARY.md:26 src/variable_bindings.md:1 msgid "Variable Bindings" msgstr "Enlaces de variables" #: src/SUMMARY.md:27 src/SUMMARY.md:120 src/SUMMARY.md:123 #: src/variable_bindings/mut.md:1 src/scope/move/mut.md:1 #: src/scope/borrow/mut.md:1 msgid "Mutability" msgstr "Mutabilidad" #: src/SUMMARY.md:28 src/variable_bindings/scope.md:1 msgid "Scope and Shadowing" msgstr "Alcance y sombreo" #: src/SUMMARY.md:29 src/variable_bindings/declare.md:1 msgid "Declare first" msgstr "Declara primero" #: src/SUMMARY.md:30 src/variable_bindings/freeze.md:1 msgid "Freezing" msgstr "Congelar" #: src/SUMMARY.md:32 src/types.md:1 msgid "Types" msgstr "Tipos" #: src/SUMMARY.md:33 src/types/cast.md:1 msgid "Casting" msgstr "Casteo" #: src/SUMMARY.md:34 src/types/literals.md:1 msgid "Literals" msgstr "Literales" #: src/SUMMARY.md:35 src/types/inference.md:1 msgid "Inference" msgstr "Inferencia" #: src/SUMMARY.md:36 src/SUMMARY.md:124 src/types/alias.md:1 #: src/scope/borrow/alias.md:1 msgid "Aliasing" msgstr "Aliasing" #: src/SUMMARY.md:38 src/conversion.md:1 msgid "Conversion" msgstr "Conversión" #: src/SUMMARY.md:39 src/conversion/from_into.md:1 msgid "`From` and `Into`" msgstr "`From` e `Into`" #: src/SUMMARY.md:40 src/conversion/try_from_try_into.md:1 msgid "`TryFrom` and `TryInto`" msgstr "`TryFrom` y `TryInto`" #: src/SUMMARY.md:41 msgid "To and from `String`s" msgstr "De y hacia `String`s" #: src/SUMMARY.md:43 src/expression.md:1 msgid "Expressions" msgstr "Expresiones" #: src/SUMMARY.md:45 src/flow_control.md:1 msgid "Flow of Control" msgstr "Control de Flujo" #: src/SUMMARY.md:46 src/flow_control/if_else.md:1 msgid "if/else" msgstr "" #: src/SUMMARY.md:47 src/flow_control/loop.md:1 msgid "loop" msgstr "" #: src/SUMMARY.md:48 src/flow_control/loop/nested.md:1 msgid "Nesting and labels" msgstr "" #: src/SUMMARY.md:49 src/flow_control/loop/return.md:1 msgid "Returning from loops" msgstr "Retornar desde bucles" #: src/SUMMARY.md:50 src/flow_control/while.md:1 msgid "while" msgstr "" #: src/SUMMARY.md:51 src/flow_control/for.md:3 msgid "for and range" msgstr "for y range" #: src/SUMMARY.md:52 src/flow_control/match.md:1 msgid "match" msgstr "" #: src/SUMMARY.md:53 src/flow_control/match/destructuring.md:1 msgid "Destructuring" msgstr "Destructura" #: src/SUMMARY.md:54 #: src/flow_control/match/destructuring/destructure_tuple.md:1 msgid "tuples" msgstr "tuplas" #: src/SUMMARY.md:55 #: src/flow_control/match/destructuring/destructure_slice.md:1 msgid "arrays/slices" msgstr "arreglos/slices" #: src/SUMMARY.md:56 src/flow_control/match/destructuring/destructure_enum.md:1 msgid "enums" msgstr "" #: src/SUMMARY.md:57 #: src/flow_control/match/destructuring/destructure_pointers.md:1 msgid "pointers/ref" msgstr "punteros/ref" #: src/SUMMARY.md:58 #: src/flow_control/match/destructuring/destructure_structures.md:1 msgid "structs" msgstr "" #: src/SUMMARY.md:59 src/flow_control/match/guard.md:1 msgid "Guards" msgstr "Guardias" #: src/SUMMARY.md:60 src/flow_control/match/binding.md:1 msgid "Binding" msgstr "Enlaces" #: src/SUMMARY.md:61 src/flow_control/if_let.md:1 msgid "if let" msgstr "" #: src/SUMMARY.md:62 src/flow_control/let_else.md:1 msgid "let-else" msgstr "" #: src/SUMMARY.md:63 src/flow_control/while_let.md:1 msgid "while let" msgstr "" #: src/SUMMARY.md:65 src/SUMMARY.md:103 src/SUMMARY.md:128 src/fn.md:1 #: src/generics/gen_fn.md:1 src/scope/lifetime/fn.md:1 msgid "Functions" msgstr "Funciones" #: src/SUMMARY.md:66 src/SUMMARY.md:129 src/scope/lifetime/methods.md:1 msgid "Methods" msgstr "Métodos" #: src/SUMMARY.md:67 src/fn/closures.md:1 msgid "Closures" msgstr "" #: src/SUMMARY.md:68 src/fn/closures/capture.md:1 msgid "Capturing" msgstr "Capturas" #: src/SUMMARY.md:69 src/fn/closures/input_parameters.md:1 msgid "As input parameters" msgstr "Como parámetros de entrada" #: src/SUMMARY.md:70 src/fn/closures/anonymity.md:1 msgid "Type anonymity" msgstr "Anonimidad de tipos" #: src/SUMMARY.md:71 src/fn/closures/input_functions.md:1 msgid "Input functions" msgstr "Funciones de entrada" #: src/SUMMARY.md:72 src/fn/closures/output_parameters.md:1 msgid "As output parameters" msgstr "Como parámetros de salida" #: src/SUMMARY.md:73 src/fn/closures/closure_examples.md:1 msgid "Examples in `std`" msgstr "Ejemplos de `std`" #: src/SUMMARY.md:74 src/fn/closures/closure_examples/iter_any.md:1 msgid "Iterator::any" msgstr "" #: src/SUMMARY.md:75 src/fn/closures/closure_examples/iter_find.md:1 msgid "Searching through iterators" msgstr "Buscando con iteradores" #: src/SUMMARY.md:76 src/fn/hof.md:1 msgid "Higher Order Functions" msgstr "Funciones de Mayor Orden" #: src/SUMMARY.md:77 src/fn/diverging.md:1 msgid "Diverging functions" msgstr "Funciones Divergentes" #: src/SUMMARY.md:79 src/mod.md:1 msgid "Modules" msgstr "Módulos" #: src/SUMMARY.md:80 src/mod/visibility.md:1 msgid "Visibility" msgstr "Visibilidad" #: src/SUMMARY.md:81 src/mod/struct_visibility.md:1 msgid "Struct visibility" msgstr "Visibilidad de estructuras" #: src/SUMMARY.md:82 src/mod/use.md:1 msgid "The `use` declaration" msgstr "La declaración `use`" #: src/SUMMARY.md:83 src/mod/super.md:1 msgid "`super` and `self`" msgstr "`super` y `self`" #: src/SUMMARY.md:84 src/mod/split.md:1 msgid "File hierarchy" msgstr "Jerarquía de archivos" #: src/SUMMARY.md:86 src/SUMMARY.md:98 src/crates.md:1 src/attribute/crate.md:1 #: src/std_misc/arg.md:30 msgid "Crates" msgstr "" #: src/SUMMARY.md:87 src/crates/lib.md:1 msgid "Creating a Library" msgstr "Creando una Library" #: src/SUMMARY.md:88 src/crates/using_lib.md:1 msgid "Using a Library" msgstr "Usando un Library" #: src/SUMMARY.md:90 src/cargo.md:1 msgid "Cargo" msgstr "" #: src/SUMMARY.md:91 src/cargo/deps.md:1 msgid "Dependencies" msgstr "Dependencias" #: src/SUMMARY.md:92 src/cargo/conventions.md:1 msgid "Conventions" msgstr "Convenciones" #: src/SUMMARY.md:93 msgid "Tests" msgstr "" #: src/SUMMARY.md:94 src/cargo/build_scripts.md:1 msgid "Build Scripts" msgstr "Scripts de Build" #: src/SUMMARY.md:96 src/attribute.md:1 msgid "Attributes" msgstr "Atributos" #: src/SUMMARY.md:97 src/attribute/unused.md:1 msgid "`dead_code`" msgstr "" #: src/SUMMARY.md:99 src/attribute/cfg.md:1 msgid "`cfg`" msgstr "" #: src/SUMMARY.md:100 src/attribute/cfg/custom.md:1 msgid "Custom" msgstr "Personalizaciones" #: src/SUMMARY.md:102 src/generics.md:1 msgid "Generics" msgstr "Genéricos" #: src/SUMMARY.md:104 src/generics/impl.md:1 msgid "Implementation" msgstr "Implementación" #: src/SUMMARY.md:105 src/SUMMARY.md:131 src/SUMMARY.md:137 #: src/generics/gen_trait.md:1 src/scope/lifetime/trait.md:1 src/trait.md:1 msgid "Traits" msgstr "" #: src/SUMMARY.md:106 src/SUMMARY.md:132 src/generics/bounds.md:1 #: src/scope/lifetime/lifetime_bounds.md:1 msgid "Bounds" msgstr "Cotas" #: src/SUMMARY.md:107 src/generics/bounds/testcase_empty.md:1 msgid "Testcase: empty bounds" msgstr "Ejemplo: cotas vacías" #: src/SUMMARY.md:108 src/generics/multi_bounds.md:1 msgid "Multiple bounds" msgstr "Cotas Múltiples" #: src/SUMMARY.md:109 src/generics/where.md:1 msgid "Where clauses" msgstr "Cláusulas where" #: src/SUMMARY.md:110 src/generics/new_types.md:1 msgid "New Type Idiom" msgstr "Modismo New Type" #: src/SUMMARY.md:111 src/generics/assoc_items.md:1 msgid "Associated items" msgstr "Ítems asociados" #: src/SUMMARY.md:112 src/generics/assoc_items/the_problem.md:1 msgid "The Problem" msgstr "El Problema" #: src/SUMMARY.md:113 src/generics/assoc_items/types.md:1 msgid "Associated types" msgstr "Tipos Asociados" #: src/SUMMARY.md:114 src/generics/phantom.md:1 msgid "Phantom type parameters" msgstr "Parámetros Phantom Type" #: src/SUMMARY.md:115 src/generics/phantom/testcase_units.md:1 msgid "Testcase: unit clarification" msgstr "Ejemplo: clarificación de unidades" #: src/SUMMARY.md:117 src/scope.md:1 msgid "Scoping rules" msgstr "Reglas de alcance" #: src/SUMMARY.md:118 src/scope/raii.md:1 msgid "RAII" msgstr "" #: src/SUMMARY.md:119 src/scope/move.md:1 msgid "Ownership and moves" msgstr "Ownership y moves" #: src/SUMMARY.md:121 src/scope/move/partial_move.md:1 msgid "Partial moves" msgstr "Moves parciales" #: src/SUMMARY.md:122 src/scope/borrow.md:1 msgid "Borrowing" msgstr "" #: src/SUMMARY.md:125 src/scope/borrow/ref.md:1 msgid "The ref pattern" msgstr "El patrón de ref" #: src/SUMMARY.md:126 src/scope/lifetime.md:1 msgid "Lifetimes" msgstr "" #: src/SUMMARY.md:127 src/scope/lifetime/explicit.md:1 msgid "Explicit annotation" msgstr "Anotación explícita" #: src/SUMMARY.md:130 src/scope/lifetime/struct.md:1 msgid "Structs" msgstr "" #: src/SUMMARY.md:133 src/scope/lifetime/lifetime_coercion.md:1 msgid "Coercion" msgstr "Coerción" #: src/SUMMARY.md:134 src/scope/lifetime/static_lifetime.md:1 msgid "Static" msgstr "" #: src/SUMMARY.md:135 src/scope/lifetime/elision.md:1 msgid "Elision" msgstr "Elisión" #: src/SUMMARY.md:138 src/trait/derive.md:1 msgid "Derive" msgstr "" #: src/SUMMARY.md:139 src/trait/dyn.md:1 msgid "Returning Traits with `dyn`" msgstr "Retornando Traits con `dyn`" #: src/SUMMARY.md:140 src/trait/ops.md:1 msgid "Operator Overloading" msgstr "Sobrecarga de Operadores" #: src/SUMMARY.md:141 src/trait/drop.md:1 msgid "Drop" msgstr "" #: src/SUMMARY.md:142 src/trait/iter.md:1 msgid "Iterators" msgstr "" #: src/SUMMARY.md:143 src/trait/impl_trait.md:1 msgid "`impl Trait`" msgstr "" #: src/SUMMARY.md:144 src/trait/clone.md:1 msgid "Clone" msgstr "" #: src/SUMMARY.md:145 src/trait/supertraits.md:1 msgid "Supertraits" msgstr "" #: src/SUMMARY.md:146 src/trait/disambiguating.md:1 msgid "Disambiguating overlapping traits" msgstr "Desambiguando traits empalmados" #: src/SUMMARY.md:148 msgid "macro_rules!" msgstr "" #: src/SUMMARY.md:149 src/macros/syntax.md:1 msgid "Syntax" msgstr "Sintaxis" #: src/SUMMARY.md:150 src/macros/designators.md:1 msgid "Designators" msgstr "Designadores" #: src/SUMMARY.md:151 src/macros/overload.md:1 msgid "Overload" msgstr "Sobrecarga" #: src/SUMMARY.md:152 src/macros/repeat.md:1 msgid "Repeat" msgstr "Repetición" #: src/SUMMARY.md:153 src/macros/dry.md:1 msgid "DRY (Don't Repeat Yourself)" msgstr "" #: src/SUMMARY.md:154 msgid "DSL (Domain Specific Languages)" msgstr "" #: src/SUMMARY.md:155 msgid "Variadics" msgstr "Variádicas" #: src/SUMMARY.md:157 src/error.md:1 msgid "Error handling" msgstr "Manejo de Errores" #: src/SUMMARY.md:158 src/error/panic.md:1 msgid "`panic`" msgstr "" #: src/SUMMARY.md:159 msgid "`abort` & `unwind`" msgstr "" #: src/SUMMARY.md:160 src/error/option_unwrap.md:1 msgid "`Option` & `unwrap`" msgstr "" #: src/SUMMARY.md:161 src/error/option_unwrap/question_mark.md:1 msgid "Unpacking options with `?`" msgstr "Desempacando Options con `?`" #: src/SUMMARY.md:162 src/error/option_unwrap/map.md:1 msgid "Combinators: `map`" msgstr "Combinadores: `map`" #: src/SUMMARY.md:163 src/error/option_unwrap/and_then.md:1 msgid "Combinators: `and_then`" msgstr "Combinadores: `and_then`" #: src/SUMMARY.md:164 msgid "Defaults: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`" msgstr "" #: src/SUMMARY.md:165 src/SUMMARY.md:183 src/error/result.md:1 #: src/std/result.md:1 msgid "`Result`" msgstr "" #: src/SUMMARY.md:166 src/error/result/result_map.md:1 msgid "`map` for `Result`" msgstr "" #: src/SUMMARY.md:167 src/error/result/result_alias.md:1 msgid "aliases for `Result`" msgstr "aliases para `Result`" #: src/SUMMARY.md:168 src/error/result/early_returns.md:1 msgid "Early returns" msgstr "Retornos tempranos" #: src/SUMMARY.md:169 src/error/result/enter_question_mark.md:1 msgid "Introducing `?`" msgstr "Introduciendo `?`" #: src/SUMMARY.md:170 src/error/multiple_error_types.md:1 msgid "Multiple error types" msgstr "Mùltiples tipos de errores" #: src/SUMMARY.md:171 src/error/multiple_error_types/option_result.md:1 msgid "Pulling `Result`s out of `Option`s" msgstr "Sacando `Result`s de `Option`s" #: src/SUMMARY.md:172 src/error/multiple_error_types/define_error_type.md:1 msgid "Defining an error type" msgstr "Definiendo un tipo de error" #: src/SUMMARY.md:173 src/error/multiple_error_types/boxing_errors.md:1 msgid "`Box`ing errors" msgstr "`Box`ing de errores" #: src/SUMMARY.md:174 src/error/multiple_error_types/reenter_question_mark.md:1 msgid "Other uses of `?`" msgstr "Otros usos de `?`" #: src/SUMMARY.md:175 src/error/multiple_error_types/wrap_error.md:1 msgid "Wrapping errors" msgstr "Envolviendo errores" #: src/SUMMARY.md:176 src/error/iter_result.md:1 msgid "Iterating over `Result`s" msgstr "Iterando sobre `Result`s" #: src/SUMMARY.md:178 src/std.md:1 msgid "Std library types" msgstr "Tipos de la biblioteca std" #: src/SUMMARY.md:179 src/std/box.md:1 msgid "Box, stack and heap" msgstr "Box, stack y heap" #: src/SUMMARY.md:180 src/std/vec.md:1 msgid "Vectors" msgstr "Vectores" #: src/SUMMARY.md:181 src/std/str.md:1 msgid "Strings" msgstr "Cadenas" #: src/SUMMARY.md:182 src/std/option.md:1 msgid "`Option`" msgstr "`Option`" #: src/SUMMARY.md:184 src/std/result/question_mark.md:1 msgid "`?`" msgstr "`?`" #: src/SUMMARY.md:185 src/std/panic.md:1 msgid "`panic!`" msgstr "" #: src/SUMMARY.md:186 src/std/hash.md:1 msgid "HashMap" msgstr "" #: src/SUMMARY.md:187 src/std/hash/alt_key_types.md:1 msgid "Alternate/custom key types" msgstr "Tipos de llaves personalizadas/alternas" #: src/SUMMARY.md:188 src/std/hash/hashset.md:1 msgid "HashSet" msgstr "" #: src/SUMMARY.md:189 src/std/rc.md:1 msgid "`Rc`" msgstr "" #: src/SUMMARY.md:190 msgid "`Arc`" msgstr "" #: src/SUMMARY.md:192 src/std_misc.md:1 msgid "Std misc" msgstr "" #: src/SUMMARY.md:193 src/std_misc.md:6 src/std_misc/threads.md:1 msgid "Threads" msgstr "Hilos" #: src/SUMMARY.md:194 src/std_misc/threads/testcase_mapreduce.md:1 msgid "Testcase: map-reduce" msgstr "Ejemplo: map-reduce" #: src/SUMMARY.md:195 src/std_misc.md:7 src/std_misc/channels.md:1 msgid "Channels" msgstr "Canales" #: src/SUMMARY.md:196 src/std_misc/path.md:1 msgid "Path" msgstr "" #: src/SUMMARY.md:197 src/std_misc.md:8 src/std_misc/file.md:1 msgid "File I/O" msgstr "" #: src/SUMMARY.md:198 src/std_misc/file/open.md:1 msgid "`open`" msgstr "" #: src/SUMMARY.md:199 src/std_misc/file/create.md:1 msgid "`create`" msgstr "" #: src/SUMMARY.md:200 src/std_misc/file/read_lines.md:1 msgid "`read_lines`" msgstr "" #: src/SUMMARY.md:201 src/std_misc/process.md:1 msgid "Child processes" msgstr "Procesos hijos" #: src/SUMMARY.md:202 src/std_misc/process/pipe.md:1 msgid "Pipes" msgstr "" #: src/SUMMARY.md:203 src/std_misc/process/wait.md:1 msgid "Wait" msgstr "" #: src/SUMMARY.md:204 src/std_misc/fs.md:1 msgid "Filesystem Operations" msgstr "Operaciones de Sistema Operativo" #: src/SUMMARY.md:205 src/std_misc/arg.md:1 msgid "Program arguments" msgstr "Argumentos del Programa" #: src/SUMMARY.md:206 src/std_misc/arg/matching.md:1 msgid "Argument parsing" msgstr "Parse de argumentos" #: src/SUMMARY.md:207 src/std_misc/ffi.md:1 msgid "Foreign Function Interface" msgstr "" #: src/SUMMARY.md:209 src/cargo/test.md:1 src/testing.md:1 msgid "Testing" msgstr "Pruebas" #: src/SUMMARY.md:210 src/testing/unit_testing.md:1 msgid "Unit testing" msgstr "Pruebas Unitarias" #: src/SUMMARY.md:211 src/testing/doc_testing.md:1 msgid "Documentation testing" msgstr "Pruebas de Documentación" #: src/SUMMARY.md:212 src/testing/integration_testing.md:1 msgid "Integration testing" msgstr "Pruebas de integración" #: src/SUMMARY.md:213 msgid "Dev-dependencies" msgstr "Dependencias de desarrollo" #: src/SUMMARY.md:215 src/unsafe.md:1 msgid "Unsafe Operations" msgstr "Operaciones Unsafe" #: src/SUMMARY.md:216 src/unsafe/asm.md:1 msgid "Inline assembly" msgstr "Ensamblador Inline" #: src/SUMMARY.md:218 src/compatibility.md:1 msgid "Compatibility" msgstr "Compatibilidad " #: src/SUMMARY.md:219 src/compatibility/raw_identifiers.md:1 msgid "Raw identifiers" msgstr "Identificadores llanos" #: src/SUMMARY.md:221 src/meta.md:1 msgid "Meta" msgstr "" #: src/SUMMARY.md:222 src/meta/doc.md:1 msgid "Documentation" msgstr "Documentación" #: src/SUMMARY.md:223 src/meta/playground.md:1 msgid "Playground" msgstr "" #: src/index.md:1 msgid "Rust by Example" msgstr "" #: src/index.md:3 msgid "" "[Rust](https://www.rust-lang.org/) is a modern systems programming language " "focusing on safety, speed, and concurrency. It accomplishes these goals by " "being memory safe without using garbage collection." msgstr "" "[Rust] (https://www.rust-lang.org/) es un lenguaje de programación de " "sistemas modernosconcentrado en la seguridad, la velocidad y la " "concurrencia. Logra estos objetivos altener seguridad de memoria sin usar la " "recolección de basura." #: src/index.md:7 msgid "" "Rust by Example (RBE) is a collection of runnable examples that illustrate " "various Rust concepts and standard libraries. To get even more out of these " "examples, don't forget to [install Rust locally](https://www.rust-lang.org/" "tools/install) and check out the [official docs](https://doc.rust-lang.org/" "std/). Additionally for the curious, you can also [check out the source code " "for this site](https://github.com/rust-lang/rust-by-example)." msgstr "" "Rust By Example (RBE) es una colección de ejemplos ejecutables que " "ilustranvarios conceptos de Rust y sus biblioteca estándar. Para obtener aún " "más de estosejemplos, no olvide [instalar Rust localmente] (https://www.rust-" "lang.org/tools/install) y consulte los [documentos oficiales](https://doc." "rust-lang.org/std/). Además, para la gente curiosa, también puede [ver el " "código fuentepara este sitio](https://github.com/rust-lang/rust-by-example)." #: src/index.md:12 msgid "Now let's begin!" msgstr "¡Comencemos!" #: src/index.md:14 msgid "[Hello World](hello.md) - Start with a traditional Hello World program." msgstr "" "[Hola Mundo](hello.md) - Empieza con el programa tradicional Hola Mundo." #: src/index.md:16 msgid "" "[Primitives](primitives.md) - Learn about signed integers, unsigned integers " "and other primitives." msgstr "" "[Primitivas](primitives.md) - Aprende sobre enteros con signo, enteros sin " "signo y otras primitivas." #: src/index.md:18 msgid "[Custom Types](custom_types.md) - `struct` and `enum`." msgstr "[Tipos Personalizados](custom_types.md) - `struct` y `enum`." #: src/index.md:20 msgid "" "[Variable Bindings](variable_bindings.md) - mutable bindings, scope, " "shadowing." msgstr "" "[Enlaces de Variables](variable_bindings.md) - enlaces mutables, alcance, " "sombreo." #: src/index.md:22 msgid "[Types](types.md) - Learn about changing and defining types." msgstr "[Tipos](types.md) - Aprende sobre cómo cambiar y definir tipos." #: src/index.md:24 msgid "" "[Conversion](conversion.md) - Convert between different types, such as " "strings, integers, and floats." msgstr "" "[Conversión](conversion.md) - Convertir entre diferentes tipos, como " "cadenas, enteros y flotantes." #: src/index.md:26 msgid "" "[Expressions](expression.md) - Learn about Expressions & how to use them." msgstr "" "[Expresiones](expression.md) - Aprenda sobre expresiones y cómo usarlas." #: src/index.md:28 msgid "[Flow of Control](flow_control.md) - `if`/`else`, `for`, and others." msgstr "[Control de Flujo](flow_control.md) - `if`/`else`, `for`, y otros." #: src/index.md:30 msgid "" "[Functions](fn.md) - Learn about Methods, Closures and Higher Order " "Functions." msgstr "" "[Funciones](fn.md) - Aprender sobre métodos, closures y Funciones de Orden " "Superior." #: src/index.md:32 msgid "[Modules](mod.md) - Organize code using modules" msgstr "[Módulos](mod.md) - Organizar código usando módulos" #: src/index.md:34 msgid "" "[Crates](crates.md) - A crate is a compilation unit in Rust. Learn to create " "a library." msgstr "" "[Crates](crates.md) - Una caja es una unidad de compilación en Rust. Aprende " "a crear una biblioteca." #: src/index.md:36 msgid "" "[Cargo](cargo.md) - Go through some basic features of the official Rust " "package management tool." msgstr "" "[Cargo](cargo.md) - Realice algunas características básicas de la " "herramienta de Rust oficial gestión de paquetes." #: src/index.md:38 msgid "" "[Attributes](attribute.md) - An attribute is metadata applied to some " "module, crate or item." msgstr "" "[Atributos](attribute.md) - Un atributo son metadatos aplicados a algún " "módulo, crate o ítem." #: src/index.md:40 msgid "" "[Generics](generics.md) - Learn about writing a function or data type which " "can work for multiple types of arguments." msgstr "" "[Genéricos](generics.md) - Aprenda a escribir una función o tipo de datos " "que puede funcionar para múltiples tipos de argumentos." #: src/index.md:42 msgid "" "[Scoping rules](scope.md) - Scopes play an important part in ownership, " "borrowing, and lifetimes." msgstr "" "[Reglas de alcance](scope.md) - Los alcances juegan un papel importante del " "ownership, borrowing y lifetimes." #: src/index.md:44 msgid "" "[Traits](trait.md) - A trait is a collection of methods defined for an " "unknown type: `Self`" msgstr "" "[Traits](trait.md) - Un trait es una colección de métodos definidos para un " "tipo desconocido: 'Self'" #: src/index.md:46 msgid "" "[Macros](macros.md) - Macros are a way of writing code that writes other " "code, which is known as metaprogramming." msgstr "" "[Macros](macros.md) - Las macros son una forma de escribir código que " "escribe a otroscódigos, lo cual se conoce como metaprogramación." #: src/index.md:48 msgid "[Error handling](error.md) - Learn Rust way of handling failures." msgstr "[Manejo de Errores](error.md) - Aprende a manejar errores con Rust." #: src/index.md:50 msgid "" "[Std library types](std.md) - Learn about some custom types provided by " "`std` library." msgstr "" "[Tipos de la librería std](std.md) - Aprenda sobre algunos tipos de la " "librería`std`." #: src/index.md:52 msgid "[Std misc](std_misc.md) - More custom types for file handling, threads." msgstr "" "[Std misc](std_misc.md) - Más tipos personalizados para el manejo de " "archivos, hilos." #: src/index.md:54 #, fuzzy msgid "[Testing](testing.md) - All sorts of testing in Rust." msgstr "[Pruebas](testing.md) - Todo tipo de pruebas en Rust." #: src/index.md:56 msgid "" "[Unsafe Operations](unsafe.md) - Learn about entering a block of unsafe " "operations." msgstr "" "[Operaciones Unsafe](unsafe.md) - Aprenda sobre el uso de bloques de " "operaciones unsafe." #: src/index.md:58 msgid "" "[Compatibility](compatibility.md) - Handling Rust's evolution and potential " "compatibility issues." msgstr "" "[Compatibilidad](compatibility.md) - Manejo de la evolución de Rust y " "potenciales problemas de compatibilidad." #: src/index.md:60 msgid "[Meta](meta.md) - Documentation, Benchmarking." msgstr "[Meta](meta.md) - Documentación, Benchmarking." #: src/hello.md:3 msgid "This is the source code of the traditional Hello World program." msgstr "Este es el código fuente del programa tradicional Hello World." #: src/hello.md:6 msgid "" "// This is a comment, and is ignored by the compiler.\n" "// You can test this code by clicking the \"Run\" button over there ->\n" "// or if you prefer to use your keyboard, you can use the \"Ctrl + Enter\"\n" "// shortcut.\n" msgstr "" "// Este es un comentario, y es ignorado por el compilador.\n" "// Puede probar este código haciendo clic en el botón \"Run\" allí -> \n" "// o si prefiere usar su teclado, puede usar el atajo \"Ctrl + Enter\".\n" #: src/hello.md:10 msgid "" "// This code is editable, feel free to hack it!\n" "// You can always return to the original code by clicking the \"Reset\" " "button ->\n" msgstr "" "// Este código es editable, ¡siéntete libre de hackearlo!\n" "// Siempre puede volver al código original haciendo clic en \"Reset\" botón -" "> \n" #: src/hello.md:13 msgid "// This is the main function.\n" msgstr "// Esta es la función main" #: src/hello.md:16 msgid "// Statements here are executed when the compiled binary is called.\n" msgstr "" "// Las oraciones aquí se ejecutan cuando el binario compilado es llamado.\n" #: src/hello.md:18 msgid "// Print text to the console.\n" msgstr "// Imprime el texto a la consola.\n" #: src/hello.md:19 src/error/result.md:55 src/meta/playground.md:12 msgid "\"Hello World!\"" msgstr "\"Hello World!\"" #: src/hello.md:23 msgid "`println!` is a [_macro_](macros.md) that prints text to the console." msgstr "`println!` es un [_macro_](macros.md) que imprime text a la consola." #: src/hello.md:26 msgid "A binary can be generated using the Rust compiler: `rustc`." msgstr "Un binario se puede generar usand el compilador de Rust: `rustc`." #: src/hello.md:32 msgid "`rustc` will produce a `hello` binary that can be executed." msgstr "`rustc` producirá un binario `hello` que puede ser ejecutado." #: src/hello.md:39 src/hello/print/print_display.md:107 #: src/hello/print/print_display/testcase_list.md:53 src/hello/print/fmt.md:70 #: src/primitives/tuples.md:64 src/custom_types/structs.md:89 msgid "Activity" msgstr "Actividad" #: src/hello.md:41 msgid "" "Click 'Run' above to see the expected output. Next, add a new line with a " "second `println!` macro so that the output shows:" msgstr "" "Haga clic en 'Run' arriba para ver la salida esperada. A continuación, " "agregue una nueva línea con unsegundo `println!` macro para que la salida " "muestre:" #: src/hello/comment.md:3 msgid "" "Any program requires comments, and Rust supports a few different varieties:" msgstr "" "Cualquier programa requiere comentarios, y Rust admite algunas variedades " "diferentes:" #: src/hello/comment.md:6 msgid "_Regular comments_ which are ignored by the compiler:" msgstr "_Comentarios regulares_ que el compilador ignora:" #: src/hello/comment.md:7 msgid "`// Line comments which go to the end of the line.`" msgstr "`// Comentarios de línea que van al final de la línea.`" #: src/hello/comment.md:8 msgid "`/* Block comments which go to the closing delimiter. */`" msgstr "`/* Comentarios de bloque que van al delimitador de cierre. */`" #: src/hello/comment.md:9 msgid "" "_Doc comments_ which are parsed into HTML library [documentation](../meta/" "doc.md):" msgstr "" "_Comentarios de Doc_ que se parsean en la librería HTML [documentation](../ " "meta/doc.md):" #: src/hello/comment.md:10 msgid "`/// Generate library docs for the following item.`" msgstr "`/// Genera docs de librería para el siguiente elemento.`" #: src/hello/comment.md:11 msgid "`//! Generate library docs for the enclosing item.`" msgstr "`//! Genera docs de librería para el artículo adjunto.`" #: src/hello/comment.md:15 msgid "" "// This is an example of a line comment.\n" " // There are two slashes at the beginning of the line.\n" " // And nothing written after these will be read by the compiler.\n" msgstr "" "// Este es un ejemplo de un comentario de línea.\n" " // Hay dos slashes al comienzo de la línea.\n" " // y nada escrito después de estos será leído por el compilador.\n" #: src/hello/comment.md:19 msgid "// println!(\"Hello, world!\");\n" msgstr "" #: src/hello/comment.md:21 msgid "// Run it. See? Now try deleting the two slashes, and run it again.\n" msgstr "" "// Ejecútalo. ¿Ves? Ahora intenta eliminar las dos barras y ejecútalo " "nuevamente.\n" #: src/hello/comment.md:23 msgid "" "/*\n" " * This is another type of comment, a block comment. In general,\n" " * line comments are the recommended comment style. But block comments\n" " * are extremely useful for temporarily disabling chunks of code.\n" " * /* Block comments can be /* nested, */ */ so it takes only a few\n" " * keystrokes to comment out everything in this main() function.\n" " * /*/*/* Try it yourself! */*/*/\n" " */" msgstr "" "/*\n" "orte * Este es otro tipo de comentario, un comentario en bloque. En " "general,\n" " * los comentarios de línea son el estilo de comentarios recomendado. " "Pero los comentarios de bloque\n" " * son extremadamente útiles para deshabilitar temporalmente los " "segmentos de código.\n" " * /* Los comentarios de bloque pueden ser /* anidados, */ */ por lo que " "solo se necesitan unos pocos\n" " * teclazos para comentar todo en esta función main().\n" " * /*/*/*¡Pruébalo! */*/*/\n" " */" #: src/hello/comment.md:32 msgid "" "/*\n" " Note: The previous column of `*` was entirely for style. There's\n" " no actual need for it.\n" " */" msgstr "" "/*\n" " Nota: la columna anterior a `*` es completamente por estilo. No hay\n" " hay necesidad real para ello. \n" " */" #: src/hello/comment.md:37 msgid "" "// You can manipulate expressions more easily with block comments\n" " // than with line comments. Try deleting the comment delimiters\n" " // to change the result:\n" msgstr "" "// Puede manipular expresiones más fácilmente con comentarios de bloque \n" " // que con comentarios de línea. Intente eliminar los delimitadores de " "comentarios\n" " // para cambiar el resultado:\n" #: src/hello/comment.md:40 msgid "/* 90 + */" msgstr "" #: src/hello/comment.md:41 msgid "\"Is `x` 10 or 100? x = {}\"" msgstr "\"¿Es `x` 10 ó 100? x = {}\"" #: src/hello/comment.md:45 src/hello/print.md:103 #: src/hello/print/print_debug.md:75 src/hello/print/print_display.md:118 #: src/hello/print/print_display/testcase_list.md:62 src/hello/print/fmt.md:89 #: src/primitives.md:64 src/custom_types/enum.md:100 #: src/custom_types/enum/enum_use.md:45 src/custom_types/enum/c_like.md:33 #: src/custom_types/enum/testcase_linked_list.md:77 #: src/custom_types/constants.md:35 src/types/alias.md:30 #: src/flow_control/for.md:121 #: src/flow_control/match/destructuring/destructure_tuple.md:25 #: src/flow_control/match/destructuring/destructure_slice.md:46 #: src/flow_control/match/destructuring/destructure_enum.md:48 #: src/flow_control/match/destructuring/destructure_pointers.md:63 #: src/flow_control/match/destructuring/destructure_structures.md:45 #: src/flow_control/match/guard.md:43 src/flow_control/match/binding.md:49 #: src/flow_control/if_let.md:118 src/flow_control/let_else.md:55 #: src/flow_control/while_let.md:56 src/fn/closures/capture.md:110 #: src/fn/closures/input_parameters.md:84 src/fn/closures/anonymity.md:47 #: src/fn/closures/input_functions.md:32 #: src/fn/closures/output_parameters.md:49 #: src/fn/closures/closure_examples/iter_any.md:50 #: src/fn/closures/closure_examples/iter_find.md:68 #: src/mod/struct_visibility.md:53 src/attribute/cfg.md:39 src/generics.md:59 #: src/generics/gen_fn.md:54 src/generics/impl.md:48 #: src/generics/gen_trait.md:39 src/generics/bounds.md:73 #: src/generics/bounds/testcase_empty.md:37 src/generics/multi_bounds.md:32 #: src/generics/where.md:49 src/generics/new_types.md:54 #: src/generics/assoc_items.md:10 src/generics/assoc_items/the_problem.md:62 #: src/generics/phantom.md:56 src/generics/phantom/testcase_units.md:75 #: src/scope/raii.md:92 src/scope/move/partial_move.md:57 #: src/scope/borrow/mut.md:56 src/scope/lifetime/explicit.md:68 #: src/scope/lifetime/fn.md:58 src/scope/lifetime/methods.md:24 #: src/scope/lifetime/struct.md:41 src/scope/lifetime/trait.md:28 #: src/scope/lifetime/lifetime_bounds.md:46 #: src/scope/lifetime/static_lifetime.md:133 src/scope/lifetime/elision.md:39 #: src/trait/derive.md:65 src/trait/supertraits.md:40 #: src/trait/disambiguating.md:60 src/error/option_unwrap/map.md:79 #: src/error/option_unwrap/and_then.md:73 #: src/error/option_unwrap/defaults.md:115 src/error/result/result_alias.md:41 #: src/error/multiple_error_types/boxing_errors.md:57 #: src/error/multiple_error_types/reenter_question_mark.md:74 #: src/error/multiple_error_types/wrap_error.md:91 src/std.md:12 #: src/std/rc.md:55 src/std_misc.md:12 #: src/std_misc/threads/testcase_mapreduce.md:129 src/std_misc/path.md:54 #: src/std_misc/fs.md:150 src/meta/doc.md:109 src/meta/playground.md:49 msgid "See also:" msgstr "Ver también" #: src/hello/comment.md:47 msgid "[Library documentation](../meta/doc.md)" msgstr "[Documentación de Librerías](../meta/doc.md)" #: src/hello/print.md:3 msgid "" "Printing is handled by a series of [`macros`](../macros.md) defined in " "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) some of which are:" msgstr "" "La impresión se maneja por una serie de [`macros`](../macros.md) definida " "en[`std::fmt`](https://doc.rust-lang.org/std/fmt/) algunos de los cuales " "son: " #: src/hello/print.md:6 msgid "`format!`: write formatted text to [`String`](../std/str.md)" msgstr "`format!`: escribe el texto formateado a un [`String`](../std/str.md)" #: src/hello/print.md:7 msgid "" "`print!`: same as `format!` but the text is printed to the console (io::" "stdout)." msgstr "" "`print!`: igual que `format!` pero el texto se imprime a la consola (io::" "stdout)." #: src/hello/print.md:9 msgid "`println!`: same as `print!` but a newline is appended." msgstr "`println!`: es igual que `print!` pero se agrega un salto de línea" #: src/hello/print.md:10 msgid "" "`eprint!`: same as `print!` but the text is printed to the standard error " "(io::stderr)." msgstr "" "`eprint!`: igual que `print!` pero el texto se imprime al error estándar " "(io::stderr)." #: src/hello/print.md:12 msgid "`eprintln!`: same as `eprint!` but a newline is appended." msgstr "`eprintln!`: es igual que `eprint!` pero se agrega un salto de línea" #: src/hello/print.md:14 #, fuzzy msgid "" "All parse text in the same fashion. As a plus, Rust checks formatting " "correctness at compile time." msgstr "" "Parsea todo el texta de la misma manera. Como beneficio, Rust verifica el " "formato // de los argumentos. Serán convertidos en cadenas.\n" #: src/hello/print.md:19 #, fuzzy msgid "" "// In general, the `{}` will be automatically replaced with any\n" " // arguments. These will be stringified.\n" msgstr "" "Parsea todo el texta de la misma manera. Como beneficio, Rust verifica el " "formato // de los argumentos. Serán convertidos en cadenas.\n" #: src/hello/print.md:21 msgid "\"{} days\"" msgstr "\"{} días\"" #: src/hello/print.md:23 msgid "" "// Positional arguments can be used. Specifying an integer inside `{}`\n" " // determines which additional argument will be replaced. Arguments " "start\n" " // at 0 immediately after the format string.\n" msgstr "" "// Se pueden usar argumentos posicionales. Especificar un entero dentro de " "`{}`\n" " // determina qué argumento adicional será reemplazado. Los " "argumentoscomienzan \n" " // en 0 inmediatamente después de la cadena de formato.\n" #: src/hello/print.md:26 msgid "\"{0}, this is {1}. {1}, this is {0}\"" msgstr "\"{0}, esto es {1}. {1}, este es {0}\"" #: src/hello/print.md:26 src/scope/move/partial_move.md:31 msgid "\"Alice\"" msgstr "\"Alice\"" #: src/hello/print.md:26 src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Bob\"" msgstr "\"Bob\"" #: src/hello/print.md:28 msgid "// As can named arguments.\n" msgstr "// Como los argumentos nombrados.\n" #: src/hello/print.md:29 msgid "\"{subject} {verb} {object}\"" msgstr "\"{sujeto} {verbo} {objeto}\"" #: src/hello/print.md:30 msgid "\"the lazy dog\"" msgstr "" #: src/hello/print.md:31 msgid "\"the quick brown fox\"" msgstr "" #: src/hello/print.md:32 msgid "\"jumps over\"" msgstr "" #: src/hello/print.md:34 msgid "" "// Different formatting can be invoked by specifying the format character\n" " // after a `:`.\n" msgstr "" "// Se puede invocar diferentes formatos especificando el carácter del " "formato\n" " // después de un `:`.\n" #: src/hello/print.md:36 msgid "\"Base 10: {}\"" msgstr "" #: src/hello/print.md:36 msgid "// 69420\n" msgstr "" #: src/hello/print.md:37 msgid "\"Base 2 (binary): {:b}\"" msgstr "\"Base 2 (binario): {:b}\"" #: src/hello/print.md:37 msgid "// 10000111100101100\n" msgstr "" #: src/hello/print.md:38 msgid "\"Base 8 (octal): {:o}\"" msgstr "" #: src/hello/print.md:38 msgid "// 207454\n" msgstr "" #: src/hello/print.md:39 msgid "\"Base 16 (hexadecimal): {:x}\"" msgstr "" #: src/hello/print.md:39 msgid "// 10f2c\n" msgstr "" #: src/hello/print.md:41 msgid "" "// You can right-justify text with a specified width. This will\n" " // output \" 1\". (Four white spaces and a \"1\", for a total width " "of 5.)\n" msgstr "" "// Puedes justificar el texto a la derecha con un ancho especificado. Esto " "será\n" "// salida \" 1 \". (Cuatro espacios blancos y un \"1\", para un ancho " "totalde 5.)\n" #: src/hello/print.md:43 msgid "\"{number:>5}\"" msgstr "\"{numero:>5}\"" #: src/hello/print.md:45 msgid "// You can pad numbers with extra zeroes,\n" msgstr "// Puedes rellenar números con ceros adicionales,\n" #: src/hello/print.md:46 msgid "\"{number:0>5}\"" msgstr "\"{numero:0>5}\"" #: src/hello/print.md:46 msgid "" "// 00001\n" " // and left-adjust by flipping the sign. This will output \"10000\".\n" msgstr "" "// 00001\n" " // y justificar a la izquierda volteando el signo. Esto imprimirá " "\"10000\".\n" #: src/hello/print.md:48 msgid "\"{number:0<5}\"" msgstr "\"{numero:0<5}\"" #: src/hello/print.md:48 msgid "// 10000\n" msgstr "" #: src/hello/print.md:50 msgid "" "// You can use named arguments in the format specifier by appending a `$`.\n" msgstr "" "// Puede usar argumentos con nombre en el formato especificador agregando un " "`$`.\n" #: src/hello/print.md:51 msgid "\"{number:0>width$}\"" msgstr "\"{numero:0>ancho$}\"" #: src/hello/print.md:53 msgid "" "// Rust even checks to make sure the correct number of arguments are used.\n" msgstr "" "// Rust incluso verifica para asegurarse de que se usen el número correcto " "de argumentos.\n" #: src/hello/print.md:54 msgid "\"My name is {0}, {1} {0}\"" msgstr "\"Mi nombre es {0}, {1} {0}\"" #: src/hello/print.md:54 msgid "\"Bond\"" msgstr "" #: src/hello/print.md:55 msgid "// FIXME ^ Add the missing argument: \"James\"\n" msgstr "" #: src/hello/print.md:57 msgid "" "// Only types that implement fmt::Display can be formatted with `{}`. User-\n" " // defined types do not implement fmt::Display by default.\n" msgstr "" "// Sólo los tipos que implementan `fmt::Display` pueden formatearse con `{}" "`.\n" " // Los tipos definidos por usuario no implementan `fmt::Display` de forma " "predeterminada.\n" #: src/hello/print.md:60 msgid "// disable `dead_code` which warn against unused module\n" msgstr "// deshabilita `dead_code` el cual advierte contra módulos no usados\n" #: src/hello/print.md:63 msgid "" "// This will not compile because `Structure` does not implement\n" " // fmt::Display.\n" " // println!(\"This struct `{}` won't print...\", Structure(3));\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// Esto no se compilará porque `Structure` no implementa \n" " // `fmt::Display`.\n" " // println!(\"esta estructura `{}` no va a imprimir... \", " "Structure(3));\n" " // TAREA ^ intente quitar el comentario de esta línea \n" #: src/hello/print.md:68 msgid "" "// For Rust 1.58 and above, you can directly capture the argument from a\n" " // surrounding variable. Just like the above, this will output\n" " // \" 1\", 4 white spaces and a \"1\".\n" msgstr "" "// Para Rust 1.58 y superior, puedes capturar directamente el argumento de " "una\n" "// variable en el entorno. Al igual que lo anterior, esto imprimirá \n" "// \" 1\", 4 espacios blancos y a \"1\".\n" #: src/hello/print.md:73 msgid "\"{number:>width$}\"" msgstr "\"{numero:>ancho$}\"" #: src/hello/print.md:77 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) contains many [`traits`]" "(https://doc.rust-lang.org/std/fmt/#formatting-traits) which govern the " "display of text. The base form of two important ones are listed below:" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) contiene muchos [`traits`]" "(https://doc.rust-lang.org/std/fmt/#formatting-traits) que rigen la " "visualización de texto. La forma básica de dos de ellos se enumera a " "continuación:" #: src/hello/print.md:80 msgid "" "`fmt::Debug`: Uses the `{:?}` marker. Format text for debugging purposes." msgstr "" "`fmt::Debug`: Usa el marcador `{:?}`. Formatea el texto para fines de " "depuración." #: src/hello/print.md:81 msgid "" "`fmt::Display`: Uses the `{}` marker. Format text in a more elegant, user " "friendly fashion." msgstr "" "`fmt::Display`: Usa el marcador `{}`. Formatea texto de una manera más " "elegante y amistosa." #: src/hello/print.md:84 msgid "" "Here, we used `fmt::Display` because the std library provides " "implementations for these types. To print text for custom types, more steps " "are required." msgstr "" "Aquí, usamos `fmt::Display` porque la librería std proporciona " "implementaciones para estos tipos. Para imprimir tipos personalizados, más " "pasosson necesarios" #: src/hello/print.md:87 msgid "" "Implementing the `fmt::Display` trait automatically implements the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "which allows us to [convert](../conversion/string.md) the type to [`String`]" "(../std/str.md)." msgstr "" "Implementar el rasgo `fmt::Display` implementa automáticamente el trait " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) que " "nos permite [convertir](../conversion/string.md) el tipo en [`String`](../" "std/str.md)." #: src/hello/print.md:90 msgid "" "In _line 43_, `#[allow(dead_code)]` is an [attribute](../attribute.md) which " "only applies to the module after it." msgstr "" "En la _línea 43_,`#[allow(dead_code)]` es un [atributo](../ attribute.md) " "quesolo se aplica al módulo después de él." #: src/hello/print.md:92 msgid "Activities" msgstr "Actividades" #: src/hello/print.md:94 msgid "" "Fix the issue in the above code (see FIXME) so that it runs without error." msgstr "" "Solucione el problema en el código anterior (ver el ARRÉGLAME) para que se " "ejecute sin error." #: src/hello/print.md:96 msgid "" "Try uncommenting the line that attempts to format the `Structure` struct " "(see TODO)" msgstr "" "Intente quitar el comentario de la línea que intenta formatear la estructura " "`Structure`(ver TAREA)" #: src/hello/print.md:98 msgid "" "Add a `println!` macro call that prints: `Pi is roughly 3.142` by " "controlling the number of decimal places shown. For the purposes of this " "exercise, use `let pi = 3.141592` as an estimate for pi. (Hint: you may need " "to check the [`std::fmt`](https://doc.rust-lang.org/std/fmt/) documentation " "for setting the number of decimals to display)" msgstr "" "Agregue un macro `println!` que imprima: ` Pi es aproximadamente 3.142` " "controlando el número de decimales mostrados. Para efectos de esteejercicio, " "use `let Pi = 3.141592` como una estimación para pi. (Sugerencia: " "puedesconsultar la documentación de [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/)para configurar el número de decimales desplegados)" #: src/hello/print.md:105 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`macros`](../macros.md), " "[`struct`](../custom_types/structs.md), [`traits`](https://doc.rust-lang.org/" "std/fmt/#formatting-traits), and [`dead_code`](../attribute/unused.md)" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`macros`](../macros.md), " "[`struct`](../custom_types/structs.md), [`traits`](https://doc.rust-lang.org/" "std/fmt/#formatting-traits), y [`dead_code`](../attribute/unused.md)" #: src/hello/print/print_debug.md:3 msgid "" "All types which want to use `std::fmt` formatting `traits` require an " "implementation to be printable. Automatic implementations are only provided " "for types such as in the `std` library. All others _must_ be manually " "implemented somehow." msgstr "" "Todos los tipos que quieren usar los traits de `std::fmt` requieren " "unaimplementación para ser imprimible. Las implementaciones automáticas solo " "se proporcionanpara tipos como en la biblioteca `std`. Todos los demás tipos " "_deben_ ser manualmente implementados de alguna manera." #: src/hello/print/print_debug.md:8 msgid "" "The `fmt::Debug` `trait` makes this very straightforward. _All_ types can " "`derive` (automatically create) the `fmt::Debug` implementation. This is not " "true for `fmt::Display` which must be manually implemented." msgstr "" "El trait `fmt::Debug` hace que esto sea muy sencillo. Todos Los tipos " "pueden`Derive` (crear automáticamente) la implementación `fmt::Debug`. Esto " "no ciertopara `fmt::Display` el cual debe implementarse manualmente." #: src/hello/print/print_debug.md:13 msgid "" "// This structure cannot be printed either with `fmt::Display` or\n" "// with `fmt::Debug`.\n" msgstr "" "// Esta estructura no se puede imprimir con `fmt::Display` o \n" "// con `fmt::Debug`.\n" " " #: src/hello/print/print_debug.md:16 msgid "" "// The `derive` attribute automatically creates the implementation\n" "// required to make this `struct` printable with `fmt::Debug`.\n" msgstr "" "// El atributo `derive` crea automáticamente la implementación \n" " // requerida para hacer esta `struct` imprimible con `fmt::Debug`. \n" #: src/hello/print/print_debug.md:23 msgid "All `std` library types are automatically printable with `{:?}` too:" msgstr "" "Todos los tipos de biblioteca `std` se pueden imprimir automáticamente con " "`{:?}` también:" #: src/hello/print/print_debug.md:26 msgid "" "// Derive the `fmt::Debug` implementation for `Structure`. `Structure`\n" "// is a structure which contains a single `i32`.\n" msgstr "" "// Derive la implementación `fmt::Debug` para `Structure`. `Structure`\n" "// es una estructura que contiene un solo `i32`.\n" " " #: src/hello/print/print_debug.md:30 msgid "" "// Put a `Structure` inside of the structure `Deep`. Make it printable\n" "// also.\n" msgstr "" "// Ponga una `Structure` dentro de la estructura `Deep`. Házlo imprimible \n" "// también.\n" #: src/hello/print/print_debug.md:37 msgid "// Printing with `{:?}` is similar to with `{}`.\n" msgstr "// Imprimir con `{:?}` es similar a imprimir con `{}`.\n" #: src/hello/print/print_debug.md:38 msgid "\"{:?} months in a year.\"" msgstr "\"{:?} meses en un año.\"" #: src/hello/print/print_debug.md:39 msgid "\"{1:?} {0:?} is the {actor:?} name.\"" msgstr "\"{1:?} {0:?} es el nombre del {actor:?}.\"" #: src/hello/print/print_debug.md:40 msgid "\"Slater\"" msgstr "" #: src/hello/print/print_debug.md:41 msgid "\"Christian\"" msgstr "" #: src/hello/print/print_debug.md:42 msgid "\"actor's\"" msgstr "" #: src/hello/print/print_debug.md:44 msgid "// `Structure` is printable!\n" msgstr "// ¡`Structure` también se puede imprimir!\n" #: src/hello/print/print_debug.md:45 src/hello/print/print_debug.md:49 msgid "\"Now {:?} will print!\"" msgstr "\"Ahora {:?} imprimirá \"" #: src/hello/print/print_debug.md:47 msgid "" "// The problem with `derive` is there is no control over how\n" " // the results look. What if I want this to just show a `7`?\n" msgstr "" "// El problema con 'derive` es que no hay control sobre cómo \n" " // los resultados se ven. ¿Qué pasa si quiero que esto solo muestre un " "`7`?\n" #: src/hello/print/print_debug.md:53 msgid "" "So `fmt::Debug` definitely makes this printable but sacrifices some " "elegance. Rust also provides \"pretty printing\" with `{:#?}`." msgstr "" "Entonces `fmt::Debug` definitivamente hace esto imprimible pero sacrifica " "algo deelegancia. Rust también proporciona \"Impresión Bonita\" con `{:#?}`." #: src/hello/print/print_debug.md:64 src/custom_types/structs.md:42 msgid "\"Peter\"" msgstr "" #: src/hello/print/print_debug.md:68 msgid "// Pretty print\n" msgstr "// Impresión bonita" #: src/hello/print/print_debug.md:69 msgid "\"{:#?}\"" msgstr "" #: src/hello/print/print_debug.md:73 msgid "One can manually implement `fmt::Display` to control the display." msgstr "" "Se puede implementar manualmente `fmt::Display` para controlar la impresión." #: src/hello/print/print_debug.md:77 msgid "" "[`attributes`](https://doc.rust-lang.org/reference/attributes.html), " "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), and [`struct`](../../custom_types/structs.md)" msgstr "" "[`attributes`](https://doc.rust-lang.org/reference/attributes.html), " "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), y [`struct`](../../custom_types/structs.md)" #: src/hello/print/print_display.md:3 msgid "" "`fmt::Debug` hardly looks compact and clean, so it is often advantageous to " "customize the output appearance. This is done by manually implementing " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/), which uses the `{}` " "print marker. Implementing it looks like this:" msgstr "" "`fmt::Debug` escasamente parece compacto y limpio, por lo que a menudo es " "ventajoso personalizar la apariencia de salida. Esto se hace implementando " "manualmente[`fmt::Display`](https://doc.rust-lang.org/std/fmt/), que usa el " "marcador `{}`. Implementarlo se ve así:" #: src/hello/print/print_display.md:9 msgid "// Import (via `use`) the `fmt` module to make it available.\n" msgstr "" "// Importar (a través de `use`) el módulo `fmt` para ponerlo a disposición.\n" #: src/hello/print/print_display.md:11 msgid "" "// Define a structure for which `fmt::Display` will be implemented. This is\n" "// a tuple struct named `Structure` that contains an `i32`.\n" msgstr "" "// Defina una estructura para la cual se implementará `fmt::Display`. Esto " "es\n" " // una estructura de tupla llamada `Estructura` que contiene un `i32`. \n" #: src/hello/print/print_display.md:15 msgid "" "// To use the `{}` marker, the trait `fmt::Display` must be implemented\n" "// manually for the type.\n" msgstr "" "// Para usar el marcador `{}`, el trait `fmt::Display` debe implementarse\n" "// manualmente para el tipo. \n" #: src/hello/print/print_display.md:19 msgid "// This trait requires `fmt` with this exact signature.\n" msgstr "// Este trait requiere de `fmt` con estos tipos exactos.\n" #: src/hello/print/print_display.md:21 msgid "" "// Write strictly the first element into the supplied output\n" " // stream: `f`. Returns `fmt::Result` which indicates whether the\n" " // operation succeeded or failed. Note that `write!` uses syntax " "which\n" " // is very similar to `println!`.\n" msgstr "" "// Escribe sólo el primer elemento en la salida suministrada \n" "// stream: `f`. Devuelve `fmt::Result` que indica si\n" "// la operación tuvo éxito o falló. Tenga en cuenta que 'write!` usa una " "sintaxis que \n" "// es muy similar a `println!`. \n" #: src/hello/print/print_display.md:25 #: src/hello/print/print_display/testcase_list.md:13 #: src/hello/print/print_display/testcase_list.md:39 #: src/hello/print/print_display/testcase_list.md:49 src/hello/print/fmt.md:53 #: src/custom_types/enum/testcase_linked_list.md:73 src/conversion/string.md:25 #: src/flow_control/loop.md:26 src/flow_control/while.md:21 #: src/flow_control/for.md:23 src/flow_control/for.md:43 src/fn.md:40 #: src/fn/closures/capture.md:96 src/fn/closures/capture.md:97 #: src/fn/closures/anonymity.md:41 src/generics/bounds.md:12 #: src/macros/repeat.md:24 src/macros/repeat.md:25 src/macros/repeat.md:26 #: src/error/result.md:73 src/std/str.md:92 src/std/str.md:102 #: src/std/str.md:106 src/std/str.md:111 src/std/result.md:72 #: src/std/result/question_mark.md:57 src/std/result/question_mark.md:65 #: src/std_misc/file/read_lines.md:60 src/std_misc/arg/matching.md:9 #: src/std_misc/arg/matching.md:13 msgid "\"{}\"" msgstr "" #: src/hello/print/print_display.md:30 msgid "" "`fmt::Display` may be cleaner than `fmt::Debug` but this presents a problem " "for the `std` library. How should ambiguous types be displayed? For example, " "if the `std` library implemented a single style for all `Vec`, what style " "should it be? Would it be either of these two?" msgstr "" "`fmt::Display` puede ser más limpio que `fmt::Debug` pero esto presenta un " "problemapara la biblioteca `std`. ¿Cómo se deben mostrar los tipos ambiguos? " "Por ejemplo, si la biblioteca `std` implementó un sólo estilo para todos los " "`Vec`, ¿qué estilo debería ser? ¿Sería cualquiera de estos dos?" #: src/hello/print/print_display.md:35 msgid "`Vec`: `/:/etc:/home/username:/bin` (split on `:`)" msgstr "`Vec`: `/:/etc:/home/usuario:/bin` (split on `:`)" #: src/hello/print/print_display.md:36 msgid "`Vec`: `1,2,3` (split on `,`)" msgstr "`Vec`: `1,2,3` (partido en `,`)" #: src/hello/print/print_display.md:38 msgid "" "No, because there is no ideal style for all types and the `std` library " "doesn't presume to dictate one. `fmt::Display` is not implemented for " "`Vec` or for any other generic containers. `fmt::Debug` must then be used " "for these generic cases." msgstr "" "No, porque no hay un estilo ideal para todos los tipos y la biblioteca `std` " "no presume dictar uno. `fmt::Display` no se implementa para `Vec` o para " "cualquier otro contenedor genérico. `Fmt::Debug` debe usarse para estos " "casos genéricos." #: src/hello/print/print_display.md:43 msgid "" "This is not a problem though because for any new _container_ type which is " "_not_ generic, `fmt::Display` can be implemented." msgstr "" "Sin embargo, esto no es un problema porque para cualquier nuevo tipo " "_contenedor_ que sea_no_ genérico, se puede implementar `fmt::Display`." #: src/hello/print/print_display.md:47 msgid "// Import `fmt`\n" msgstr "// Importar `fmt`\n" #: src/hello/print/print_display.md:48 msgid "" "// A structure holding two numbers. `Debug` will be derived so the results " "can\n" "// be contrasted with `Display`.\n" msgstr "" "// Una estructura que contiene dos números. Se derivará `Debug` para que los " "resultadospuedan// ser contrastados con `Display`.\n" #: src/hello/print/print_display.md:53 msgid "// Implement `Display` for `MinMax`.\n" msgstr "// Implementa `Display` para `MinMax`.\n" #: src/hello/print/print_display.md:57 msgid "// Use `self.number` to refer to each positional data point.\n" msgstr "// Usa `self.number` para referirte a cada dato posicional.\n" #: src/hello/print/print_display.md:58 msgid "\"({}, {})\"" msgstr "" #: src/hello/print/print_display.md:61 msgid "// Define a structure where the fields are nameable for comparison.\n" msgstr "" "// Define una estructura donde los campos se puedan nombrar para " "compararse.\n" #: src/hello/print/print_display.md:68 msgid "// Similarly, implement `Display` for `Point2D`.\n" msgstr "// Similarmente, implementa `Display` para `Point2D`.\n" #: src/hello/print/print_display.md:72 msgid "// Customize so only `x` and `y` are denoted.\n" msgstr "// Personalízalo para que sólo `x` y `y` sean denotados.\n" #: src/hello/print/print_display.md:73 msgid "\"x: {}, y: {}\"" msgstr "" #: src/hello/print/print_display.md:80 msgid "\"Compare structures:\"" msgstr "\"Compara estructuras:\"" #: src/hello/print/print_display.md:81 src/hello/print/print_display.md:94 msgid "\"Display: {}\"" msgstr "" #: src/hello/print/print_display.md:82 src/hello/print/print_display.md:95 msgid "\"Debug: {:?}\"" msgstr "" #: src/hello/print/print_display.md:87 msgid "\"The big range is {big} and the small is {small}\"" msgstr "\"El rango grande es {big} y el pequeño es {small}\"" #: src/hello/print/print_display.md:93 msgid "\"Compare points:\"" msgstr "\" Compara Puntos:\"" #: src/hello/print/print_display.md:97 msgid "" "// Error. Both `Debug` and `Display` were implemented, but `{:b}`\n" " // requires `fmt::Binary` to be implemented. This will not work.\n" " // println!(\"What does Point2D look like in binary: {:b}?\", point);\n" msgstr "" "// Error. Ambos `Debug` y `Display` fueron implementados, pero `{:b}`\n" " // requiere implementar `fmt::Binary`. Esto no funcionará.\n" " // println!(\"¿Cómo se ve el Punto2D en binario: {:b}?\", point);\n" #: src/hello/print/print_display.md:103 msgid "" "So, `fmt::Display` has been implemented but `fmt::Binary` has not, and " "therefore cannot be used. `std::fmt` has many such [`traits`](https://doc." "rust-lang.org/std/fmt/#formatting-traits) and each requires its own " "implementation. This is detailed further in [`std::fmt`](https://doc.rust-" "lang.org/std/fmt/)." msgstr "" "Entonces, `fmt::Display` se ha implementado pero `fmt::Binary` no, ypor lo " "tanto, no se puede usar. `std::fmt` tiene muchos de estos [`traits`](https://" "doc.rust-lang.org/std/fmt/#formatting-traits) y cada uno requiere " "suimplementación. Esto se detalla aún más en [`std::fmt`](https://doc.rust-" "lang.org/std/fmt/)." #: src/hello/print/print_display.md:109 msgid "" "After checking the output of the above example, use the `Point2D` struct as " "a guide to add a `Complex` struct to the example. When printed in the same " "way, the output should be:" msgstr "" "Después de verificar la salida del ejemplo anterior, use la estructura " "`Point2D` como una guía para agregar una estructura `Complex` al ejemplo. " "Cuando se imprime de la misma manera, la salida debería ser:" #: src/hello/print/print_display.md:120 msgid "" "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [`macros`](../../macros.md), [`struct`](../../custom_types/" "structs.md), [`trait`](https://doc.rust-lang.org/std/fmt/#formatting-" "traits), and [`use`](../../mod/use.md)" msgstr "" "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [`macros`](../../macros.md), [`struct`](../../custom_types/" "structs.md), [`trait`](https://doc.rust-lang.org/std/fmt/#formatting-" "traits), y [`use`](../../mod/use.md)" #: src/hello/print/print_display/testcase_list.md:3 msgid "" "Implementing `fmt::Display` for a structure where the elements must each be " "handled sequentially is tricky. The problem is that each `write!` generates " "a `fmt::Result`. Proper handling of this requires dealing with _all_ the " "results. Rust provides the `?` operator for exactly this purpose." msgstr "" "Implementar `fmt::Display` para una estructura donde los elementos deben ser " "cada uno manejados secuencialmente es complicado. El problema es que cada " "`write!` genera un `fmt::Result`. El manejo adecuado de esto requiere tratar " "con _todos_ losresultados. Rust proporciona el operador `?` para exactamente " "este propósito." #: src/hello/print/print_display/testcase_list.md:8 msgid "Using `?` on `write!` looks like this:" msgstr "Usar `?` con `write!` se ve así:" #: src/hello/print/print_display/testcase_list.md:11 msgid "" "// Try `write!` to see if it errors. If it errors, return\n" "// the error. Otherwise continue.\n" msgstr "" "// Usa `write!` para ver si falla. Si hay errores, regresa\n" "// el error. En otro caso, continúa.\n" #: src/hello/print/print_display/testcase_list.md:16 msgid "" "With `?` available, implementing `fmt::Display` for a `Vec` is " "straightforward:" msgstr "" "Si disponemos de `?`, implementar `fmt::Display` para un `Vec` es directo:" #: src/hello/print/print_display/testcase_list.md:20 msgid "// Import the `fmt` module.\n" msgstr "// Importar el módulo `fmt`.\n" #: src/hello/print/print_display/testcase_list.md:21 msgid "// Define a structure named `List` containing a `Vec`.\n" msgstr "// Define una estructura llamada `List` que contiene un `Vec`.\n" #: src/hello/print/print_display/testcase_list.md:27 msgid "" "// Extract the value using tuple indexing,\n" " // and create a reference to `vec`.\n" msgstr "" "// Extrae el valor usando indexación de tuplas,\n" " // y crea una referencia a `vec`.\n" #: src/hello/print/print_display/testcase_list.md:31 msgid "\"[\"" msgstr "" #: src/hello/print/print_display/testcase_list.md:33 msgid "" "// Iterate over `v` in `vec` while enumerating the iteration\n" " // count in `count`.\n" msgstr "" "// Itera sobre `v` en un `vec` mientras enumeras la cuenta\n" " // de la iteración en `count`.\n" #: src/hello/print/print_display/testcase_list.md:36 msgid "" "// For every element except the first, add a comma.\n" " // Use the ? operator to return on errors.\n" msgstr "" "// Para cada element excepto el primero, agrega una coma.\n" " // Usa el operador ? para regresar errroes.\n" #: src/hello/print/print_display/testcase_list.md:38 src/std/str.md:36 msgid "\", \"" msgstr "" #: src/hello/print/print_display/testcase_list.md:42 msgid "// Close the opened bracket and return a fmt::Result value.\n" msgstr "// Cierra la llave abierta y regresa un valor de `fmt::Result`.\n" #: src/hello/print/print_display/testcase_list.md:43 msgid "\"]\"" msgstr "" #: src/hello/print/print_display/testcase_list.md:55 msgid "" "Try changing the program so that the index of each element in the vector is " "also printed. The new output should look like this:" msgstr "" "Intente cambiar el programa para que el índice de cada elemento en el vector " "seatambién impreso. La nueva salida debería verse así:" #: src/hello/print/print_display/testcase_list.md:64 msgid "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/ref." "md), [`Result`](../../../std/result.md), [`struct`](../../../custom_types/" "structs.md), [`?`](../../../std/result/question_mark.md), and [`vec!`]" "(../../../std/vec.md)" msgstr "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/ref." "md), [`Result`](../../../std/result.md), [`struct`](../../../custom_types/" "structs.md), [`?`](../../../std/result/question_mark.md), y [`vec!`]" "(../../../std/vec.md)" #: src/hello/print/fmt.md:3 msgid "We've seen that formatting is specified via a _format string_:" msgstr "" "Hemos visto que este formato se especifica via una _cadena de formato_:" #: src/hello/print/fmt.md:5 msgid "`format!(\"{}\", foo)` -> `\"3735928559\"`" msgstr "" #: src/hello/print/fmt.md:6 msgid "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" msgstr "" #: src/hello/print/fmt.md:7 msgid "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" msgstr "" #: src/hello/print/fmt.md:9 msgid "" "The same variable (`foo`) can be formatted differently depending on which " "_argument type_ is used: `X` vs `o` vs _unspecified_." msgstr "" "La misma variable (`foo`) puede formatearse de manera diferente dependiendo " "de cuál sea _tipo de argumento_ utilizado: `X` vs `o` vs _no especificado_." #: src/hello/print/fmt.md:12 msgid "" "This formatting functionality is implemented via traits, and there is one " "trait for each argument type. The most common formatting trait is `Display`, " "which handles cases where the argument type is left unspecified: `{}` for " "instance." msgstr "" "Esta funcionalidad de formato se implementa a través de traits, y hay trait " "para cada tipo de argumento. El trait de formato más común es la `Display`, " "que maneja casos en los que el tipo de argumento se deja sin especificar: `{}" "`, por ejemplo." #: src/hello/print/fmt.md:21 msgid "// Latitude\n" msgstr "// Latitude\n" #: src/hello/print/fmt.md:23 msgid "// Longitude\n" msgstr "// Longitude\n" #: src/hello/print/fmt.md:28 msgid "" "// `f` is a buffer, and this method must write the formatted string into " "it.\n" msgstr "" "// `f` es un búfer, y este método se usa para formatear y meterle una " "cadena.\n" #: src/hello/print/fmt.md:30 msgid "'N'" msgstr "" #: src/hello/print/fmt.md:30 msgid "'S'" msgstr "" #: src/hello/print/fmt.md:31 msgid "'E'" msgstr "" #: src/hello/print/fmt.md:31 msgid "'W'" msgstr "" #: src/hello/print/fmt.md:33 msgid "" "// `write!` is like `format!`, but it will write the formatted string\n" " // into a buffer (the first argument).\n" msgstr "" "// `write!` es como `format!`, pero escribirá la cadena formateada\n" " // al búfer (el primer argumento).\n" #: src/hello/print/fmt.md:35 msgid "\"{}: {:.3}°{} {:.3}°{}\"" msgstr "" #: src/hello/print/fmt.md:49 msgid "\"Dublin\"" msgstr "" #: src/hello/print/fmt.md:50 msgid "\"Oslo\"" msgstr "" #: src/hello/print/fmt.md:51 msgid "\"Vancouver\"" msgstr "" #: src/hello/print/fmt.md:60 msgid "" "// Switch this to use {} once you've added an implementation\n" " // for fmt::Display.\n" msgstr "" "// Cambia esto a {} una vez que hayas añadido una implementación\n" " // para fmt::Display.\n" #: src/hello/print/fmt.md:62 src/primitives/tuples.md:60 #: src/custom_types/structs.md:47 src/types/inference.md:23 #: src/conversion/string.md:76 src/generics/bounds.md:49 #: src/generics/where.md:38 src/std/str.md:137 src/std/result.md:59 #: src/std/result.md:61 src/std/result.md:63 src/std/arc.md:26 #: src/std_misc/channels.md:53 msgid "\"{:?}\"" msgstr "" #: src/hello/print/fmt.md:67 msgid "" "You can view a [full list of formatting traits](https://doc.rust-lang.org/" "std/fmt/#formatting-traits) and their argument types in the [`std::fmt`]" "(https://doc.rust-lang.org/std/fmt/) documentation." msgstr "" "Puede ver una [lista completa de traits de formato](https://doc.rust-lang." "org/std/fmt/#formatting-traits) y sus tipos de argumentos en la " "documentación de [`std::fmt`](https://doc.rust-lang.org/std/fmt/)." #: src/hello/print/fmt.md:72 msgid "" "Add an implementation of the `fmt::Display` trait for the `Color` struct " "above so that the output displays as:" msgstr "" "Agrega una implementación del trait `fmt::Display` para la estructura " "`Color`arriba para que la salida se muestre como:" #: src/hello/print/fmt.md:81 msgid "Three hints if you get stuck:" msgstr "Tres pistas por si te atoras:" #: src/hello/print/fmt.md:83 msgid "" "The formula for calculating a color in the RGB color space is: `RGB = " "(R*65536)+(G*256)+B , (when R is RED, G is GREEN and B is BLUE)`. For more " "see [RGB color format & calculation](https://www.rapidtables.com/web/color/" "RGB_Color.html#rgb-format)." msgstr "" "La fórmula para calcular un color en el espacio de color RGB es: `RGB = " "(R*65536)+(G*256)+B, (cuando R es ROJO, G es VERDE y B es AZUL)`. Para más " "ver [Formato de color RGB y su cálculo](https://www.rapidtables.com/web/color/" "RGB_Color.html#rgb-format)." #: src/hello/print/fmt.md:86 msgid "" "You [may need to list each color more than once](https://doc.rust-lang.org/" "std/fmt/#named-parameters)." msgstr "" "Puede que [necesites enumerar cada color más de una vez](https://doc.rust-lang.org/" "std/fmt/#named-parameters)." #: src/hello/print/fmt.md:87 msgid "" "You can [pad with zeros to a width of 2](https://doc.rust-lang.org/std/fmt/" "#width) with `:0>2`." msgstr "" "Puedes [acolchonar con ceros a un ancho de 2](https://doc.rust-lang.org/std/fmt/" "#width) usando `:0>2`." #: src/hello/print/fmt.md:91 msgid "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" msgstr "" #: src/primitives.md:3 msgid "" "Rust provides access to a wide variety of `primitives`. A sample includes:" msgstr "" "Rust proporciona acceso a una amplia variedad de `primitivas`. Algunos ejemplos son:" #: src/primitives.md:5 msgid "Scalar Types" msgstr "Tipos Escalares" #: src/primitives.md:7 msgid "" "Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size)" msgstr "" "Enteros con signo: `i8`, `i16`, `i32`, `i64`, `i128` y `isize` (el tamaño del puntero)" #: src/primitives.md:8 msgid "" "Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer " "size)" msgstr "" "Enteros sin signo: `u8`, `u16`, `u32`, `u64`, `u128` y `usize` (el tamaño del puntero" ")" #: src/primitives.md:10 msgid "Floating point: `f32`, `f64`" msgstr "Punto flotante: `f32`, `f64`" #: src/primitives.md:11 msgid "`char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each)" msgstr "`char` Valores de Unicode escalares como `'a'`, `'α'` y `'∞'` (4 bytes cada uno)" #: src/primitives.md:12 msgid "`bool` either `true` or `false`" msgstr "`bool` puede ser `true` o `falso`" #: src/primitives.md:13 msgid "The unit type `()`, whose only possible value is an empty tuple: `()`" msgstr "El tipo unitario `()`, cuyo único posible valor es la tupla vacía: `()`" #: src/primitives.md:15 msgid "" "Despite the value of a unit type being a tuple, it is not considered a " "compound type because it does not contain multiple values." msgstr "" "A pesar de que el valor de un tipo de unidad es una tupla, no se considera un" "tipo de compuesto porque no contiene múltiples valores." #: src/primitives.md:18 msgid "Compound Types" msgstr "Tipos Compuestos" #: src/primitives.md:20 msgid "Arrays like `[1, 2, 3]`" msgstr "Arreglos como `[1, 2, 3]`" #: src/primitives.md:21 msgid "Tuples like `(1, true)`" msgstr "Tuplas como `(1, true)`" #: src/primitives.md:23 msgid "" "Variables can always be _type annotated_. Numbers may additionally be " "annotated via a _suffix_ or _by default_. Integers default to `i32` and " "floats to `f64`. Note that Rust can also infer types from context." msgstr "" "Las variables siempre pueden llevar _anotación de tipos_. Los números también pueden ser" "anotados a través de un _sufijo_ o _por default_. Los enteros usan como default `i32` y " "los flotantes usan a `f64`. Tenga en cuenta que Rust puede también puede inferir tipos." #: src/primitives.md:29 msgid "// Variables can be type annotated.\n" msgstr "// Las variables pueden llevar anotaciónes de tipo.\n" #: src/primitives.md:32 msgid "// Regular annotation\n" msgstr "// Anotación regular\n" #: src/primitives.md:33 msgid "// Suffix annotation\n" msgstr "// Anotación con sufijo\n" #: src/primitives.md:35 msgid "// Or a default will be used.\n" msgstr "// O se usará un default.\n" #: src/primitives.md:36 msgid "// `f64`\n" msgstr "" #: src/primitives.md:37 msgid "// `i32`\n" msgstr "" #: src/primitives.md:39 msgid "// A type can also be inferred from context.\n" msgstr "// Un tipo también se puede inferir por context.\n" #: src/primitives.md:40 msgid "// Type i64 is inferred from another line.\n" msgstr "// El tipo i64 se puede inferir de otra línea.\n" #: src/primitives.md:43 msgid "// A mutable variable's value can be changed.\n" msgstr "// Una mariable mutable puede cambiar.\n" #: src/primitives.md:44 msgid "// Mutable `i32`\n" msgstr "// `i32` Mutable\n" #: src/primitives.md:47 msgid "// Error! The type of a variable can't be changed.\n" msgstr "// Error! El tipo de la variable no se puede cambiar.\n" #: src/primitives.md:50 msgid "// Variables can be overwritten with shadowing.\n" msgstr "// Las variables se puede sobreescribir con sombreo.\n" #: src/primitives.md:53 msgid "/* Compound types - Array and Tuple */" msgstr "/* Tipos compuestos - Arreglo y Tupla */" #: src/primitives.md:55 msgid "// Array signature consists of Type T and length as [T; length].\n" msgstr "// La declaración del tipo de Arreglo consiste del tipo T y la longitud como [T; longitud].\n" #: src/primitives.md:58 msgid "" "// Tuple is a collection of values of different types \n" " // and is constructed using parentheses ().\n" msgstr "" "// Una tupla es una colección de valores de diferentes tipos\n" " // y se construye usando paréntesis ().\n" #: src/primitives.md:66 msgid "" "[the `std` library](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [`inference`](types/inference.md), and " "[`shadowing`](variable_bindings/scope.md)" msgstr "" "[the `std` library](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [`inference`](types/inference.md), y " "[`shadowing`](variable_bindings/scope.md)" #: src/primitives/literals.md:3 msgid "" "Integers `1`, floats `1.2`, characters `'a'`, strings `\"abc\"`, booleans " "`true` and the unit type `()` can be expressed using literals." msgstr "" "Enteros `1`, flotantes `1.2`, caractéres `'a'`, cadenas `\"abc\"`, booleanos " "`true` y el tipo unitario `()` se puede expresar con literales." #: src/primitives/literals.md:6 msgid "" "Integers can, alternatively, be expressed using hexadecimal, octal or binary " "notation using these prefixes respectively: `0x`, `0o` or `0b`." msgstr "" "Los enteros pueden, alternativamente, expresarse utilizando notación hexadecimal, octal o binaria" "usando estos prefijos respectivamente: `0x`, `0o` o` 0b`." #: src/primitives/literals.md:9 msgid "" "Underscores can be inserted in numeric literals to improve readability, e.g. " "`1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`." msgstr "" "Se pueden insertar guíones bajos en literales numéricos para mejorar la legibilidad, por ejemplo," "`1_000` es lo mismo que `1000`, y `0.000_001` es lo mismo que `0.000001`." #: src/primitives/literals.md:12 msgid "" "Rust also supports scientific [E-notation](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. The associated type " "is `f64`." msgstr "" "Rust también admite [notación E científica](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. El tipo asociado es " "`f64`." #: src/primitives/literals.md:15 msgid "" "We need to tell the compiler the type of the literals we use. For now, we'll " "use the `u32` suffix to indicate that the literal is an unsigned 32-bit " "integer, and the `i32` suffix to indicate that it's a signed 32-bit integer." msgstr "" "Necesitamos decirle al compilador el tipo de literales que usamos. Por ahora, lo haremos" "usando el sufijo `u32` para indicar que el literal es un entero sin signo de 32 bits " ", y el sufijo `i32` para indicar que es un entero con signo de 32 bits." #: src/primitives/literals.md:19 msgid "" "The operators available and their precedence [in Rust](https://doc.rust-lang." "org/reference/expressions.html#expression-precedence) are similar to other " "[C-like languages](https://en.wikipedia.org/wiki/" "Operator_precedence#Programming_languages)." msgstr "" "Los operadores disponibles y su precedencia [en Rust](https://doc.rust-lang." "org/reference/expressions.html#expression-precedence) es similar a otros " "[lenguajes como C](https://en.wikipedia.org/wiki/" "Operator_precedence#Programming_languages)." #: src/primitives/literals.md:24 msgid "// Integer addition\n" msgstr "// Suma de enteros" #: src/primitives/literals.md:25 msgid "\"1 + 2 = {}\"" msgstr "" #: src/primitives/literals.md:27 msgid "// Integer subtraction\n" msgstr "// Resta de enteros" #: src/primitives/literals.md:28 msgid "\"1 - 2 = {}\"" msgstr "" #: src/primitives/literals.md:29 msgid "" "// TODO ^ Try changing `1i32` to `1u32` to see why the type is important\n" msgstr "" "// TAREA ^ Intenta cambiar `1i32` a `1u32` para ver por qué el tipo es importante\n" #: src/primitives/literals.md:31 msgid "// Scientific notation\n" msgstr "// Notación científica" #: src/primitives/literals.md:32 msgid "\"1e4 is {}, -2.5e-3 is {}\"" msgstr "\"1e4 es {}, -2.5e-3 es {}\"" #: src/primitives/literals.md:34 msgid "// Short-circuiting boolean logic\n" msgstr "// Lógica booleana de corto circuito" #: src/primitives/literals.md:35 msgid "\"true AND false is {}\"" msgstr "\"true Y false es {}\"" #: src/primitives/literals.md:36 msgid "\"true OR false is {}\"" msgstr "\"true O false es {}\"" #: src/primitives/literals.md:37 msgid "\"NOT true is {}\"" msgstr "\"NOT true es {}\"" #: src/primitives/literals.md:39 msgid "// Bitwise operations\n" msgstr "// Operaciones sobre bits" #: src/primitives/literals.md:40 msgid "\"0011 AND 0101 is {:04b}\"" msgstr "\"0011 AND 0101 es {:04b}\"" #: src/primitives/literals.md:41 msgid "\"0011 OR 0101 is {:04b}\"" msgstr "\"0011 OR 0101 es {:04b}\"" #: src/primitives/literals.md:42 msgid "\"0011 XOR 0101 is {:04b}\"" msgstr "\"0011 XOR 0101 es {:04b}\"" #: src/primitives/literals.md:43 msgid "\"1 << 5 is {}\"" msgstr "\"1 << 5 es {}\"" #: src/primitives/literals.md:44 msgid "\"0x80 >> 2 is 0x{:x}\"" msgstr "\"0x80 >> 2 es 0x{:x}\"" #: src/primitives/literals.md:46 msgid "// Use underscores to improve readability!\n" msgstr "// ¡Usa guiones bajos para mejorar la legibilidad!\n" #: src/primitives/literals.md:47 msgid "\"One million is written as {}\"" msgstr "\" Un millón se escribe como {}\"" #: src/primitives/tuples.md:3 msgid "" "A tuple is a collection of values of different types. Tuples are constructed " "using parentheses `()`, and each tuple itself is a value with type signature " "`(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions " "can use tuples to return multiple values, as tuples can hold any number of " "values." msgstr "" "Una tupla es una colección de valores de diferentes tipos. Se construyen tuplas" "usando paréntesis `()`, y cada tupla en sí es un valor con la anotación de tipo" "`(T1, t2, ...) `, donde `t1`, `t2` son los tipos de sus miembros. Las funciones" "pueden usar tuplas para devolver múltiples valores, ya que las tuplas pueden contener cualquier número de" "valores." #: src/primitives/tuples.md:9 msgid "// Tuples can be used as function arguments and as return values.\n" msgstr "// Las tuplas se pueden como argumentos de funciones y como sus valores de retorno.\n" #: src/primitives/tuples.md:11 msgid "// `let` can be used to bind the members of a tuple to variables.\n" msgstr "// `let` se puede usar para ligar los miembros de la tupla a variables.\n" #: src/primitives/tuples.md:16 msgid "// The following struct is for the activity.\n" msgstr "// La siguiente `struct` es para la actividad.\n" #: src/primitives/tuples.md:22 msgid "// A tuple with a bunch of different types.\n" msgstr "// Una tupla es montón de tipos diferentes.\n" #: src/primitives/tuples.md:26 src/generics.md:50 src/generics.md:55 #: src/generics/gen_fn.md:47 msgid "'a'" msgstr "" #: src/primitives/tuples.md:28 msgid "// Values can be extracted from the tuple using tuple indexing.\n" msgstr "// Se pueden extraer valores de la tupla indexando" #: src/primitives/tuples.md:29 msgid "\"Long tuple first value: {}\"" msgstr "\"Tupla grande primer valor: {}\"" #: src/primitives/tuples.md:30 msgid "\"Long tuple second value: {}\"" msgstr "\"Tupla grande segundo valor: {}\"" #: src/primitives/tuples.md:32 msgid "// Tuples can be tuple members.\n" msgstr "// Tuplas con tuplas como miembros.\n" #: src/primitives/tuples.md:35 msgid "// Tuples are printable.\n" msgstr "// Las tuples se pueden imprimir.\n" #: src/primitives/tuples.md:36 msgid "\"tuple of tuples: {:?}\"" msgstr "\"tupla de tuplas: {:?}\"" #: src/primitives/tuples.md:38 msgid "" "// But long Tuples (more than 12 elements) cannot be printed.\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"Too long tuple: {:?}\", too_long_tuple);\n" " // TODO ^ Uncomment the above 2 lines to see the compiler error\n" msgstr "" "// Pero no se pueden imprimir tuplas demasadio grandes (más de 12 elementos).\n" " // let tupla_demasiado_grande = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " // println!(\"Tupla demasiado grande: {:?}\", tupla_demasiado_grande);\n" " // TAREA ^ Quita el comentario de las 2 líneas anteriores para ver el error del compilador\n" #: src/primitives/tuples.md:44 msgid "\"Pair is {:?}\"" msgstr "\"Par es {:?}\"" #: src/primitives/tuples.md:46 msgid "\"The reversed pair is {:?}\"" msgstr "\"El par invertido es {:?}\"" #: src/primitives/tuples.md:48 msgid "" "// To create one element tuples, the comma is required to tell them apart\n" " // from a literal surrounded by parentheses.\n" msgstr "" "// Para crear un tuplas de un sólo elemento, se requiere la coma para distinguirlas\n" " // de un literal rodeado de paréntesis.\n" #: src/primitives/tuples.md:50 msgid "\"One element tuple: {:?}\"" msgstr "\"Una tupla de 1 elemento: {:?}\"" #: src/primitives/tuples.md:51 msgid "\"Just an integer: {:?}\"" msgstr "\"Sólo un entero: {:?}\"" #: src/primitives/tuples.md:53 msgid "// Tuples can be destructured to create bindings.\n" msgstr "// Las tuplas puede desestructurar para crear variables.\n" #: src/primitives/tuples.md:54 src/conversion/from_into.md:17 #: src/fn/closures/input_parameters.md:52 src/std_misc/fs.md:51 msgid "\"hello\"" msgstr "" #: src/primitives/tuples.md:57 msgid "\"{:?}, {:?}, {:?}, {:?}\"" msgstr "" #: src/primitives/tuples.md:66 msgid "" "_Recap_: Add the `fmt::Display` trait to the `Matrix` struct in the above " "example, so that if you switch from printing the debug format `{:?}` to the " "display format `{}`, you see the following output:" msgstr "" "_Recapitulando_: Agrega el rasgo `fmt::Display` a `Matrix` en el ejemplo" "anterior, de modo que si cambias de imprimir el formato de depuración `{:?}` al" "formato de visualización `{}`, ves la siguiente salida:" #: src/primitives/tuples.md:75 msgid "" "You may want to refer back to the example for [print display](../hello/print/" "print_display.md)." msgstr "" "Es posible que desee consultar el ejemplo de [impresión a pantalla](../hello/print/" "print_display.md)." #: src/primitives/tuples.md:76 msgid "" "Add a `transpose` function using the `reverse` function as a template, which " "accepts a matrix as an argument, and returns a matrix in which two elements " "have been swapped. For example:" msgstr "" "Agrega una función `transpose` usando la función `reverse` como una plantilla, el cual" "acepta una matriz como argumento y devuelve una matriz en la que dos elementos" "han sido intercambiados. Por ejemplo:" #: src/primitives/tuples.md:81 msgid "\"Matrix:\\n{}\"" msgstr "\"Matriz:\\n{}\"" #: src/primitives/tuples.md:82 msgid "\"Transpose:\\n{}\"" msgstr "\"Transpuesta:\\n{}\"" #: src/primitives/tuples.md:85 msgid "Results in the output:" msgstr "Resultados en el output:" #: src/primitives/array.md:3 msgid "" "An array is a collection of objects of the same type `T`, stored in " "contiguous memory. Arrays are created using brackets `[]`, and their length, " "which is known at compile time, is part of their type signature `[T; " "length]`." msgstr "" "Un arreglo es una colección de objetos del mismo tipo `t`, almacenado en " "memoria contigua. Los arreglos se crean usando corchetes cuardrados `[]`, y su longitud, " "que se conoce en el momento de la compilación, es parte de su anotación de tipo `[T; " "longitud]`." #: src/primitives/array.md:7 msgid "" "Slices are similar to arrays, but their length is not known at compile time. " "Instead, a slice is a two-word object; the first word is a pointer to the " "data, the second word is the length of the slice. The word size is the same " "as usize, determined by the processor architecture, e.g. 64 bits on an " "x86-64. Slices can be used to borrow a section of an array and have the type " "signature `&[T]`." msgstr "" "Las slices son similares a los arreglos, pero su longitud no se conoce al momento de compilar." "En cambio, un slice es un objeto de dos 'words' del procesador; la primera palabra es un puntero a los" "datos, la segunda palabra es la longitud del slice. El tamaño de la palabra es el mismo" "que usize, el cual se determina por la arquitectura del procesador, e.g. 64 bits en " "x86-64. Los slices se pueden usar para tomar un `borrow` de una sección de un arreglo y tener la anotación" "de tipo `&[t]`." #: src/primitives/array.md:15 msgid "// This function borrows a slice.\n" msgstr "// Esta funcion hace borrow a una slice.\n" #: src/primitives/array.md:18 msgid "\"First element of the slice: {}\"" msgstr "\" El primer elemento de un slice: {}\"" #: src/primitives/array.md:19 msgid "\"The slice has {} elements\"" msgstr "\"El slice tiene {} elementos\"" #: src/primitives/array.md:23 msgid "// Fixed-size array (type signature is superfluous).\n" msgstr "// Arreglos de tamaño fijo (su anotación de tipo es superflua).\n" #: src/primitives/array.md:26 msgid "// All elements can be initialized to the same value.\n" msgstr "// Todos los elementos pueden ser inicializados al mismo valor.\n" #: src/primitives/array.md:29 msgid "// Indexing starts at 0.\n" msgstr "// Los índices empiezan en 0.\n" #: src/primitives/array.md:30 msgid "\"First element of the array: {}\"" msgstr "\"El primer elemento del arreglo: {}\"" #: src/primitives/array.md:31 msgid "\"Second element of the array: {}\"" msgstr "\"El segundo elemento del arreglo: {}\"" #: src/primitives/array.md:33 msgid "// `len` returns the count of elements in the array.\n" msgstr "// `len` regresa cuántos elementos hay en el arreglo.\n" #: src/primitives/array.md:34 msgid "\"Number of elements in array: {}\"" msgstr "\"Número de elementos en el arreglo: {} \"" #: src/primitives/array.md:36 msgid "// Arrays are stack allocated.\n" msgstr "// Los arreglos se colocan en el stack.\n" #: src/primitives/array.md:37 msgid "\"Array occupies {} bytes\"" msgstr "\"Los arreglos ocupan {} bytes\"" #: src/primitives/array.md:39 msgid "// Arrays can be automatically borrowed as slices.\n" msgstr "// Los arreglos pueden ser `borrowed` como slices.\n" #: src/primitives/array.md:40 msgid "\"Borrow the whole array as a slice.\"" msgstr "\"Hace borrow de todo el arreglo como un slice.\"" #: src/primitives/array.md:43 msgid "" "// Slices can point to a section of an array.\n" " // They are of the form [starting_index..ending_index].\n" " // `starting_index` is the first position in the slice.\n" " // `ending_index` is one more than the last position in the slice.\n" msgstr "" "// Los slices pueden apuntar a una sección de un arreglo.\n" " // Estos son de la forma [índice_inicial..índice_final].\n" " // `índice_inicial` es la primera posición en el slice.\n" " // `índice_final` es uno más que la última posición en la porción.\n" #: src/primitives/array.md:47 msgid "\"Borrow a section of the array as a slice.\"" msgstr "\"Hace Borrow de una sección del arreglo como un slice.\"" #: src/primitives/array.md:50 msgid "// Example of empty slice `&[]`:\n" msgstr "// Un ejemplo de un slice vacío `&[]`:\n" #: src/primitives/array.md:53 msgid "// Same but more verbose\n" msgstr "// Lo mismo pero menos conciso" #: src/primitives/array.md:55 msgid "" "// Arrays can be safely accessed using `.get`, which returns an\n" " // `Option`. This can be matched as shown below, or used with\n" " // `.expect()` if you would like the program to exit with a nice\n" " // message instead of happily continue.\n" msgstr "" "// Se pueden acceder a las arreglos de forma segura usando `.get`, el cual devuelve un \n" " // `Option'. Aquí se puede usar un match como se muestra a continuación, o en su caso con \n" " // `.expect()` si desees que el programa termine con un amable\n" " // mensaje en lugar de continuar felizmente.\n" #: src/primitives/array.md:59 msgid "// Oops, one element too far!\n" msgstr "// ¡Oops!, un elemento de sobra.\n" #: src/primitives/array.md:61 msgid "\"{}: {}\"" msgstr "" #: src/primitives/array.md:62 msgid "\"Slow down! {} is too far!\"" msgstr "\"¡Para! {} es demasiado lejos\"" #: src/primitives/array.md:66 msgid "" "// Out of bound indexing on array with constant value causes compile time " "error.\n" " //println!(\"{}\", xs[5]);\n" " // Out of bound indexing on slice causes runtime error.\n" " //println!(\"{}\", xs[..][5]);\n" msgstr "" "// Usar un índice constante que se encuentra fuera del rango válido causa un error de compilación.\n" " //println!(\"{}\", xs[5]);\n" " // Usar un índice fuera de rango en un slice causa un error de compilación.\n" " //println!(\"{}\", xs[..][5]);\n" #: src/custom_types.md:3 msgid "Rust custom data types are formed mainly through the two keywords:" msgstr "Los tipos de datos personalizados en Rust se logran principalmente con 2 palabras clave:" #: src/custom_types.md:5 msgid "`struct`: define a structure" msgstr "`struct`: define una estructura" #: src/custom_types.md:6 msgid "`enum`: define an enumeration" msgstr "`enum`: define una enumeración" #: src/custom_types.md:8 msgid "Constants can also be created via the `const` and `static` keywords." msgstr "Las constantes se crean con las palabras clave `const` o `static`." #: src/custom_types/structs.md:3 msgid "" "There are three types of structures (\"structs\") that can be created using " "the `struct` keyword:" msgstr "" "Hay tres tipos de estructuras (\"struct\") que se pueden crear usando" "la palabra clave 'struct`:" #: src/custom_types/structs.md:6 msgid "Tuple structs, which are, basically, named tuples." msgstr "Estructuras de tupla, las cuales son básicamente tuplas nombradas." #: src/custom_types/structs.md:7 msgid "" "The classic [C structs](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" msgstr "" "Las clásicas estructuras [struct de C](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" #: src/custom_types/structs.md:8 msgid "Unit structs, which are field-less, are useful for generics." msgstr "Las structs unitarias, las cuales no tienen campos, y son útiles para los genéricos." #: src/custom_types/structs.md:11 src/custom_types/enum/enum_use.md:6 #: src/custom_types/enum/c_like.md:6 msgid "// An attribute to hide warnings for unused code.\n" msgstr "// Un atributo para esconder las advertencias del código no utilizado.\n" #: src/custom_types/structs.md:19 msgid "// A unit struct\n" msgstr "// Una struct unitaria" #: src/custom_types/structs.md:22 msgid "// A tuple struct\n" msgstr "// Una struct de tupla" #: src/custom_types/structs.md:25 msgid "// A struct with two fields\n" msgstr "// Una struct de dos campos\n" #: src/custom_types/structs.md:31 msgid "// Structs can be reused as fields of another struct\n" msgstr "// Las Structs pueden reutilizar los campos de otras structs\n" #: src/custom_types/structs.md:34 msgid "" "// A rectangle can be specified by where the top left and bottom right\n" " // corners are in space.\n" msgstr "" "// Un rectángulo se puede escpecificar por dónde las esquinas de arriba a la izquierda y abajo a la derecha" " // se encuentran en el espacio.\n" #: src/custom_types/structs.md:41 msgid "// Create struct with field init shorthand\n" msgstr "// Abreviación para crear un struct con un campo ya inicializado\n" #: src/custom_types/structs.md:46 msgid "// Print debug struct\n" msgstr "// Imprime un struct de depuración\n" #: src/custom_types/structs.md:49 msgid "// Instantiate a `Point`\n" msgstr "// Instanciar un `Point`\n" #: src/custom_types/structs.md:53 msgid "// Access the fields of the point\n" msgstr "// Accesa los campos del punto\n" #: src/custom_types/structs.md:54 msgid "\"point coordinates: ({}, {})\"" msgstr "\"coordenadas del punto: ({}, {})\"" #: src/custom_types/structs.md:56 msgid "" "// Make a new point by using struct update syntax to use the fields of our\n" " // other one\n" msgstr "" "// Crea un nuevo punto usando la sintáxis de update de struct para usar los campos\n" " // del otro struct\n" #: src/custom_types/structs.md:60 msgid "" "// `bottom_right.y` will be the same as `another_point.y` because we used " "that field\n" " // from `another_point`\n" msgstr "" "// `abajo_derecha.y` va a ser lo mismo que `otro_punto.y` por que usamos ese " "campo \n" " // de `otro_punto`\n" #: src/custom_types/structs.md:62 msgid "\"second point: ({}, {})\"" msgstr "\"segundo punto: ({}, {})\"" #: src/custom_types/structs.md:64 msgid "// Destructure the point using a `let` binding\n" msgstr "// Destructura el punto con un enlace `let`\n" #: src/custom_types/structs.md:68 msgid "// struct instantiation is an expression too\n" msgstr "// también se puede hacer la instanciación de un struct con una expresión" #: src/custom_types/structs.md:73 msgid "// Instantiate a unit struct\n" msgstr "// Instacia una struct unitaria" #: src/custom_types/structs.md:76 msgid "// Instantiate a tuple struct\n" msgstr "// Instancia una estructura de tupla\n" #: src/custom_types/structs.md:79 msgid "// Access the fields of a tuple struct\n" msgstr "// Accesa los campos de una estructura de tupla\n" #: src/custom_types/structs.md:80 src/custom_types/structs.md:85 msgid "\"pair contains {:?} and {:?}\"" msgstr "\"un par contiene {:?} y {:?}\"" #: src/custom_types/structs.md:82 msgid "// Destructure a tuple struct\n" msgstr "// Destructura una estructura de tupla" #: src/custom_types/structs.md:91 msgid "" "Add a function `rect_area` which calculates the area of a `Rectangle` (try " "using nested destructuring)." msgstr "" "Agregue una función `rect_area` que calcula el área de un `Rectangle` (intenta" "usar de la destructación anidada)." #: src/custom_types/structs.md:93 msgid "" "Add a function `square` which takes a `Point` and a `f32` as arguments, and " "returns a `Rectangle` with its top left corner on the point, and a width and " "height corresponding to the `f32`." msgstr "" "Agregue una función `square` que toma un `Punto` y un `f32` como argumentos, y " "devuelve un `Rectangle` con su esquina superior izquierda en el punto, y un ancho y" "altura correspondiente al `f32`." #: src/custom_types/structs.md:97 msgid "See also" msgstr "Véase también" #: src/custom_types/structs.md:99 msgid "" "[`attributes`](../attribute.md), [raw identifiers](../compatibility/" "raw_identifiers.md) and [destructuring](../flow_control/match/destructuring." "md)" msgstr "" "[`attributes`](../attribute.md), [raw identifiers](../compatibility/" "raw_identifiers.md) y [destructuring](../flow_control/match/destructuring." "md)" #: src/custom_types/enum.md:3 msgid "" "The `enum` keyword allows the creation of a type which may be one of a few " "different variants. Any variant which is valid as a `struct` is also valid " "in an `enum`." msgstr "" "La palabra clave `enum` permite la creación de un tipo que puede ser uno de unas pocas" "diferentes variantes. Cualquier variante que sea válida como `struct` también es válida" "en un `enum`." #: src/custom_types/enum.md:8 msgid "" "// Create an `enum` to classify a web event. Note how both\n" "// names and type information together specify the variant:\n" "// `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.\n" "// Each is different and independent.\n" msgstr "" "// Cree un `enum` para clasificar un evento web. Tenga en cuenta cómo ambos los\n" "// nombres y los tipos juntos especifican la variante:\n" "// `PageLoad != PageUnload` y `KeyPress(char) != Paste(String)`.\n" "// Cada uno es diferente e independiente.\n" #: src/custom_types/enum.md:13 msgid "// An `enum` variant may either be `unit-like`,\n" msgstr "// Una variante `enum` puede ser `cuasi-unitaria`,\n" #: src/custom_types/enum.md:16 msgid "// like tuple structs,\n" msgstr "// como estructuras de tuplas" #: src/custom_types/enum.md:19 msgid "// or c-like structures.\n" msgstr "// o estructuras estilo C.\n" #: src/custom_types/enum.md:22 msgid "" "// A function which takes a `WebEvent` enum as an argument and\n" "// returns nothing.\n" msgstr "" "// Una función que toma un enum 'WebEvent` como argumento y \n" "// no devuelve nada.\n" #: src/custom_types/enum.md:27 msgid "\"page loaded\"" msgstr "\"página cargada\"" #: src/custom_types/enum.md:28 msgid "\"page unloaded\"" msgstr "\"página descargada \"" #: src/custom_types/enum.md:29 msgid "// Destructure `c` from inside the `enum` variant.\n" msgstr "// Destructura `c` desde dentro de la variante `enum`.\n" #: src/custom_types/enum.md:30 msgid "\"pressed '{}'.\"" msgstr "\"presionaste '{}'.\"" #: src/custom_types/enum.md:31 msgid "\"pasted \\\"{}\\\".\"" msgstr "\"pegaste \\\"{}\\\".\"" #: src/custom_types/enum.md:32 msgid "// Destructure `Click` into `x` and `y`.\n" msgstr "// Destructura `Click` en `x` y `y`.\n" #: src/custom_types/enum.md:34 msgid "\"clicked at x={}, y={}.\"" msgstr "\"click en x={}, y={}.\"" #: src/custom_types/enum.md:40 msgid "'x'" msgstr "" #: src/custom_types/enum.md:41 msgid "// `to_owned()` creates an owned `String` from a string slice.\n" msgstr "// `to_owned()` crea un `String` que es owned de slice de cadena.\n" #: src/custom_types/enum.md:42 msgid "\"my text\"" msgstr "\"mi texto\"" #: src/custom_types/enum.md:56 msgid "Type aliases" msgstr "Aliases de tipos" #: src/custom_types/enum.md:58 msgid "" "If you use a type alias, you can refer to each enum variant via its alias. " "This might be useful if the enum's name is too long or too generic, and you " "want to rename it." msgstr "" "Si usa un alias de tipo, puedes consultar cada variante de enum a través de su alias." "Esto podría ser útil si el nombre del enum es demasiado largo o demasiado genérico, y lo " "quieres renombrar." #: src/custom_types/enum.md:67 msgid "// Creates a type alias\n" msgstr "// Crear un alias de tipo\n" #: src/custom_types/enum.md:72 msgid "" "// We can refer to each variant via its alias, not its long and " "inconvenient\n" " // name.\n" msgstr "" "// Podemos referirnos a cada variante a través de su alias, y no su largo e" "inconveniente \n" " // nombre. \n" #: src/custom_types/enum.md:78 msgid "" "The most common place you'll see this is in `impl` blocks using the `Self` " "alias." msgstr "" "El lugar más común que verás esto es en los bloques de `impl` usando el alias `Self` " "." #: src/custom_types/enum.md:96 msgid "" "To learn more about enums and type aliases, you can read the [stabilization " "report](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847) from when this feature was stabilized into Rust." msgstr "" "Para obtener más información sobre enums y alias de tipo, puedes leer el [informe " "estabilización](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847) de cuando este feature se estabilizó en Rust." #: src/custom_types/enum.md:102 msgid "" "[`match`](../flow_control/match.md), [`fn`](../fn.md), and [`String`](../std/" "str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/" "rfcs/2338-type-alias-enum-variants.html)" msgstr "" "[`match`](../flow_control/match.md), [`fn`](../fn.md), y [`String`](../std/" "str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/" "rfcs/2338-type-alias-enum-variants.html)" #: src/custom_types/enum/enum_use.md:3 msgid "The `use` declaration can be used so manual scoping isn't needed:" msgstr "La declaración `use` se puede usar de tal manera que no se necesiten alcances manuales:" #: src/custom_types/enum/enum_use.md:20 msgid "" "// Explicitly `use` each name so they are available without\n" " // manual scoping.\n" msgstr "" "// Explícitamente `use` (usa) cada nombre para que estén disponibles sin \n " " // alcance manual. \n" #: src/custom_types/enum/enum_use.md:23 msgid "// Automatically `use` each name inside `Role`.\n" msgstr "// Hace `use` automaticamente para cada nombre dentro de `Role`.\n" #: src/custom_types/enum/enum_use.md:26 msgid "// Equivalent to `Stage::Beginner`.\n" msgstr "// Equivalente a `Stage::Beginner`.\n" #: src/custom_types/enum/enum_use.md:28 msgid "// Equivalent to `Role::Student`.\n" msgstr "// Equivalente a `Role::Student`.\n" #: src/custom_types/enum/enum_use.md:32 msgid "// Note the lack of scoping because of the explicit `use` above.\n" msgstr "// Notamos que la falta de alcances se debe al uso explícito de `use` arriba.\n" #: src/custom_types/enum/enum_use.md:33 msgid "\"Beginners are starting their learning journey!\"" msgstr "\"¡Los principiantes están comenzando su aprendizaje!\"" #: src/custom_types/enum/enum_use.md:34 msgid "\"Advanced learners are mastering their subjects...\"" msgstr "\"Los estudiantes avanzados están dominando sus materias...\"" #: src/custom_types/enum/enum_use.md:38 msgid "// Note again the lack of scoping.\n" msgstr "// Notamos otra vez la falta de alcances.\n" #: src/custom_types/enum/enum_use.md:39 msgid "\"Students are acquiring knowledge!\"" msgstr "\"¡Los estudiantes están adquiriendo conocimiento!\"" #: src/custom_types/enum/enum_use.md:40 msgid "\"Teachers are spreading knowledge!\"" msgstr "" #: src/custom_types/enum/enum_use.md:47 msgid "[`match`](../../flow_control/match.md) and [`use`](../../mod/use.md)" msgstr "" #: src/custom_types/enum/c_like.md:3 msgid "`enum` can also be used as C-like enums." msgstr "" #: src/custom_types/enum/c_like.md:8 msgid "// enum with implicit discriminator (starts at 0)\n" msgstr "" #: src/custom_types/enum/c_like.md:15 msgid "// enum with explicit discriminator\n" msgstr "" #: src/custom_types/enum/c_like.md:24 msgid "// `enums` can be cast as integers.\n" msgstr "" #: src/custom_types/enum/c_like.md:25 msgid "\"zero is {}\"" msgstr "" #: src/custom_types/enum/c_like.md:26 msgid "\"one is {}\"" msgstr "" #: src/custom_types/enum/c_like.md:28 msgid "\"roses are #{:06x}\"" msgstr "" #: src/custom_types/enum/c_like.md:29 msgid "\"violets are #{:06x}\"" msgstr "" #: src/custom_types/enum/c_like.md:35 msgid "[casting](../../types/cast.md)" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:3 msgid "A common way to implement a linked-list is via `enums`:" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:9 msgid "" "// Cons: Tuple struct that wraps an element and a pointer to the next node\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:11 msgid "// Nil: A node that signifies the end of the linked list\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:14 msgid "// Methods can be attached to an enum\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:17 msgid "// Create an empty list\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:19 msgid "// `Nil` has type `List`\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:23 msgid "" "// Consume a list, and return the same list with a new element at its front\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:25 msgid "// `Cons` also has type List\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:29 msgid "// Return the length of the list\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:31 msgid "" "// `self` has to be matched, because the behavior of this method\n" " // depends on the variant of `self`\n" " // `self` has type `&List`, and `*self` has type `List`, matching on " "a\n" " // concrete type `T` is preferred over a match on a reference `&T`\n" " // after Rust 2018 you can use self here and tail (with no ref) " "below as well,\n" " // rust will infer &s and ref tail. \n" " // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:39 msgid "" "// Can't take ownership of the tail, because `self` is borrowed;\n" " // instead take a reference to the tail\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:42 msgid "// Base Case: An empty list has zero length\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:47 msgid "// Return representation of the list as a (heap allocated) string\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:51 msgid "" "// `format!` is similar to `print!`, but returns a heap\n" " // allocated string instead of printing to the console\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:53 src/generics/impl.md:44 msgid "\"{}, {}\"" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:56 msgid "\"Nil\"" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:63 msgid "// Create an empty linked list\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:66 msgid "// Prepend some elements\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:71 msgid "// Show the final state of the list\n" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:72 msgid "\"linked list has length: {}\"" msgstr "" #: src/custom_types/enum/testcase_linked_list.md:79 msgid "[`Box`](../../std/box.md) and [methods](../../fn/methods.md)" msgstr "" #: src/custom_types/constants.md:3 msgid "" "Rust has two different types of constants which can be declared in any scope " "including global. Both require explicit type annotation:" msgstr "" #: src/custom_types/constants.md:6 msgid "`const`: An unchangeable value (the common case)." msgstr "" #: src/custom_types/constants.md:7 msgid "" "`static`: A possibly mutable variable with [`'static`](../scope/lifetime/" "static_lifetime.md) lifetime. The static lifetime is inferred and does not " "have to be specified. Accessing or modifying a mutable static variable is " "[`unsafe`](../unsafe.md)." msgstr "" #: src/custom_types/constants.md:12 msgid "// Globals are declared outside all other scopes.\n" msgstr "" #: src/custom_types/constants.md:13 msgid "\"Rust\"" msgstr "" #: src/custom_types/constants.md:17 msgid "// Access constant in some function\n" msgstr "" #: src/custom_types/constants.md:24 msgid "// Access constant in the main thread\n" msgstr "" #: src/custom_types/constants.md:25 msgid "\"This is {}\"" msgstr "" #: src/custom_types/constants.md:26 msgid "\"The threshold is {}\"" msgstr "" #: src/custom_types/constants.md:27 msgid "\"{} is {}\"" msgstr "" #: src/custom_types/constants.md:27 msgid "\"big\"" msgstr "" #: src/custom_types/constants.md:27 msgid "\"small\"" msgstr "" #: src/custom_types/constants.md:29 msgid "// Error! Cannot modify a `const`.\n" msgstr "" #: src/custom_types/constants.md:31 src/variable_bindings/scope.md:22 #: src/variable_bindings/declare.md:27 src/variable_bindings/freeze.md:16 #: src/types/cast.md:19 src/types/cast.md:28 src/flow_control/for.md:95 #: src/scope/borrow.md:41 src/scope/borrow/mut.md:52 src/std/vec.md:32 #: src/std/vec.md:45 src/std/hash/hashset.md:48 msgid "// FIXME ^ Comment out this line\n" msgstr "" #: src/custom_types/constants.md:37 msgid "" "[The `const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/" "text/0246-const-vs-static.md), [`'static` lifetime](../scope/lifetime/" "static_lifetime.md)" msgstr "" #: src/variable_bindings.md:3 msgid "" "Rust provides type safety via static typing. Variable bindings can be type " "annotated when declared. However, in most cases, the compiler will be able " "to infer the type of the variable from the context, heavily reducing the " "annotation burden." msgstr "" #: src/variable_bindings.md:8 msgid "" "Values (like literals) can be bound to variables, using the `let` binding." msgstr "" #: src/variable_bindings.md:16 msgid "// copy `an_integer` into `copied_integer`\n" msgstr "" #: src/variable_bindings.md:19 msgid "\"An integer: {:?}\"" msgstr "" #: src/variable_bindings.md:20 msgid "\"A boolean: {:?}\"" msgstr "" #: src/variable_bindings.md:21 msgid "\"Meet the unit value: {:?}\"" msgstr "" #: src/variable_bindings.md:23 msgid "" "// The compiler warns about unused variable bindings; these warnings can\n" " // be silenced by prefixing the variable name with an underscore\n" msgstr "" #: src/variable_bindings.md:28 msgid "" "// FIXME ^ Prefix with an underscore to suppress the warning\n" " // Please note that warnings may not be shown in a browser\n" msgstr "" #: src/variable_bindings/mut.md:3 msgid "" "Variable bindings are immutable by default, but this can be overridden using " "the `mut` modifier." msgstr "" #: src/variable_bindings/mut.md:11 msgid "\"Before mutation: {}\"" msgstr "" #: src/variable_bindings/mut.md:13 msgid "// Ok\n" msgstr "" #: src/variable_bindings/mut.md:16 msgid "\"After mutation: {}\"" msgstr "" #: src/variable_bindings/mut.md:18 msgid "// Error! Cannot assign a new value to an immutable variable\n" msgstr "" #: src/variable_bindings/mut.md:23 msgid "The compiler will throw a detailed diagnostic about mutability errors." msgstr "" #: src/variable_bindings/scope.md:3 msgid "" "Variable bindings have a scope, and are constrained to live in a _block_. A " "block is a collection of statements enclosed by braces `{}`." msgstr "" #: src/variable_bindings/scope.md:8 msgid "// This binding lives in the main function\n" msgstr "" #: src/variable_bindings/scope.md:11 msgid "// This is a block, and has a smaller scope than the main function\n" msgstr "" #: src/variable_bindings/scope.md:13 msgid "// This binding only exists in this block\n" msgstr "" #: src/variable_bindings/scope.md:16 msgid "\"inner short: {}\"" msgstr "" #: src/variable_bindings/scope.md:18 msgid "// End of the block\n" msgstr "" #: src/variable_bindings/scope.md:20 msgid "// Error! `short_lived_binding` doesn't exist in this scope\n" msgstr "" #: src/variable_bindings/scope.md:21 msgid "\"outer short: {}\"" msgstr "" #: src/variable_bindings/scope.md:24 msgid "\"outer long: {}\"" msgstr "" #: src/variable_bindings/scope.md:28 msgid "" "Also, [variable shadowing](https://en.wikipedia.org/wiki/Variable_shadowing) " "is allowed." msgstr "" #: src/variable_bindings/scope.md:35 msgid "\"before being shadowed: {}\"" msgstr "" #: src/variable_bindings/scope.md:37 msgid "// This binding *shadows* the outer one\n" msgstr "" #: src/variable_bindings/scope.md:38 msgid "\"abc\"" msgstr "" #: src/variable_bindings/scope.md:40 msgid "\"shadowed in inner block: {}\"" msgstr "" #: src/variable_bindings/scope.md:42 msgid "\"outside inner block: {}\"" msgstr "" #: src/variable_bindings/scope.md:44 msgid "// This binding *shadows* the previous binding\n" msgstr "" #: src/variable_bindings/scope.md:46 msgid "\"shadowed in outer block: {}\"" msgstr "" #: src/variable_bindings/declare.md:3 msgid "" "It is possible to declare variable bindings first and initialize them later, " "but all variable bindings must be initialized before they are used: the " "compiler forbids use of uninitialized variable bindings, as it would lead to " "undefined behavior." msgstr "" #: src/variable_bindings/declare.md:5 msgid "" "It is not common to declare a variable binding and initialize it later in " "the function. It is more difficult for a reader to find the initialization " "when initialization is separated from declaration. It is common to declare " "and initialize a variable binding near where the variable will be used." msgstr "" #: src/variable_bindings/declare.md:11 msgid "// Declare a variable binding\n" msgstr "" #: src/variable_bindings/declare.md:17 msgid "// Initialize the binding\n" msgstr "" #: src/variable_bindings/declare.md:21 msgid "\"a binding: {}\"" msgstr "" #: src/variable_bindings/declare.md:25 msgid "// Error! Use of uninitialized binding\n" msgstr "" #: src/variable_bindings/declare.md:26 src/variable_bindings/declare.md:31 msgid "\"another binding: {}\"" msgstr "" #: src/variable_bindings/freeze.md:3 msgid "" "When data is bound by the same name immutably, it also _freezes_. _Frozen_ " "data can't be modified until the immutable binding goes out of scope:" msgstr "" #: src/variable_bindings/freeze.md:11 msgid "// Shadowing by immutable `_mutable_integer`\n" msgstr "" #: src/variable_bindings/freeze.md:14 msgid "// Error! `_mutable_integer` is frozen in this scope\n" msgstr "" #: src/variable_bindings/freeze.md:18 msgid "// `_mutable_integer` goes out of scope\n" msgstr "" #: src/variable_bindings/freeze.md:21 msgid "// Ok! `_mutable_integer` is not frozen in this scope\n" msgstr "" #: src/types.md:3 msgid "" "Rust provides several mechanisms to change or define the type of primitive " "and user defined types. The following sections cover:" msgstr "" #: src/types.md:6 msgid "[Casting](types/cast.md) between primitive types" msgstr "" #: src/types.md:7 msgid "Specifying the desired type of [literals](types/literals.md)" msgstr "" #: src/types.md:8 msgid "Using [type inference](types/inference.md)" msgstr "" #: src/types.md:9 msgid "[Aliasing](types/alias.md) types" msgstr "" #: src/types/cast.md:3 msgid "" "Rust provides no implicit type conversion (coercion) between primitive " "types. But, explicit type conversion (casting) can be performed using the " "`as` keyword." msgstr "" #: src/types/cast.md:6 msgid "" "Rules for converting between integral types follow C conventions generally, " "except in cases where C has undefined behavior. The behavior of all casts " "between integral types is well defined in Rust." msgstr "" #: src/types/cast.md:11 msgid "// Suppress all warnings from casts which overflow.\n" msgstr "" #: src/types/cast.md:17 msgid "// Error! No implicit conversion\n" msgstr "" #: src/types/cast.md:21 msgid "// Explicit conversion\n" msgstr "" #: src/types/cast.md:25 msgid "" "// Error! There are limitations in conversion rules.\n" " // A float cannot be directly converted to a char.\n" msgstr "" #: src/types/cast.md:30 msgid "\"Casting: {} -> {} -> {}\"" msgstr "" #: src/types/cast.md:32 msgid "" "// when casting any value to an unsigned type, T,\n" " // T::MAX + 1 is added or subtracted until the value\n" " // fits into the new type\n" msgstr "" #: src/types/cast.md:36 msgid "// 1000 already fits in a u16\n" msgstr "" #: src/types/cast.md:37 msgid "\"1000 as a u16 is: {}\"" msgstr "" #: src/types/cast.md:39 msgid "" "// 1000 - 256 - 256 - 256 = 232\n" " // Under the hood, the first 8 least significant bits (LSB) are kept,\n" " // while the rest towards the most significant bit (MSB) get truncated.\n" msgstr "" #: src/types/cast.md:42 src/types/cast.md:61 msgid "\"1000 as a u8 is : {}\"" msgstr "" #: src/types/cast.md:43 msgid "// -1 + 256 = 255\n" msgstr "" #: src/types/cast.md:44 msgid "\" -1 as a u8 is : {}\"" msgstr "" #: src/types/cast.md:46 msgid "// For positive numbers, this is the same as the modulus\n" msgstr "" #: src/types/cast.md:47 msgid "\"1000 mod 256 is : {}\"" msgstr "" #: src/types/cast.md:49 msgid "" "// When casting to a signed type, the (bitwise) result is the same as\n" " // first casting to the corresponding unsigned type. If the most " "significant\n" " // bit of that value is 1, then the value is negative.\n" msgstr "" #: src/types/cast.md:53 msgid "// Unless it already fits, of course.\n" msgstr "" #: src/types/cast.md:54 msgid "\" 128 as a i16 is: {}\"" msgstr "" #: src/types/cast.md:56 msgid "" "// In boundary case 128 value in 8-bit two's complement representation is " "-128\n" msgstr "" #: src/types/cast.md:57 msgid "\" 128 as a i8 is : {}\"" msgstr "" #: src/types/cast.md:59 msgid "" "// repeating the example above\n" " // 1000 as u8 -> 232\n" msgstr "" #: src/types/cast.md:62 msgid "" "// and the value of 232 in 8-bit two's complement representation is -24\n" msgstr "" #: src/types/cast.md:63 msgid "\" 232 as a i8 is : {}\"" msgstr "" #: src/types/cast.md:65 msgid "" "// Since Rust 1.45, the `as` keyword performs a *saturating cast*\n" " // when casting from float to int. If the floating point value exceeds\n" " // the upper bound or is less than the lower bound, the returned value\n" " // will be equal to the bound crossed.\n" msgstr "" #: src/types/cast.md:70 msgid "// 300.0 as u8 is 255\n" msgstr "" #: src/types/cast.md:71 src/types/cast.md:82 msgid "\" 300.0 as u8 is : {}\"" msgstr "" #: src/types/cast.md:72 msgid "// -100.0 as u8 is 0\n" msgstr "" #: src/types/cast.md:73 src/types/cast.md:84 msgid "\"-100.0 as u8 is : {}\"" msgstr "" #: src/types/cast.md:74 src/types/cast.md:85 msgid "// nan as u8 is 0\n" msgstr "" #: src/types/cast.md:75 src/types/cast.md:86 msgid "\" nan as u8 is : {}\"" msgstr "" #: src/types/cast.md:77 msgid "" "// This behavior incurs a small runtime cost and can be avoided\n" " // with unsafe methods, however the results might overflow and\n" " // return **unsound values**. Use these methods wisely:\n" msgstr "" #: src/types/cast.md:81 msgid "// 300.0 as u8 is 44\n" msgstr "" #: src/types/cast.md:83 msgid "// -100.0 as u8 is 156\n" msgstr "" #: src/types/literals.md:3 msgid "" "Numeric literals can be type annotated by adding the type as a suffix. As an " "example, to specify that the literal `42` should have the type `i32`, write " "`42i32`." msgstr "" #: src/types/literals.md:6 msgid "" "The type of unsuffixed numeric literals will depend on how they are used. If " "no constraint exists, the compiler will use `i32` for integers, and `f64` " "for floating-point numbers." msgstr "" #: src/types/literals.md:12 msgid "// Suffixed literals, their types are known at initialization\n" msgstr "" #: src/types/literals.md:17 msgid "// Unsuffixed literals, their types depend on how they are used\n" msgstr "" #: src/types/literals.md:21 msgid "// `size_of_val` returns the size of a variable in bytes\n" msgstr "" #: src/types/literals.md:22 msgid "\"size of `x` in bytes: {}\"" msgstr "" #: src/types/literals.md:23 msgid "\"size of `y` in bytes: {}\"" msgstr "" #: src/types/literals.md:24 msgid "\"size of `z` in bytes: {}\"" msgstr "" #: src/types/literals.md:25 msgid "\"size of `i` in bytes: {}\"" msgstr "" #: src/types/literals.md:26 msgid "\"size of `f` in bytes: {}\"" msgstr "" #: src/types/literals.md:30 msgid "" "There are some concepts used in the previous code that haven't been " "explained yet, here's a brief explanation for the impatient readers:" msgstr "" #: src/types/literals.md:33 msgid "" "`std::mem::size_of_val` is a function, but called with its _full path_. Code " "can be split in logical units called _modules_. In this case, the " "`size_of_val` function is defined in the `mem` module, and the `mem` module " "is defined in the `std` _crate_. For more details, see [modules](../mod.md) " "and [crates](../crates.md)." msgstr "" #: src/types/inference.md:3 msgid "" "The type inference engine is pretty smart. It does more than looking at the " "type of the value expression during an initialization. It also looks at how " "the variable is used afterwards to infer its type. Here's an advanced " "example of type inference:" msgstr "" #: src/types/inference.md:10 msgid "" "// Because of the annotation, the compiler knows that `elem` has type u8.\n" msgstr "" #: src/types/inference.md:13 msgid "// Create an empty vector (a growable array).\n" msgstr "" #: src/types/inference.md:15 msgid "" "// At this point the compiler doesn't know the exact type of `vec`, it\n" " // just knows that it's a vector of something (`Vec<_>`).\n" msgstr "" #: src/types/inference.md:18 msgid "// Insert `elem` in the vector.\n" msgstr "" #: src/types/inference.md:20 msgid "" "// Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec`)\n" " // TODO ^ Try commenting out the `vec.push(elem)` line\n" msgstr "" #: src/types/inference.md:27 msgid "" "No type annotation of variables was needed, the compiler is happy and so is " "the programmer!" msgstr "" #: src/types/alias.md:3 msgid "" "The `type` statement can be used to give a new name to an existing type. " "Types must have `UpperCamelCase` names, or the compiler will raise a " "warning. The exception to this rule are the primitive types: `usize`, `f32`, " "etc." msgstr "" #: src/types/alias.md:8 msgid "// `NanoSecond`, `Inch`, and `U64` are new names for `u64`.\n" msgstr "" #: src/types/alias.md:14 msgid "// `NanoSecond` = `Inch` = `U64` = `u64`.\n" msgstr "" #: src/types/alias.md:18 msgid "" "// Note that type aliases *don't* provide any extra type safety, because\n" " // aliases are *not* new types\n" msgstr "" #: src/types/alias.md:20 msgid "\"{} nanoseconds + {} inches = {} unit?\"" msgstr "" #: src/types/alias.md:27 msgid "" "The main use of aliases is to reduce boilerplate; for example the `io::" "Result` type is an alias for the `Result` type." msgstr "" #: src/types/alias.md:32 msgid "[Attributes](../attribute.md)" msgstr "" #: src/conversion.md:3 msgid "" "Primitive types can be converted to each other through [casting](types/cast." "md)." msgstr "" #: src/conversion.md:5 msgid "" "Rust addresses conversion between custom types (i.e., `struct` and `enum`) " "by the use of [traits](trait.md). The generic conversions will use the " "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`Into`]" "(https://doc.rust-lang.org/std/convert/trait.Into.html) traits. However " "there are more specific ones for the more common cases, in particular when " "converting to and from `String`s." msgstr "" #: src/conversion/from_into.md:3 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) traits are " "inherently linked, and this is actually part of its implementation. If you " "are able to convert type A from type B, then it should be easy to believe " "that we should be able to convert type B to type A." msgstr "" #: src/conversion/from_into.md:7 msgid "`From`" msgstr "" #: src/conversion/from_into.md:9 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) trait " "allows for a type to define how to create itself from another type, hence " "providing a very simple mechanism for converting between several types. " "There are numerous implementations of this trait within the standard library " "for conversion of primitive and common types." msgstr "" #: src/conversion/from_into.md:14 msgid "For example we can easily convert a `str` into a `String`" msgstr "" #: src/conversion/from_into.md:21 msgid "We can do something similar for defining a conversion for our own type." msgstr "" #: src/conversion/from_into.md:39 src/conversion/from_into.md:68 #: src/conversion/from_into.md:98 msgid "\"My number is {:?}\"" msgstr "" #: src/conversion/from_into.md:43 msgid "`Into`" msgstr "" #: src/conversion/from_into.md:45 msgid "" "The [`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) trait is " "simply the reciprocal of the `From` trait. It defines how to convert a type " "into another type." msgstr "" #: src/conversion/from_into.md:48 msgid "" "Calling `into()` typically requires us to specify the result type as the " "compiler is unable to determine this most of the time." msgstr "" #: src/conversion/from_into.md:66 msgid "// Try removing the type annotation\n" msgstr "" #: src/conversion/from_into.md:72 msgid "`From` and `Into` are interchangeable" msgstr "" #: src/conversion/from_into.md:74 msgid "" "`From` and `Into` are designed to be complementary. We do not need to " "provide an implementation for both traits. If you have implemented the " "`From` trait for your type, `Into` will call it when necessary. Note, " "however, that the converse is not true: implementing `Into` for your type " "will not automatically provide it with an implementation of `From`." msgstr "" #: src/conversion/from_into.md:86 msgid "// Define `From`\n" msgstr "" #: src/conversion/from_into.md:96 msgid "// use `Into`\n" msgstr "" #: src/conversion/try_from_try_into.md:3 msgid "" "Similar to [`From` and `Into`](from_into.html), [`TryFrom`](https://doc.rust-" "lang.org/std/convert/trait.TryFrom.html) and [`TryInto`](https://doc.rust-" "lang.org/std/convert/trait.TryInto.html) are generic traits for converting " "between types. Unlike `From`/`Into`, the `TryFrom`/`TryInto` traits are used " "for fallible conversions, and as such, return [`Result`](https://doc.rust-" "lang.org/std/result/enum.Result.html)s." msgstr "" #: src/conversion/try_from_try_into.md:33 msgid "// TryFrom\n" msgstr "" #: src/conversion/try_from_try_into.md:38 msgid "// TryInto\n" msgstr "" #: src/conversion/string.md:1 msgid "To and from Strings" msgstr "" #: src/conversion/string.md:3 msgid "Converting to String" msgstr "" #: src/conversion/string.md:5 msgid "" "To convert any type to a `String` is as simple as implementing the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "for the type. Rather than doing so directly, you should implement the [`fmt::" "Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html) trait which " "automatically provides [`ToString`](https://doc.rust-lang.org/std/string/" "trait.ToString.html) and also allows printing the type as discussed in the " "section on [`print!`](../hello/print.md)." msgstr "" #: src/conversion/string.md:19 msgid "\"Circle of radius {}\"" msgstr "" #: src/conversion/string.md:29 msgid "Parsing a String" msgstr "" #: src/conversion/string.md:31 msgid "" "It's useful to convert strings into many types, but one of the more common " "string operations is to convert them from string to number. The idiomatic " "approach to this is to use the [`parse`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) function and either to arrange for type " "inference or to specify the type to parse using the 'turbofish' syntax. Both " "alternatives are shown in the following example." msgstr "" #: src/conversion/string.md:37 msgid "" "This will convert the string into the type specified as long as the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait is " "implemented for that type. This is implemented for numerous types within the " "standard library." msgstr "" #: src/conversion/string.md:43 src/std_misc/process/wait.md:10 msgid "\"5\"" msgstr "" #: src/conversion/string.md:44 src/error/result.md:33 src/error/result.md:68 #: src/error/result/result_map.md:42 src/error/result/result_map.md:75 #: src/error/result/result_alias.md:36 src/error/result/early_returns.md:36 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:67 msgid "\"10\"" msgstr "" #: src/conversion/string.md:47 msgid "\"Sum: {:?}\"" msgstr "" #: src/conversion/string.md:51 msgid "" "To obtain this functionality on a user defined type simply implement the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "that type." msgstr "" #: src/conversion/string.md:74 msgid "\" 3 \"" msgstr "" #: src/expression.md:3 msgid "A Rust program is (mostly) made up of a series of statements:" msgstr "" #: src/expression.md:7 msgid "" "// statement\n" " // statement\n" " // statement\n" msgstr "" #: src/expression.md:13 msgid "" "There are a few kinds of statements in Rust. The most common two are " "declaring a variable binding, and using a `;` with an expression:" msgstr "" #: src/expression.md:18 msgid "// variable binding\n" msgstr "" #: src/expression.md:21 msgid "// expression;\n" msgstr "" #: src/expression.md:28 msgid "" "Blocks are expressions too, so they can be used as values in assignments. " "The last expression in the block will be assigned to the place expression " "such as a local variable. However, if the last expression of the block ends " "with a semicolon, the return value will be `()`." msgstr "" #: src/expression.md:41 msgid "// This expression will be assigned to `y`\n" msgstr "" #: src/expression.md:46 msgid "" "// The semicolon suppresses this expression and `()` is assigned to `z`\n" msgstr "" #: src/expression.md:50 msgid "\"x is {:?}\"" msgstr "" #: src/expression.md:51 msgid "\"y is {:?}\"" msgstr "" #: src/expression.md:52 msgid "\"z is {:?}\"" msgstr "" #: src/flow_control.md:3 msgid "" "An integral part of any programming language are ways to modify control " "flow: `if`/`else`, `for`, and others. Let's talk about them in Rust." msgstr "" #: src/flow_control/if_else.md:3 msgid "" "Branching with `if`\\-`else` is similar to other languages. Unlike many of " "them, the boolean condition doesn't need to be surrounded by parentheses, " "and each condition is followed by a block. `if`\\-`else` conditionals are " "expressions, and, all branches must return the same type." msgstr "" #: src/flow_control/if_else.md:13 msgid "\"{} is negative\"" msgstr "" #: src/flow_control/if_else.md:15 msgid "\"{} is positive\"" msgstr "" #: src/flow_control/if_else.md:17 msgid "\"{} is zero\"" msgstr "" #: src/flow_control/if_else.md:22 msgid "\", and is a small number, increase ten-fold\"" msgstr "" #: src/flow_control/if_else.md:24 msgid "// This expression returns an `i32`.\n" msgstr "" #: src/flow_control/if_else.md:27 msgid "\", and is a big number, halve the number\"" msgstr "" #: src/flow_control/if_else.md:29 msgid "// This expression must return an `i32` as well.\n" msgstr "" #: src/flow_control/if_else.md:31 msgid "// TODO ^ Try suppressing this expression with a semicolon.\n" msgstr "" #: src/flow_control/if_else.md:33 msgid "" "// ^ Don't forget to put a semicolon here! All `let` bindings need it.\n" msgstr "" #: src/flow_control/if_else.md:35 src/flow_control/match.md:35 msgid "\"{} -> {}\"" msgstr "" #: src/flow_control/loop.md:3 msgid "Rust provides a `loop` keyword to indicate an infinite loop." msgstr "" #: src/flow_control/loop.md:5 msgid "" "The `break` statement can be used to exit a loop at anytime, whereas the " "`continue` statement can be used to skip the rest of the iteration and start " "a new one." msgstr "" #: src/flow_control/loop.md:13 msgid "\"Let's count until infinity!\"" msgstr "" #: src/flow_control/loop.md:15 msgid "// Infinite loop\n" msgstr "" #: src/flow_control/loop.md:20 msgid "\"three\"" msgstr "" #: src/flow_control/loop.md:22 msgid "// Skip the rest of this iteration\n" msgstr "" #: src/flow_control/loop.md:29 msgid "\"OK, that's enough\"" msgstr "" #: src/flow_control/loop.md:31 msgid "// Exit this loop\n" msgstr "" #: src/flow_control/loop/nested.md:3 msgid "" "It's possible to `break` or `continue` outer loops when dealing with nested " "loops. In these cases, the loops must be annotated with some `'label`, and " "the label must be passed to the `break`/`continue` statement." msgstr "" #: src/flow_control/loop/nested.md:12 msgid "\"Entered the outer loop\"" msgstr "" #: src/flow_control/loop/nested.md:15 msgid "\"Entered the inner loop\"" msgstr "" #: src/flow_control/loop/nested.md:17 msgid "" "// This would break only the inner loop\n" " //break;\n" msgstr "" #: src/flow_control/loop/nested.md:20 msgid "// This breaks the outer loop\n" msgstr "" #: src/flow_control/loop/nested.md:24 msgid "\"This point will never be reached\"" msgstr "" #: src/flow_control/loop/nested.md:27 msgid "\"Exited the outer loop\"" msgstr "" #: src/flow_control/loop/return.md:3 msgid "" "One of the uses of a `loop` is to retry an operation until it succeeds. If " "the operation returns a value though, you might need to pass it to the rest " "of the code: put it after the `break`, and it will be returned by the `loop` " "expression." msgstr "" #: src/flow_control/while.md:3 msgid "" "The `while` keyword can be used to run a loop while a condition is true." msgstr "" #: src/flow_control/while.md:5 msgid "" "Let's write the infamous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) " "using a `while` loop." msgstr "" #: src/flow_control/while.md:9 msgid "// A counter variable\n" msgstr "" #: src/flow_control/while.md:12 msgid "// Loop while `n` is less than 101\n" msgstr "" #: src/flow_control/while.md:15 src/flow_control/for.md:17 #: src/flow_control/for.md:37 src/fn.md:34 msgid "\"fizzbuzz\"" msgstr "" #: src/flow_control/while.md:17 src/flow_control/for.md:19 #: src/flow_control/for.md:39 src/fn.md:36 msgid "\"fizz\"" msgstr "" #: src/flow_control/while.md:19 src/flow_control/for.md:21 #: src/flow_control/for.md:41 src/fn.md:38 msgid "\"buzz\"" msgstr "" #: src/flow_control/while.md:24 msgid "// Increment counter\n" msgstr "" #: src/flow_control/for.md:1 msgid "for loops" msgstr "" #: src/flow_control/for.md:5 msgid "" "The `for in` construct can be used to iterate through an `Iterator`. One of " "the easiest ways to create an iterator is to use the range notation `a..b`. " "This yields values from `a` (inclusive) to `b` (exclusive) in steps of one." msgstr "" #: src/flow_control/for.md:10 msgid "Let's write FizzBuzz using `for` instead of `while`." msgstr "" #: src/flow_control/for.md:14 src/flow_control/for.md:34 msgid "// `n` will take the values: 1, 2, ..., 100 in each iteration\n" msgstr "" #: src/flow_control/for.md:29 msgid "" "Alternatively, `a..=b` can be used for a range that is inclusive on both " "ends. The above can be written as:" msgstr "" #: src/flow_control/for.md:49 msgid "for and iterators" msgstr "" #: src/flow_control/for.md:51 msgid "" "The `for in` construct is able to interact with an `Iterator` in several " "ways. As discussed in the section on the [Iterator](../trait/iter.md) trait, " "by default the `for` loop will apply the `into_iter` function to the " "collection. However, this is not the only means of converting collections " "into iterators." msgstr "" #: src/flow_control/for.md:56 msgid "" "`into_iter`, `iter` and `iter_mut` all handle the conversion of a collection " "into an iterator in different ways, by providing different views on the data " "within." msgstr "" #: src/flow_control/for.md:60 msgid "" "`iter` - This borrows each element of the collection through each iteration. " "Thus leaving the collection untouched and available for reuse after the loop." msgstr "" #: src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Frank\"" msgstr "" #: src/flow_control/for.md:65 src/flow_control/for.md:69 #: src/flow_control/for.md:85 src/flow_control/for.md:89 #: src/flow_control/for.md:104 src/flow_control/for.md:108 msgid "\"Ferris\"" msgstr "" #: src/flow_control/for.md:69 src/flow_control/for.md:89 #: src/flow_control/for.md:108 msgid "\"There is a rustacean among us!\"" msgstr "" #: src/flow_control/for.md:70 msgid "// TODO ^ Try deleting the & and matching just \"Ferris\"\n" msgstr "" #: src/flow_control/for.md:71 src/flow_control/for.md:90 msgid "\"Hello {}\"" msgstr "" #: src/flow_control/for.md:75 src/flow_control/for.md:94 #: src/flow_control/for.md:113 msgid "\"names: {:?}\"" msgstr "" #: src/flow_control/for.md:79 msgid "" "`into_iter` - This consumes the collection so that on each iteration the " "exact data is provided. Once the collection has been consumed it is no " "longer available for reuse as it has been 'moved' within the loop." msgstr "" #: src/flow_control/for.md:99 msgid "" "`iter_mut` - This mutably borrows each element of the collection, allowing " "for the collection to be modified in place." msgstr "" #: src/flow_control/for.md:109 msgid "\"Hello\"" msgstr "" #: src/flow_control/for.md:117 msgid "" "In the above snippets note the type of `match` branch, that is the key " "difference in the types of iteration. The difference in type then of course " "implies differing actions that are able to be performed." msgstr "" #: src/flow_control/for.md:123 msgid "[Iterator](../trait/iter.md)" msgstr "" #: src/flow_control/match.md:3 msgid "" "Rust provides pattern matching via the `match` keyword, which can be used " "like a C `switch`. The first matching arm is evaluated and all possible " "values must be covered." msgstr "" #: src/flow_control/match.md:10 msgid "// TODO ^ Try different values for `number`\n" msgstr "" #: src/flow_control/match.md:12 msgid "\"Tell me about {}\"" msgstr "" #: src/flow_control/match.md:14 msgid "// Match a single value\n" msgstr "" #: src/flow_control/match.md:15 msgid "\"One!\"" msgstr "" #: src/flow_control/match.md:16 msgid "// Match several values\n" msgstr "" #: src/flow_control/match.md:17 msgid "\"This is a prime\"" msgstr "" #: src/flow_control/match.md:18 msgid "" "// TODO ^ Try adding 13 to the list of prime values\n" " // Match an inclusive range\n" msgstr "" #: src/flow_control/match.md:20 msgid "\"A teen\"" msgstr "" #: src/flow_control/match.md:21 msgid "// Handle the rest of cases\n" msgstr "" #: src/flow_control/match.md:22 msgid "\"Ain't special\"" msgstr "" #: src/flow_control/match.md:23 msgid "// TODO ^ Try commenting out this catch-all arm\n" msgstr "" #: src/flow_control/match.md:27 msgid "// Match is an expression too\n" msgstr "" #: src/flow_control/match.md:29 msgid "// The arms of a match must cover all the possible values\n" msgstr "" #: src/flow_control/match.md:32 msgid "// TODO ^ Try commenting out one of these arms\n" msgstr "" #: src/flow_control/match/destructuring.md:3 msgid "A `match` block can destructure items in a variety of ways." msgstr "" #: src/flow_control/match/destructuring.md:5 msgid "[Destructuring Tuples](destructuring/destructure_tuple.md)" msgstr "" #: src/flow_control/match/destructuring.md:6 msgid "[Destructuring Arrays and Slices](destructuring/destructure_slice.md)" msgstr "" #: src/flow_control/match/destructuring.md:7 msgid "[Destructuring Enums](destructuring/destructure_enum.md)" msgstr "" #: src/flow_control/match/destructuring.md:8 msgid "[Destructuring Pointers](destructuring/destructure_pointers.md)" msgstr "" #: src/flow_control/match/destructuring.md:9 msgid "[Destructuring Structures](destructuring/destructure_structures.md)" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:3 msgid "Tuples can be destructured in a `match` as follows:" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:8 msgid "// TODO ^ Try different values for `triple`\n" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:10 msgid "\"Tell me about {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:11 msgid "// Match can be used to destructure a tuple\n" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:13 msgid "// Destructure the second and third elements\n" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:14 msgid "\"First is `0`, `y` is {:?}, and `z` is {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:15 msgid "\"First is `1` and the rest doesn't matter\"" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:16 msgid "\"last is `2` and the rest doesn't matter\"" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:17 msgid "\"First is `3`, last is `4`, and the rest doesn't matter\"" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:18 msgid "// `..` can be used to ignore the rest of the tuple\n" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:19 msgid "\"It doesn't matter what they are\"" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:20 msgid "// `_` means don't bind the value to a variable\n" msgstr "" #: src/flow_control/match/destructuring/destructure_tuple.md:27 msgid "[Tuples](../../../primitives/tuples.md)" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:3 msgid "Like tuples, arrays and slices can be destructured this way:" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:7 msgid "// Try changing the values in the array, or make it a slice!\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:11 msgid "" "// Binds the second and the third elements to the respective variables\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:13 msgid "\"array[0] = 0, array[1] = {}, array[2] = {}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:15 msgid "// Single values can be ignored with _\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:17 msgid "\"array[0] = 1, array[2] = {} and array[1] was ignored\"" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:21 msgid "// You can also bind some and ignore the rest\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:23 msgid "\"array[0] = -1, array[1] = {} and all the other ones were ignored\"" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:26 msgid "" "// The code below would not compile\n" " // [-1, second] => ...\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:29 msgid "" "// Or store them in another array/slice (the type depends on\n" " // that of the value that is being matched against)\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:32 msgid "\"array[0] = 3, array[1] = {} and the other elements were {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:36 msgid "" "// Combining these patterns, we can, for example, bind the first and\n" " // last values, and store the rest of them in a single array\n" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:39 msgid "\"array[0] = {}, middle = {:?}, array[2] = {}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_slice.md:48 msgid "" "[Arrays and Slices](../../../primitives/array.md) and [Binding](../binding." "md) for `@` sigil" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:3 msgid "An `enum` is destructured similarly:" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:6 msgid "" "// `allow` required to silence warnings because only\n" "// one variant is used.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:10 msgid "// These 3 are specified solely by their name.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:14 msgid "// These likewise tie `u32` tuples to different names: color models.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:24 msgid "// TODO ^ Try different variants for `color`\n" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:26 msgid "\"What color is it?\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:27 msgid "// An `enum` can be destructured using a `match`.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:29 msgid "\"The color is Red!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:30 msgid "\"The color is Blue!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:31 msgid "\"The color is Green!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:33 msgid "\"Red: {}, green: {}, and blue: {}!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:35 msgid "\"Hue: {}, saturation: {}, value: {}!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:37 msgid "\"Hue: {}, saturation: {}, lightness: {}!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:39 msgid "\"Cyan: {}, magenta: {}, yellow: {}!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:41 msgid "\"Cyan: {}, magenta: {}, yellow: {}, key (black): {}!\"" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:43 msgid "// Don't need another arm because all variants have been examined\n" msgstr "" #: src/flow_control/match/destructuring/destructure_enum.md:50 msgid "" "[`#[allow(...)]`](../../../attribute/unused.md), [color models](https://en." "wikipedia.org/wiki/Color_model) and [`enum`](../../../custom_types/enum.md)" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:3 msgid "" "For pointers, a distinction needs to be made between destructuring and " "dereferencing as they are different concepts which are used differently from " "languages like C/C++." msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:7 msgid "Dereferencing uses `*`" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:8 msgid "Destructuring uses `&`, `ref`, and `ref mut`" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:12 msgid "" "// Assign a reference of type `i32`. The `&` signifies there\n" " // is a reference being assigned.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:17 msgid "" "// If `reference` is pattern matched against `&val`, it results\n" " // in a comparison like:\n" " // `&i32`\n" " // `&val`\n" " // ^ We see that if the matching `&`s are dropped, then the `i32`\n" " // should be assigned to `val`.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:23 msgid "\"Got a value via destructuring: {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:26 msgid "// To avoid the `&`, you dereference before matching.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:28 msgid "\"Got a value via dereferencing: {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:31 msgid "" "// What if you don't start with a reference? `reference` was a `&`\n" " // because the right side was already a reference. This is not\n" " // a reference because the right side is not one.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:36 msgid "" "// Rust provides `ref` for exactly this purpose. It modifies the\n" " // assignment so that a reference is created for the element; this\n" " // reference is assigned.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:41 msgid "" "// Accordingly, by defining 2 values without references, references\n" " // can be retrieved via `ref` and `ref mut`.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:46 msgid "// Use `ref` keyword to create a reference.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:48 msgid "\"Got a reference to a value: {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:51 msgid "// Use `ref mut` similarly.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:54 msgid "" "// Got a reference. Gotta dereference it before we can\n" " // add anything to it.\n" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:57 msgid "\"We added 10. `mut_value`: {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_pointers.md:65 msgid "[The ref pattern](../../../scope/borrow/ref.md)" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:3 msgid "Similarly, a `struct` can be destructured as shown:" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:12 msgid "// Try changing the values in the struct to see what happens\n" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:16 msgid "\"First of x is 1, b = {}, y = {} \"" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:18 msgid "" "// you can destructure structs and rename the variables,\n" " // the order is not important\n" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:20 msgid "\"y is 2, i = {:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:22 msgid "// and you can also ignore some variables:\n" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:23 msgid "\"y = {}, we don't care about x\"" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:24 msgid "" "// this will give an error: pattern does not mention field `x`\n" " //Foo { y } => println!(\"y = {}\", y),\n" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:30 msgid "// You do not need a match block to destructure structs:\n" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:32 msgid "\"Outside: x0 = {x0:?}, y0 = {y0}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:34 msgid "// Destructuring works with nested structs as well:\n" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:41 msgid "\"Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}\"" msgstr "" #: src/flow_control/match/destructuring/destructure_structures.md:47 msgid "[Structs](../../../custom_types/structs.md)" msgstr "" #: src/flow_control/match/guard.md:3 msgid "A `match` _guard_ can be added to filter the arm." msgstr "" #: src/flow_control/match/guard.md:14 msgid "// ^ TODO try different values for `temperature`\n" msgstr "" #: src/flow_control/match/guard.md:17 msgid "\"{}C is above 30 Celsius\"" msgstr "" #: src/flow_control/match/guard.md:18 msgid "// The `if condition` part ^ is a guard\n" msgstr "" #: src/flow_control/match/guard.md:19 msgid "\"{}C is equal to or below 30 Celsius\"" msgstr "" #: src/flow_control/match/guard.md:21 msgid "\"{}F is above 86 Fahrenheit\"" msgstr "" #: src/flow_control/match/guard.md:22 msgid "\"{}F is equal to or below 86 Fahrenheit\"" msgstr "" #: src/flow_control/match/guard.md:27 msgid "" "Note that the compiler won't take guard conditions into account when " "checking if all patterns are covered by the match expression." msgstr "" #: src/flow_control/match/guard.md:35 msgid "\"Zero\"" msgstr "" #: src/flow_control/match/guard.md:36 msgid "\"Greater than zero\"" msgstr "" #: src/flow_control/match/guard.md:37 msgid "" "// _ => unreachable!(\"Should never happen.\"),\n" " // TODO ^ uncomment to fix compilation\n" msgstr "" #: src/flow_control/match/guard.md:45 msgid "" "[Tuples](../../primitives/tuples.md) [Enums](../../custom_types/enum.md)" msgstr "" #: src/flow_control/match/binding.md:3 msgid "" "Indirectly accessing a variable makes it impossible to branch and use that " "variable without re-binding. `match` provides the `@` sigil for binding " "values to names:" msgstr "" #: src/flow_control/match/binding.md:8 msgid "// A function `age` which returns a `u32`.\n" msgstr "" #: src/flow_control/match/binding.md:14 msgid "\"Tell me what type of person you are\"" msgstr "" #: src/flow_control/match/binding.md:17 msgid "\"I haven't celebrated my first birthday yet\"" msgstr "" #: src/flow_control/match/binding.md:18 msgid "" "// Could `match` 1 ..= 12 directly but then what age\n" " // would the child be? Instead, bind to `n` for the\n" " // sequence of 1 ..= 12. Now the age can be reported.\n" msgstr "" #: src/flow_control/match/binding.md:21 msgid "\"I'm a child of age {:?}\"" msgstr "" #: src/flow_control/match/binding.md:22 msgid "\"I'm a teen of age {:?}\"" msgstr "" #: src/flow_control/match/binding.md:23 msgid "// Nothing bound. Return the result.\n" msgstr "" #: src/flow_control/match/binding.md:24 msgid "\"I'm an old person of age {:?}\"" msgstr "" #: src/flow_control/match/binding.md:29 msgid "" "You can also use binding to \"destructure\" `enum` variants, such as " "`Option`:" msgstr "" #: src/flow_control/match/binding.md:38 msgid "" "// Got `Some` variant, match if its value, bound to `n`,\n" " // is equal to 42.\n" msgstr "" #: src/flow_control/match/binding.md:40 msgid "\"The Answer: {}!\"" msgstr "" #: src/flow_control/match/binding.md:41 msgid "// Match any other number.\n" msgstr "" #: src/flow_control/match/binding.md:42 msgid "\"Not interesting... {}\"" msgstr "" #: src/flow_control/match/binding.md:43 msgid "// Match anything else (`None` variant).\n" msgstr "" #: src/flow_control/match/binding.md:51 msgid "" "[`functions`](../../fn.md), [`enums`](../../custom_types/enum.md) and " "[`Option`](../../std/option.md)" msgstr "" #: src/flow_control/if_let.md:3 msgid "" "For some use cases, when matching enums, `match` is awkward. For example:" msgstr "" #: src/flow_control/if_let.md:6 src/flow_control/while_let.md:7 #: src/flow_control/while_let.md:35 msgid "// Make `optional` of type `Option`\n" msgstr "" #: src/flow_control/if_let.md:10 msgid "\"This is a really long string and `{:?}`\"" msgstr "" #: src/flow_control/if_let.md:12 msgid "" "// ^ Required because `match` is exhaustive. Doesn't it seem\n" " // like wasted space?\n" msgstr "" #: src/flow_control/if_let.md:18 msgid "" "`if let` is cleaner for this use case and in addition allows various failure " "options to be specified:" msgstr "" #: src/flow_control/if_let.md:23 msgid "// All have type `Option`\n" msgstr "" #: src/flow_control/if_let.md:28 msgid "" "// The `if let` construct reads: \"if `let` destructures `number` into\n" " // `Some(i)`, evaluate the block (`{}`).\n" msgstr "" #: src/flow_control/if_let.md:31 src/flow_control/if_let.md:36 #: src/flow_control/if_let.md:46 msgid "\"Matched {:?}!\"" msgstr "" #: src/flow_control/if_let.md:34 msgid "// If you need to specify a failure, use an else:\n" msgstr "" #: src/flow_control/if_let.md:38 msgid "// Destructure failed. Change to the failure case.\n" msgstr "" #: src/flow_control/if_let.md:39 src/flow_control/if_let.md:50 msgid "\"Didn't match a number. Let's go with a letter!\"" msgstr "" #: src/flow_control/if_let.md:42 msgid "// Provide an altered failing condition.\n" msgstr "" #: src/flow_control/if_let.md:47 msgid "" "// Destructure failed. Evaluate an `else if` condition to see if the\n" " // alternate failure branch should be taken:\n" msgstr "" #: src/flow_control/if_let.md:52 msgid "// The condition evaluated false. This branch is the default:\n" msgstr "" #: src/flow_control/if_let.md:53 msgid "\"I don't like letters. Let's go with an emoticon :)!\"" msgstr "" #: src/flow_control/if_let.md:58 msgid "In the same way, `if let` can be used to match any enum value:" msgstr "" #: src/flow_control/if_let.md:61 msgid "// Our example enum\n" msgstr "" #: src/flow_control/if_let.md:69 msgid "// Create example variables\n" msgstr "" #: src/flow_control/if_let.md:74 src/flow_control/if_let.md:110 msgid "// Variable a matches Foo::Bar\n" msgstr "" #: src/flow_control/if_let.md:76 src/flow_control/if_let.md:113 msgid "\"a is foobar\"" msgstr "" #: src/flow_control/if_let.md:79 msgid "" "// Variable b does not match Foo::Bar\n" " // So this will print nothing\n" msgstr "" #: src/flow_control/if_let.md:82 msgid "\"b is foobar\"" msgstr "" #: src/flow_control/if_let.md:85 msgid "" "// Variable c matches Foo::Qux which has a value\n" " // Similar to Some() in the previous example\n" msgstr "" #: src/flow_control/if_let.md:88 msgid "\"c is {}\"" msgstr "" #: src/flow_control/if_let.md:91 msgid "// Binding also works with `if let`\n" msgstr "" #: src/flow_control/if_let.md:93 msgid "\"c is one hundred\"" msgstr "" #: src/flow_control/if_let.md:98 msgid "" "Another benefit is that `if let` allows us to match non-parameterized enum " "variants. This is true even in cases where the enum doesn't implement or " "derive `PartialEq`. In such cases `if Foo::Bar == a` would fail to compile, " "because instances of the enum cannot be equated, however `if let` will " "continue to work." msgstr "" #: src/flow_control/if_let.md:100 msgid "Would you like a challenge? Fix the following example to use `if let`:" msgstr "" #: src/flow_control/if_let.md:103 msgid "" "// This enum purposely neither implements nor derives PartialEq.\n" "// That is why comparing Foo::Bar == a fails below.\n" msgstr "" #: src/flow_control/if_let.md:112 msgid "// ^-- this causes a compile-time error. Use `if let` instead.\n" msgstr "" #: src/flow_control/if_let.md:120 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/160)" msgstr "" #: src/flow_control/let_else.md:3 msgid "🛈 stable since: rust 1.65" msgstr "" #: src/flow_control/let_else.md:5 msgid "" "🛈 you can target specific edition by compiling like this `rustc --" "edition=2021 main.rs`" msgstr "" #: src/flow_control/let_else.md:8 msgid "" "With `let`\\-`else`, a refutable pattern can match and bind variables in the " "surrounding scope like a normal `let`, or else diverge (e.g. `break`, " "`return`, `panic!`) when the pattern doesn't match." msgstr "" #: src/flow_control/let_else.md:16 src/flow_control/let_else.md:39 #: src/std/str.md:41 msgid "' '" msgstr "" #: src/flow_control/let_else.md:18 src/flow_control/let_else.md:42 msgid "\"Can't segment count item pair: '{s}'\"" msgstr "" #: src/flow_control/let_else.md:21 src/flow_control/let_else.md:47 msgid "\"Can't parse integer: '{count_str}'\"" msgstr "" #: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52 msgid "\"3 chairs\"" msgstr "" #: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52 msgid "\"chairs\"" msgstr "" #: src/flow_control/let_else.md:31 msgid "" "The scope of name bindings is the main thing that makes this different from " "`match` or `if let`\\-`else` expressions. You could previously approximate " "these patterns with an unfortunate bit of repetition and an outer `let`:" msgstr "" #: src/flow_control/let_else.md:57 msgid "" "[option](../std/option.md), [match](./match.md), [if let](./if_let.md) and " "the [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)." msgstr "" #: src/flow_control/while_let.md:3 msgid "" "Similar to `if let`, `while let` can make awkward `match` sequences more " "tolerable. Consider the following sequence that increments `i`:" msgstr "" #: src/flow_control/while_let.md:9 msgid "// Repeatedly try this test.\n" msgstr "" #: src/flow_control/while_let.md:13 msgid "// If `optional` destructures, evaluate the block.\n" msgstr "" #: src/flow_control/while_let.md:16 src/flow_control/while_let.md:42 msgid "\"Greater than 9, quit!\"" msgstr "" #: src/flow_control/while_let.md:19 src/flow_control/while_let.md:45 msgid "\"`i` is `{:?}`. Try again.\"" msgstr "" #: src/flow_control/while_let.md:22 msgid "// ^ Requires 3 indentations!\n" msgstr "" #: src/flow_control/while_let.md:24 msgid "// Quit the loop when the destructure fails:\n" msgstr "" #: src/flow_control/while_let.md:26 msgid "// ^ Why should this be required? There must be a better way!\n" msgstr "" #: src/flow_control/while_let.md:31 msgid "Using `while let` makes this sequence much nicer:" msgstr "" #: src/flow_control/while_let.md:38 msgid "" "// This reads: \"while `let` destructures `optional` into\n" " // `Some(i)`, evaluate the block (`{}`). Else `break`.\n" msgstr "" #: src/flow_control/while_let.md:48 msgid "" "// ^ Less rightward drift and doesn't require\n" " // explicitly handling the failing case.\n" msgstr "" #: src/flow_control/while_let.md:51 msgid "" "// ^ `if let` had additional optional `else`/`else if`\n" " // clauses. `while let` does not have these.\n" msgstr "" #: src/flow_control/while_let.md:58 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/214)" msgstr "" #: src/fn.md:3 msgid "" "Functions are declared using the `fn` keyword. Its arguments are type " "annotated, just like variables, and, if the function returns a value, the " "return type must be specified after an arrow `->`." msgstr "" #: src/fn.md:7 msgid "" "The final expression in the function will be used as return value. " "Alternatively, the `return` statement can be used to return a value earlier " "from within the function, even from inside loops or `if` statements." msgstr "" #: src/fn.md:11 msgid "Let's rewrite FizzBuzz using functions!" msgstr "" #: src/fn.md:14 msgid "" "// Unlike C/C++, there's no restriction on the order of function " "definitions\n" msgstr "" #: src/fn.md:16 msgid "// We can use this function here, and define it somewhere later\n" msgstr "" #: src/fn.md:19 msgid "// Function that returns a boolean value\n" msgstr "" #: src/fn.md:22 msgid "// Corner case, early return\n" msgstr "" #: src/fn.md:27 msgid "// This is an expression, the `return` keyword is not necessary here\n" msgstr "" #: src/fn.md:30 msgid "" "// Functions that \"don't\" return a value, actually return the unit type " "`()`\n" msgstr "" #: src/fn.md:43 msgid "" "// When a function returns `()`, the return type can be omitted from the\n" "// signature\n" msgstr "" #: src/fn/methods.md:1 msgid "Associated functions & Methods" msgstr "" #: src/fn/methods.md:3 msgid "" "Some functions are connected to a particular type. These come in two forms: " "associated functions, and methods. Associated functions are functions that " "are defined on a type generally, while methods are associated functions that " "are called on a particular instance of a type." msgstr "" #: src/fn/methods.md:13 msgid "" "// Implementation block, all `Point` associated functions & methods go in " "here\n" msgstr "" #: src/fn/methods.md:16 msgid "" "// This is an \"associated function\" because this function is associated " "with\n" " // a particular type, that is, Point.\n" " //\n" " // Associated functions don't need to be called with an instance.\n" " // These functions are generally used like constructors.\n" msgstr "" #: src/fn/methods.md:25 msgid "// Another associated function, taking two arguments:\n" msgstr "" #: src/fn/methods.md:37 msgid "" "// This is a method\n" " // `&self` is sugar for `self: &Self`, where `Self` is the type of the\n" " // caller object. In this case `Self` = `Rectangle`\n" msgstr "" #: src/fn/methods.md:41 msgid "// `self` gives access to the struct fields via the dot operator\n" msgstr "" #: src/fn/methods.md:45 msgid "" "// `abs` is a `f64` method that returns the absolute value of the\n" " // caller\n" msgstr "" #: src/fn/methods.md:57 msgid "" "// This method requires the caller object to be mutable\n" " // `&mut self` desugars to `self: &mut Self`\n" msgstr "" #: src/fn/methods.md:67 msgid "// `Pair` owns resources: two heap allocated integers\n" msgstr "" #: src/fn/methods.md:72 msgid "" "// This method \"consumes\" the resources of the caller object\n" " // `self` desugars to `self: Self`\n" msgstr "" #: src/fn/methods.md:75 msgid "// Destructure `self`\n" msgstr "" #: src/fn/methods.md:78 msgid "\"Destroying Pair({}, {})\"" msgstr "" #: src/fn/methods.md:80 msgid "// `first` and `second` go out of scope and get freed\n" msgstr "" #: src/fn/methods.md:86 msgid "// Associated functions are called using double colons\n" msgstr "" #: src/fn/methods.md:91 msgid "" "// Methods are called using the dot operator\n" " // Note that the first argument `&self` is implicitly passed, i.e.\n" " // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`\n" msgstr "" #: src/fn/methods.md:94 msgid "\"Rectangle perimeter: {}\"" msgstr "" #: src/fn/methods.md:95 msgid "\"Rectangle area: {}\"" msgstr "" #: src/fn/methods.md:102 msgid "" "// Error! `rectangle` is immutable, but this method requires a mutable\n" " // object\n" " //rectangle.translate(1.0, 0.0);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/fn/methods.md:107 msgid "// Okay! Mutable objects can call mutable methods\n" msgstr "" #: src/fn/methods.md:114 msgid "" "// Error! Previous `destroy` call \"consumed\" `pair`\n" " //pair.destroy();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/fn/closures.md:3 msgid "" "Closures are functions that can capture the enclosing environment. For " "example, a closure that captures the `x` variable:" msgstr "" #: src/fn/closures.md:10 msgid "" "The syntax and capabilities of closures make them very convenient for on the " "fly usage. Calling a closure is exactly like calling a function. However, " "both input and return types _can_ be inferred and input variable names " "_must_ be specified." msgstr "" #: src/fn/closures.md:15 msgid "Other characteristics of closures include:" msgstr "" #: src/fn/closures.md:17 msgid "using `||` instead of `()` around input variables." msgstr "" #: src/fn/closures.md:18 msgid "" "optional body delimitation (`{}`) for a single line expression (mandatory " "otherwise)." msgstr "" #: src/fn/closures.md:19 msgid "the ability to capture the outer environment variables." msgstr "" #: src/fn/closures.md:25 msgid "" "// A regular function can't refer to variables in the enclosing environment\n" " //fn function(i: i32) -> i32 { i + outer_var }\n" " // TODO: uncomment the line above and see the compiler error. The " "compiler\n" " // suggests that we define a closure instead.\n" msgstr "" #: src/fn/closures.md:30 msgid "" "// Closures are anonymous, here we are binding them to references.\n" " // Annotation is identical to function annotation but is optional\n" " // as are the `{}` wrapping the body. These nameless functions\n" " // are assigned to appropriately named variables.\n" msgstr "" #: src/fn/closures.md:37 msgid "// Call the closures.\n" msgstr "" #: src/fn/closures.md:38 msgid "\"closure_annotated: {}\"" msgstr "" #: src/fn/closures.md:39 msgid "\"closure_inferred: {}\"" msgstr "" #: src/fn/closures.md:40 msgid "" "// Once closure's type has been inferred, it cannot be inferred again with " "another type.\n" " //println!(\"cannot reuse closure_inferred with another type: {}\", " "closure_inferred(42i64));\n" " // TODO: uncomment the line above and see the compiler error.\n" msgstr "" #: src/fn/closures.md:44 msgid "" "// A closure taking no arguments which returns an `i32`.\n" " // The return type is inferred.\n" msgstr "" #: src/fn/closures.md:47 msgid "\"closure returning one: {}\"" msgstr "" #: src/fn/closures/capture.md:3 msgid "" "Closures are inherently flexible and will do what the functionality requires " "to make the closure work without annotation. This allows capturing to " "flexibly adapt to the use case, sometimes moving and sometimes borrowing. " "Closures can capture variables:" msgstr "" #: src/fn/closures/capture.md:8 msgid "by reference: `&T`" msgstr "" #: src/fn/closures/capture.md:9 msgid "by mutable reference: `&mut T`" msgstr "" #: src/fn/closures/capture.md:10 msgid "by value: `T`" msgstr "" #: src/fn/closures/capture.md:12 msgid "" "They preferentially capture variables by reference and only go lower when " "required." msgstr "" #: src/fn/closures/capture.md:19 msgid "\"green\"" msgstr "" #: src/fn/closures/capture.md:21 msgid "" "// A closure to print `color` which immediately borrows (`&`) `color` and\n" " // stores the borrow and closure in the `print` variable. It will " "remain\n" " // borrowed until `print` is used the last time. \n" " //\n" " // `println!` only requires arguments by immutable reference so it " "doesn't\n" " // impose anything more restrictive.\n" msgstr "" #: src/fn/closures/capture.md:27 msgid "\"`color`: {}\"" msgstr "" #: src/fn/closures/capture.md:29 msgid "// Call the closure using the borrow.\n" msgstr "" #: src/fn/closures/capture.md:32 msgid "" "// `color` can be borrowed immutably again, because the closure only holds\n" " // an immutable reference to `color`. \n" msgstr "" #: src/fn/closures/capture.md:37 msgid "// A move or reborrow is allowed after the final use of `print`\n" msgstr "" #: src/fn/closures/capture.md:42 msgid "" "// A closure to increment `count` could take either `&mut count` or `count`\n" " // but `&mut count` is less restrictive so it takes that. Immediately\n" " // borrows `count`.\n" " //\n" " // A `mut` is required on `inc` because a `&mut` is stored inside. " "Thus,\n" " // calling the closure mutates `count` which requires a `mut`.\n" msgstr "" #: src/fn/closures/capture.md:50 msgid "\"`count`: {}\"" msgstr "" #: src/fn/closures/capture.md:53 msgid "// Call the closure using a mutable borrow.\n" msgstr "" #: src/fn/closures/capture.md:56 msgid "" "// The closure still mutably borrows `count` because it is called later.\n" " // An attempt to reborrow will lead to an error.\n" " // let _reborrow = &count; \n" " // ^ TODO: try uncommenting this line.\n" msgstr "" #: src/fn/closures/capture.md:62 msgid "" "// The closure no longer needs to borrow `&mut count`. Therefore, it is\n" " // possible to reborrow without an error\n" msgstr "" #: src/fn/closures/capture.md:67 msgid "// A non-copy type.\n" msgstr "" #: src/fn/closures/capture.md:70 msgid "" "// `mem::drop` requires `T` so this must take by value. A copy type\n" " // would copy into the closure leaving the original untouched.\n" " // A non-copy must move and so `movable` immediately moves into\n" " // the closure.\n" msgstr "" #: src/fn/closures/capture.md:75 msgid "\"`movable`: {:?}\"" msgstr "" #: src/fn/closures/capture.md:79 msgid "// `consume` consumes the variable so this can only be called once.\n" msgstr "" #: src/fn/closures/capture.md:81 msgid "" "// consume();\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" #: src/fn/closures/capture.md:86 msgid "" "Using `move` before vertical pipes forces closure to take ownership of " "captured variables:" msgstr "" #: src/fn/closures/capture.md:91 msgid "// `Vec` has non-copy semantics.\n" msgstr "" #: src/fn/closures/capture.md:99 msgid "" "// println!(\"There're {} elements in vec\", haystack.len());\n" " // ^ Uncommenting above line will result in compile-time error\n" " // because borrow checker doesn't allow re-using variable after it\n" " // has been moved.\n" msgstr "" #: src/fn/closures/capture.md:104 msgid "" "// Removing `move` from closure's signature will cause closure\n" " // to borrow _haystack_ variable immutably, hence _haystack_ is still\n" " // available and uncommenting above line will not cause an error.\n" msgstr "" #: src/fn/closures/capture.md:112 msgid "" "[`Box`](../../std/box.md) and [`std::mem::drop`](https://doc.rust-lang.org/" "std/mem/fn.drop.html)" msgstr "" #: src/fn/closures/input_parameters.md:3 msgid "" "While Rust chooses how to capture variables on the fly mostly without type " "annotation, this ambiguity is not allowed when writing functions. When " "taking a closure as an input parameter, the closure's complete type must be " "annotated using one of a few `traits`, and they're determined by what the " "closure does with captured value. In order of decreasing restriction, they " "are:" msgstr "" #: src/fn/closures/input_parameters.md:10 msgid "`Fn`: the closure uses the captured value by reference (`&T`)" msgstr "" #: src/fn/closures/input_parameters.md:11 msgid "" "`FnMut`: the closure uses the captured value by mutable reference (`&mut T`)" msgstr "" #: src/fn/closures/input_parameters.md:12 msgid "`FnOnce`: the closure uses the captured value by value (`T`)" msgstr "" #: src/fn/closures/input_parameters.md:14 msgid "" "On a variable-by-variable basis, the compiler will capture variables in the " "least restrictive manner possible." msgstr "" #: src/fn/closures/input_parameters.md:17 msgid "" "For instance, consider a parameter annotated as `FnOnce`. This specifies " "that the closure _may_ capture by `&T`, `&mut T`, or `T`, but the compiler " "will ultimately choose based on how the captured variables are used in the " "closure." msgstr "" #: src/fn/closures/input_parameters.md:22 msgid "" "This is because if a move is possible, then any type of borrow should also " "be possible. Note that the reverse is not true. If the parameter is " "annotated as `Fn`, then capturing variables by `&mut T` or `T` are not " "allowed. However, `&T` is allowed." msgstr "" #: src/fn/closures/input_parameters.md:27 msgid "" "In the following example, try swapping the usage of `Fn`, `FnMut`, and " "`FnOnce` to see what happens:" msgstr "" #: src/fn/closures/input_parameters.md:31 msgid "" "// A function which takes a closure as an argument and calls it.\n" "// denotes that F is a \"Generic type parameter\"\n" msgstr "" #: src/fn/closures/input_parameters.md:34 msgid "// The closure takes no input and returns nothing.\n" msgstr "" #: src/fn/closures/input_parameters.md:36 msgid "// ^ TODO: Try changing this to `Fn` or `FnMut`.\n" msgstr "" #: src/fn/closures/input_parameters.md:40 msgid "// A function which takes a closure and returns an `i32`.\n" msgstr "" #: src/fn/closures/input_parameters.md:43 msgid "// The closure takes an `i32` and returns an `i32`.\n" msgstr "" #: src/fn/closures/input_parameters.md:53 msgid "" "// A non-copy type.\n" " // `to_owned` creates owned data from borrowed one\n" msgstr "" #: src/fn/closures/input_parameters.md:55 msgid "\"goodbye\"" msgstr "" #: src/fn/closures/input_parameters.md:57 msgid "" "// Capture 2 variables: `greeting` by reference and\n" " // `farewell` by value.\n" msgstr "" #: src/fn/closures/input_parameters.md:60 msgid "// `greeting` is by reference: requires `Fn`.\n" msgstr "" #: src/fn/closures/input_parameters.md:61 msgid "\"I said {}.\"" msgstr "" #: src/fn/closures/input_parameters.md:63 msgid "" "// Mutation forces `farewell` to be captured by\n" " // mutable reference. Now requires `FnMut`.\n" msgstr "" #: src/fn/closures/input_parameters.md:65 msgid "\"!!!\"" msgstr "" #: src/fn/closures/input_parameters.md:66 msgid "\"Then I screamed {}.\"" msgstr "" #: src/fn/closures/input_parameters.md:67 msgid "\"Now I can sleep. zzzzz\"" msgstr "" #: src/fn/closures/input_parameters.md:69 msgid "" "// Manually calling drop forces `farewell` to\n" " // be captured by value. Now requires `FnOnce`.\n" msgstr "" #: src/fn/closures/input_parameters.md:74 msgid "// Call the function which applies the closure.\n" msgstr "" #: src/fn/closures/input_parameters.md:77 msgid "// `double` satisfies `apply_to_3`'s trait bound\n" msgstr "" #: src/fn/closures/input_parameters.md:80 msgid "\"3 doubled: {}\"" msgstr "" #: src/fn/closures/input_parameters.md:86 msgid "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://doc." "rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md), " "[where](../../generics/where.md) and [`FnOnce`](https://doc.rust-lang.org/" "std/ops/trait.FnOnce.html)" msgstr "" #: src/fn/closures/anonymity.md:3 msgid "" "Closures succinctly capture variables from enclosing scopes. Does this have " "any consequences? It surely does. Observe how using a closure as a function " "parameter requires [generics](../../generics.md), which is necessary because " "of how they are defined:" msgstr "" #: src/fn/closures/anonymity.md:9 msgid "// `F` must be generic.\n" msgstr "" #: src/fn/closures/anonymity.md:16 msgid "" "When a closure is defined, the compiler implicitly creates a new anonymous " "structure to store the captured variables inside, meanwhile implementing the " "functionality via one of the `traits`: `Fn`, `FnMut`, or `FnOnce` for this " "unknown type. This type is assigned to the variable which is stored until " "calling." msgstr "" #: src/fn/closures/anonymity.md:22 msgid "" "Since this new type is of unknown type, any usage in a function will require " "generics. However, an unbounded type parameter `` would still be " "ambiguous and not be allowed. Thus, bounding by one of the `traits`: `Fn`, " "`FnMut`, or `FnOnce` (which it implements) is sufficient to specify its type." msgstr "" #: src/fn/closures/anonymity.md:28 msgid "" "// `F` must implement `Fn` for a closure which takes no\n" "// inputs and returns nothing - exactly what is required\n" "// for `print`.\n" msgstr "" #: src/fn/closures/anonymity.md:39 msgid "" "// Capture `x` into an anonymous type and implement\n" " // `Fn` for it. Store it in `print`.\n" msgstr "" #: src/fn/closures/anonymity.md:49 msgid "" "[A thorough analysis](https://huonw.github.io/blog/2015/05/finding-closure-" "in-rust/), [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`]" "(https://doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://" "doc.rust-lang.org/std/ops/trait.FnOnce.html)" msgstr "" #: src/fn/closures/input_functions.md:3 msgid "" "Since closures may be used as arguments, you might wonder if the same can be " "said about functions. And indeed they can! If you declare a function that " "takes a closure as parameter, then any function that satisfies the trait " "bound of that closure can be passed as a parameter." msgstr "" #: src/fn/closures/input_functions.md:9 msgid "" "// Define a function which takes a generic `F` argument\n" "// bounded by `Fn`, and calls it\n" msgstr "" #: src/fn/closures/input_functions.md:14 msgid "// Define a wrapper function satisfying the `Fn` bound\n" msgstr "" #: src/fn/closures/input_functions.md:17 msgid "\"I'm a function!\"" msgstr "" #: src/fn/closures/input_functions.md:21 msgid "// Define a closure satisfying the `Fn` bound\n" msgstr "" #: src/fn/closures/input_functions.md:22 msgid "\"I'm a closure!\"" msgstr "" #: src/fn/closures/input_functions.md:29 msgid "" "As an additional note, the `Fn`, `FnMut`, and `FnOnce` `traits` dictate how " "a closure captures variables from the enclosing scope." msgstr "" #: src/fn/closures/input_functions.md:34 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" msgstr "" #: src/fn/closures/output_parameters.md:3 msgid "" "Closures as input parameters are possible, so returning closures as output " "parameters should also be possible. However, anonymous closure types are, by " "definition, unknown, so we have to use `impl Trait` to return them." msgstr "" #: src/fn/closures/output_parameters.md:8 msgid "The valid traits for returning a closure are:" msgstr "" #: src/fn/closures/output_parameters.md:10 msgid "`Fn`" msgstr "" #: src/fn/closures/output_parameters.md:11 msgid "`FnMut`" msgstr "" #: src/fn/closures/output_parameters.md:12 msgid "`FnOnce`" msgstr "" #: src/fn/closures/output_parameters.md:14 msgid "" "Beyond this, the `move` keyword must be used, which signals that all " "captures occur by value. This is required because any captures by reference " "would be dropped as soon as the function exited, leaving invalid references " "in the closure." msgstr "" #: src/fn/closures/output_parameters.md:21 msgid "\"Fn\"" msgstr "" #: src/fn/closures/output_parameters.md:23 #: src/fn/closures/output_parameters.md:29 #: src/fn/closures/output_parameters.md:35 msgid "\"This is a: {}\"" msgstr "" #: src/fn/closures/output_parameters.md:27 msgid "\"FnMut\"" msgstr "" #: src/fn/closures/output_parameters.md:33 msgid "\"FnOnce\"" msgstr "" #: src/fn/closures/output_parameters.md:51 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md) " "and [impl Trait](../../trait/impl_trait.md)." msgstr "" #: src/fn/closures/closure_examples.md:3 msgid "" "This section contains a few examples of using closures from the `std` " "library." msgstr "" #: src/fn/closures/closure_examples/iter_any.md:3 msgid "" "`Iterator::any` is a function which when passed an iterator, will return " "`true` if any element satisfies the predicate. Otherwise `false`. Its " "signature:" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:9 #: src/fn/closures/closure_examples/iter_find.md:9 msgid "// The type being iterated over.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:12 msgid "" "// `any` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `Self::Item` states it takes\n" " // arguments to the closure by value.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:27 msgid "// `iter()` for vecs yields `&i32`. Destructure to `i32`.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:28 msgid "\"2 in vec1: {}\"" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:29 msgid "// `into_iter()` for vecs yields `i32`. No destructuring required.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:30 msgid "\"2 in vec2: {}\"" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:32 msgid "" "// `iter()` only borrows `vec1` and its elements, so they can be used again\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:33 msgid "\"vec1 len: {}\"" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:34 msgid "\"First element of vec1 is: {}\"" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:35 msgid "" "// `into_iter()` does move `vec2` and its elements, so they cannot be used " "again\n" " // println!(\"First element of vec2 is: {}\", vec2[0]);\n" " // println!(\"vec2 len: {}\", vec2.len());\n" " // TODO: uncomment two lines above and see compiler errors.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:43 msgid "// `iter()` for arrays yields `&i32`.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:44 msgid "\"2 in array1: {}\"" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:45 msgid "// `into_iter()` for arrays yields `i32`.\n" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:46 msgid "\"2 in array2: {}\"" msgstr "" #: src/fn/closures/closure_examples/iter_any.md:52 msgid "" "[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.any)" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:3 msgid "" "`Iterator::find` is a function which iterates over an iterator and searches " "for the first value which satisfies some condition. If none of the values " "satisfy the condition, it returns `None`. Its signature:" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:12 msgid "" "// `find` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `&Self::Item` states it takes\n" " // arguments to the closure by reference.\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:27 msgid "// `iter()` for vecs yields `&i32`.\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:29 msgid "// `into_iter()` for vecs yields `i32`.\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:32 msgid "" "// `iter()` for vecs yields `&i32`, and we want to reference one of its\n" " // items, so we have to destructure `&&i32` to `i32`\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:34 msgid "\"Find 2 in vec1: {:?}\"" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:35 msgid "" "// `into_iter()` for vecs yields `i32`, and we want to reference one of\n" " // its items, so we have to destructure `&i32` to `i32`\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:37 msgid "\"Find 2 in vec2: {:?}\"" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:42 msgid "// `iter()` for arrays yields `&&i32`\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:43 msgid "\"Find 2 in array1: {:?}\"" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:44 msgid "// `into_iter()` for arrays yields `&i32`\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:45 msgid "\"Find 2 in array2: {:?}\"" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:49 msgid "" "`Iterator::find` gives you a reference to the item. But if you want the " "_index_ of the item, use `Iterator::position`." msgstr "" #: src/fn/closures/closure_examples/iter_find.md:56 msgid "" "// `iter()` for vecs yields `&i32` and `position()` does not take a " "reference, so\n" " // we have to destructure `&i32` to `i32`\n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:61 msgid "" "// `into_iter()` for vecs yields `i32` and `position()` does not take a " "reference, so\n" " // we do not have to destructure \n" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:70 msgid "" "[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.find)" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:72 msgid "" "[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.find_map)" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:74 msgid "" "[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.position)" msgstr "" #: src/fn/closures/closure_examples/iter_find.md:76 msgid "" "[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.rposition)" msgstr "" #: src/fn/hof.md:3 msgid "" "Rust provides Higher Order Functions (HOF). These are functions that take " "one or more functions and/or produce a more useful function. HOFs and lazy " "iterators give Rust its functional flavor." msgstr "" #: src/fn/hof.md:13 msgid "\"Find the sum of all the numbers with odd squares under 1000\"" msgstr "" #: src/fn/hof.md:16 msgid "" "// Imperative approach\n" " // Declare accumulator variable\n" msgstr "" #: src/fn/hof.md:19 msgid "// Iterate: 0, 1, 2, ... to infinity\n" msgstr "" #: src/fn/hof.md:21 msgid "// Square the number\n" msgstr "" #: src/fn/hof.md:25 msgid "// Break loop if exceeded the upper limit\n" msgstr "" #: src/fn/hof.md:28 msgid "// Accumulate value, if it's odd\n" msgstr "" #: src/fn/hof.md:32 msgid "\"imperative style: {}\"" msgstr "" #: src/fn/hof.md:34 msgid "// Functional approach\n" msgstr "" #: src/fn/hof.md:36 msgid "// All natural numbers squared\n" msgstr "" #: src/fn/hof.md:37 msgid "// Below upper limit\n" msgstr "" #: src/fn/hof.md:38 msgid "// That are odd\n" msgstr "" #: src/fn/hof.md:39 msgid "// Sum them\n" msgstr "" #: src/fn/hof.md:40 msgid "\"functional style: {}\"" msgstr "" #: src/fn/hof.md:44 msgid "" "[Option](https://doc.rust-lang.org/core/option/enum.Option.html) and " "[Iterator](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "implement their fair share of HOFs." msgstr "" #: src/fn/diverging.md:3 msgid "" "Diverging functions never return. They are marked using `!`, which is an " "empty type." msgstr "" #: src/fn/diverging.md:7 src/fn/diverging.md:35 msgid "\"This call never returns.\"" msgstr "" #: src/fn/diverging.md:11 msgid "" "As opposed to all the other types, this one cannot be instantiated, because " "the set of all possible values this type can have is empty. Note that, it is " "different from the `()` type, which has exactly one possible value." msgstr "" #: src/fn/diverging.md:15 msgid "" "For example, this function returns as usual, although there is no " "information in the return value." msgstr "" #: src/fn/diverging.md:25 msgid "\"This function returns and you can see this line.\"" msgstr "" #: src/fn/diverging.md:29 msgid "" "As opposed to this function, which will never return the control back to the " "caller." msgstr "" #: src/fn/diverging.md:36 msgid "\"You will never see this line!\"" msgstr "" #: src/fn/diverging.md:40 msgid "" "Although this might seem like an abstract concept, it is actually very " "useful and often handy. The main advantage of this type is that it can be " "cast to any other type, making it versatile in situations where an exact " "type is required, such as in match branches. This flexibility allows us to " "write code like this:" msgstr "" #: src/fn/diverging.md:50 msgid "" "// Notice that the return type of this match expression must be u32\n" " // because of the type of the \"addition\" variable.\n" msgstr "" #: src/fn/diverging.md:53 msgid "// The \"i\" variable is of type u32, which is perfectly fine.\n" msgstr "" #: src/fn/diverging.md:55 msgid "" "// On the other hand, the \"continue\" expression does not return\n" " // u32, but it is still fine, because it never returns and " "therefore\n" " // does not violate the type requirements of the match " "expression.\n" msgstr "" #: src/fn/diverging.md:64 msgid "\"Sum of odd numbers up to 9 (excluding): {}\"" msgstr "" #: src/fn/diverging.md:68 msgid "" "It is also the return type of functions that loop forever (e.g. `loop {}`) " "like network servers or functions that terminate the process (e.g. `exit()`)." msgstr "" #: src/mod.md:3 msgid "" "Rust provides a powerful module system that can be used to hierarchically " "split code in logical units (modules), and manage visibility (public/" "private) between them." msgstr "" #: src/mod.md:7 msgid "" "A module is a collection of items: functions, structs, traits, `impl` " "blocks, and even other modules." msgstr "" #: src/mod/visibility.md:3 msgid "" "By default, the items in a module have private visibility, but this can be " "overridden with the `pub` modifier. Only the public items of a module can be " "accessed from outside the module scope." msgstr "" #: src/mod/visibility.md:8 msgid "// A module named `my_mod`\n" msgstr "" #: src/mod/visibility.md:10 msgid "// Items in modules default to private visibility.\n" msgstr "" #: src/mod/visibility.md:12 msgid "\"called `my_mod::private_function()`\"" msgstr "" #: src/mod/visibility.md:15 msgid "// Use the `pub` modifier to override default visibility.\n" msgstr "" #: src/mod/visibility.md:17 msgid "\"called `my_mod::function()`\"" msgstr "" #: src/mod/visibility.md:20 msgid "" "// Items can access other items in the same module,\n" " // even when private.\n" msgstr "" #: src/mod/visibility.md:23 msgid "\"called `my_mod::indirect_access()`, that\\n> \"" msgstr "" #: src/mod/visibility.md:27 msgid "// Modules can also be nested\n" msgstr "" #: src/mod/visibility.md:30 msgid "\"called `my_mod::nested::function()`\"" msgstr "" #: src/mod/visibility.md:35 msgid "\"called `my_mod::nested::private_function()`\"" msgstr "" #: src/mod/visibility.md:38 msgid "" "// Functions declared using `pub(in path)` syntax are only visible\n" " // within the given path. `path` must be a parent or ancestor " "module\n" msgstr "" #: src/mod/visibility.md:41 msgid "\"called `my_mod::nested::public_function_in_my_mod()`, that\\n> \"" msgstr "" #: src/mod/visibility.md:45 msgid "" "// Functions declared using `pub(self)` syntax are only visible within\n" " // the current module, which is the same as leaving them private\n" msgstr "" #: src/mod/visibility.md:48 msgid "\"called `my_mod::nested::public_function_in_nested()`\"" msgstr "" #: src/mod/visibility.md:51 msgid "" "// Functions declared using `pub(super)` syntax are only visible within\n" " // the parent module\n" msgstr "" #: src/mod/visibility.md:54 msgid "\"called `my_mod::nested::public_function_in_super_mod()`\"" msgstr "" #: src/mod/visibility.md:59 msgid "\"called `my_mod::call_public_function_in_my_mod()`, that\\n> \"" msgstr "" #: src/mod/visibility.md:61 msgid "\"> \"" msgstr "" #: src/mod/visibility.md:65 msgid "// pub(crate) makes functions visible only within the current crate\n" msgstr "" #: src/mod/visibility.md:67 msgid "\"called `my_mod::public_function_in_crate()`\"" msgstr "" #: src/mod/visibility.md:70 msgid "// Nested modules follow the same rules for visibility\n" msgstr "" #: src/mod/visibility.md:74 msgid "\"called `my_mod::private_nested::function()`\"" msgstr "" #: src/mod/visibility.md:77 msgid "" "// Private parent items will still restrict the visibility of a child item,\n" " // even if it is declared as visible within a bigger scope.\n" msgstr "" #: src/mod/visibility.md:81 msgid "\"called `my_mod::private_nested::restricted_function()`\"" msgstr "" #: src/mod/visibility.md:87 src/mod/use.md:25 src/mod/super.md:8 #: src/mod/split.md:24 msgid "\"called `function()`\"" msgstr "" #: src/mod/visibility.md:91 msgid "" "// Modules allow disambiguation between items that have the same name.\n" msgstr "" #: src/mod/visibility.md:95 msgid "" "// Public items, including those inside nested modules, can be\n" " // accessed from outside the parent module.\n" msgstr "" #: src/mod/visibility.md:101 msgid "// pub(crate) items can be called from anywhere in the same crate\n" msgstr "" #: src/mod/visibility.md:104 msgid "" "// pub(in path) items can only be called from within the module specified\n" " // Error! function `public_function_in_my_mod` is private\n" " //my_mod::nested::public_function_in_my_mod();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/visibility.md:109 msgid "" "// Private items of a module cannot be directly accessed, even if\n" " // nested in a public module:\n" msgstr "" #: src/mod/visibility.md:112 msgid "" "// Error! `private_function` is private\n" " //my_mod::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/visibility.md:116 msgid "" "// Error! `private_function` is private\n" " //my_mod::nested::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/visibility.md:120 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/visibility.md:124 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::restricted_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/struct_visibility.md:3 msgid "" "Structs have an extra level of visibility with their fields. The visibility " "defaults to private, and can be overridden with the `pub` modifier. This " "visibility only matters when a struct is accessed from outside the module " "where it is defined, and has the goal of hiding information (encapsulation)." msgstr "" #: src/mod/struct_visibility.md:10 msgid "// A public struct with a public field of generic type `T`\n" msgstr "" #: src/mod/struct_visibility.md:15 msgid "// A public struct with a private field of generic type `T`\n" msgstr "" #: src/mod/struct_visibility.md:21 msgid "// A public constructor method\n" msgstr "" #: src/mod/struct_visibility.md:31 msgid "// Public structs with public fields can be constructed as usual\n" msgstr "" #: src/mod/struct_visibility.md:32 msgid "\"public information\"" msgstr "" #: src/mod/struct_visibility.md:34 msgid "// and their fields can be normally accessed.\n" msgstr "" #: src/mod/struct_visibility.md:35 msgid "\"The open box contains: {}\"" msgstr "" #: src/mod/struct_visibility.md:37 msgid "" "// Public structs with private fields cannot be constructed using field " "names.\n" " // Error! `ClosedBox` has private fields\n" " //let closed_box = my::ClosedBox { contents: \"classified " "information\" };\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/struct_visibility.md:42 msgid "" "// However, structs with private fields can be created using\n" " // public constructors\n" msgstr "" #: src/mod/struct_visibility.md:44 msgid "\"classified information\"" msgstr "" #: src/mod/struct_visibility.md:46 msgid "" "// and the private fields of a public struct cannot be accessed.\n" " // Error! The `contents` field is private\n" " //println!(\"The closed box contains: {}\", _closed_box.contents);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/mod/struct_visibility.md:55 msgid "[generics](../generics.md) and [methods](../fn/methods.md)" msgstr "" #: src/mod/use.md:3 msgid "" "The `use` declaration can be used to bind a full path to a new name, for " "easier access. It is often used like this:" msgstr "" #: src/mod/use.md:18 msgid "You can use the `as` keyword to bind imports to a different name:" msgstr "" #: src/mod/use.md:21 msgid "// Bind the `deeply::nested::function` path to `other_function`.\n" msgstr "" #: src/mod/use.md:31 msgid "\"called `deeply::nested::function()`\"" msgstr "" #: src/mod/use.md:37 msgid "// Easier access to `deeply::nested::function`\n" msgstr "" #: src/mod/use.md:40 msgid "\"Entering block\"" msgstr "" #: src/mod/use.md:42 msgid "" "// This is equivalent to `use deeply::nested::function as function`.\n" " // This `function()` will shadow the outer one.\n" msgstr "" #: src/mod/use.md:46 msgid "" "// `use` bindings have a local scope. In this case, the\n" " // shadowing of `function()` is only in this block.\n" msgstr "" #: src/mod/use.md:50 msgid "\"Leaving block\"" msgstr "" #: src/mod/super.md:3 msgid "" "The `super` and `self` keywords can be used in the path to remove ambiguity " "when accessing items and to prevent unnecessary hardcoding of paths." msgstr "" #: src/mod/super.md:13 msgid "\"called `cool::function()`\"" msgstr "" #: src/mod/super.md:19 src/mod/split.md:49 msgid "\"called `my::function()`\"" msgstr "" #: src/mod/super.md:24 msgid "\"called `my::cool::function()`\"" msgstr "" #: src/mod/super.md:29 msgid "// Let's access all the functions named `function` from this scope!\n" msgstr "" #: src/mod/super.md:30 msgid "\"called `my::indirect_call()`, that\\n> \"" msgstr "" #: src/mod/super.md:32 msgid "" "// The `self` keyword refers to the current module scope - in this case " "`my`.\n" " // Calling `self::function()` and calling `function()` directly both " "give\n" " // the same result, because they refer to the same function.\n" msgstr "" #: src/mod/super.md:38 msgid "// We can also use `self` to access another module inside `my`:\n" msgstr "" #: src/mod/super.md:41 msgid "" "// The `super` keyword refers to the parent scope (outside the `my` " "module).\n" msgstr "" #: src/mod/super.md:44 msgid "" "// This will bind to the `cool::function` in the *crate* scope.\n" " // In this case the crate scope is the outermost scope.\n" msgstr "" #: src/mod/split.md:3 msgid "" "Modules can be mapped to a file/directory hierarchy. Let's break down the " "[visibility example](visibility.md) in files:" msgstr "" #: src/mod/split.md:16 msgid "In `split.rs`:" msgstr "" #: src/mod/split.md:19 msgid "" "// This declaration will look for a file named `my.rs` and will\n" "// insert its contents inside a module named `my` under this scope\n" msgstr "" #: src/mod/split.md:39 msgid "In `my.rs`:" msgstr "" #: src/mod/split.md:42 msgid "" "// Similarly `mod inaccessible` and `mod nested` will locate the `nested." "rs`\n" "// and `inaccessible.rs` files and insert them here under their respective\n" "// modules\n" msgstr "" #: src/mod/split.md:53 msgid "\"called `my::private_function()`\"" msgstr "" #: src/mod/split.md:57 msgid "\"called `my::indirect_access()`, that\\n> \"" msgstr "" #: src/mod/split.md:63 msgid "In `my/nested.rs`:" msgstr "" #: src/mod/split.md:67 msgid "\"called `my::nested::function()`\"" msgstr "" #: src/mod/split.md:72 msgid "\"called `my::nested::private_function()`\"" msgstr "" #: src/mod/split.md:76 msgid "In `my/inaccessible.rs`:" msgstr "" #: src/mod/split.md:81 msgid "\"called `my::inaccessible::public_function()`\"" msgstr "" #: src/mod/split.md:85 msgid "Let's check that things still work as before:" msgstr "" #: src/crates.md:3 msgid "" "A crate is a compilation unit in Rust. Whenever `rustc some_file.rs` is " "called, `some_file.rs` is treated as the _crate file_. If `some_file.rs` has " "`mod` declarations in it, then the contents of the module files would be " "inserted in places where `mod` declarations in the crate file are found, " "_before_ running the compiler over it. In other words, modules do _not_ get " "compiled individually, only crates get compiled." msgstr "" #: src/crates.md:10 msgid "" "A crate can be compiled into a binary or into a library. By default, `rustc` " "will produce a binary from a crate. This behavior can be overridden by " "passing the `--crate-type` flag to `lib`." msgstr "" #: src/crates/lib.md:3 msgid "Let's create a library, and then see how to link it to another crate." msgstr "" #: src/crates/lib.md:5 msgid "In `rary.rs`:" msgstr "" #: src/crates/lib.md:9 src/attribute/crate.md:19 msgid "\"called rary's `public_function()`\"" msgstr "" #: src/crates/lib.md:13 src/attribute/crate.md:23 msgid "\"called rary's `private_function()`\"" msgstr "" #: src/crates/lib.md:17 src/attribute/crate.md:27 msgid "\"called rary's `indirect_access()`, that\\n> \"" msgstr "" #: src/crates/lib.md:29 msgid "" "Libraries get prefixed with \"lib\", and by default they get named after " "their crate file, but this default name can be overridden by passing the `--" "crate-name` option to `rustc` or by using the [`crate_name` attribute](../" "attribute/crate.md)." msgstr "" #: src/crates/using_lib.md:3 msgid "" "To link a crate to this new library you may use `rustc`'s `--extern` flag. " "All of its items will then be imported under a module named the same as the " "library. This module generally behaves the same way as any other module." msgstr "" #: src/crates/using_lib.md:8 msgid "" "// extern crate rary; // May be required for Rust 2015 edition or earlier\n" msgstr "" #: src/crates/using_lib.md:13 msgid "" "// Error! `private_function` is private\n" " //rary::private_function();\n" msgstr "" #: src/cargo.md:3 msgid "" "`cargo` is the official Rust package management tool. It has lots of really " "useful features to improve code quality and developer velocity! These include" msgstr "" #: src/cargo.md:6 msgid "" "Dependency management and integration with [crates.io](https://crates.io) " "(the official Rust package registry)" msgstr "" #: src/cargo.md:8 msgid "Awareness of unit tests" msgstr "" #: src/cargo.md:9 msgid "Awareness of benchmarks" msgstr "" #: src/cargo.md:11 msgid "" "This chapter will go through some quick basics, but you can find the " "comprehensive docs in [The Cargo Book](https://doc.rust-lang.org/cargo/)." msgstr "" #: src/cargo/deps.md:3 msgid "" "Most programs have dependencies on some libraries. If you have ever managed " "dependencies by hand, you know how much of a pain this can be. Luckily, the " "Rust ecosystem comes standard with `cargo`! `cargo` can manage dependencies " "for a project." msgstr "" #: src/cargo/deps.md:8 msgid "To create a new Rust project," msgstr "" #: src/cargo/deps.md:11 msgid "# A binary\n" msgstr "" #: src/cargo/deps.md:13 msgid "# A library\n" msgstr "" #: src/cargo/deps.md:18 msgid "" "For the rest of this chapter, let's assume we are making a binary, rather " "than a library, but all of the concepts are the same." msgstr "" #: src/cargo/deps.md:21 msgid "After the above commands, you should see a file hierarchy like this:" msgstr "" #: src/cargo/deps.md:35 msgid "" "The `main.rs` is the root source file for your new `foo` project -- nothing " "new there. The `Cargo.toml` is the config file for `cargo` for this project. " "If you look inside it, you should see something like this:" msgstr "" #: src/cargo/deps.md:39 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "```" msgstr "" #: src/cargo/deps.md:48 msgid "" "The `name` field under `[package]` determines the name of the project. This " "is used by `crates.io` if you publish the crate (more later). It is also the " "name of the output binary when you compile." msgstr "" #: src/cargo/deps.md:52 msgid "" "The `version` field is a crate version number using [Semantic Versioning]" "(http://semver.org/)." msgstr "" #: src/cargo/deps.md:55 msgid "" "The `authors` field is a list of authors used when publishing the crate." msgstr "" #: src/cargo/deps.md:57 msgid "" "The `[dependencies]` section lets you add dependencies for your project." msgstr "" #: src/cargo/deps.md:59 msgid "" "For example, suppose that we want our program to have a great CLI. You can " "find lots of great packages on [crates.io](https://crates.io) (the official " "Rust package registry). One popular choice is [clap](https://crates.io/" "crates/clap). As of this writing, the most recent published version of " "`clap` is `2.27.1`. To add a dependency to our program, we can simply add " "the following to our `Cargo.toml` under `[dependencies]`: `clap = " "\"2.27.1\"`. And that's it! You can start using `clap` in your program." msgstr "" #: src/cargo/deps.md:67 msgid "" "`cargo` also supports [other types of dependencies](https://doc.rust-lang." "org/cargo/reference/specifying-dependencies.html). Here is just a small " "sampling:" msgstr "" #: src/cargo/deps.md:70 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "clap = \"2.27.1\" # from crates.io\n" "rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # from online " "repo\n" "bar = { path = \"../bar\" } # from a path in the local filesystem\n" "```" msgstr "" #: src/cargo/deps.md:82 msgid "" "`cargo` is more than a dependency manager. All of the available " "configuration options are listed in the [format specification](https://doc." "rust-lang.org/cargo/reference/manifest.html) of `Cargo.toml`." msgstr "" #: src/cargo/deps.md:86 msgid "" "To build our project we can execute `cargo build` anywhere in the project " "directory (including subdirectories!). We can also do `cargo run` to build " "and run. Notice that these commands will resolve all dependencies, download " "crates if needed, and build everything, including your crate. (Note that it " "only rebuilds what it has not already built, similar to `make`)." msgstr "" #: src/cargo/deps.md:92 msgid "Voila! That's all there is to it!" msgstr "" #: src/cargo/conventions.md:3 msgid "In the previous chapter, we saw the following directory hierarchy:" msgstr "" #: src/cargo/conventions.md:12 msgid "" "Suppose that we wanted to have two binaries in the same project, though. " "What then?" msgstr "" #: src/cargo/conventions.md:15 msgid "" "It turns out that `cargo` supports this. The default binary name is `main`, " "as we saw before, but you can add additional binaries by placing them in a " "`bin/` directory:" msgstr "" #: src/cargo/conventions.md:28 msgid "" "To tell `cargo` to only compile or run this binary, we just pass `cargo` the " "`--bin my_other_bin` flag, where `my_other_bin` is the name of the binary we " "want to work with." msgstr "" #: src/cargo/conventions.md:32 msgid "" "In addition to extra binaries, `cargo` supports [more features](https://doc." "rust-lang.org/cargo/guide/project-layout.html) such as benchmarks, tests, " "and examples." msgstr "" #: src/cargo/conventions.md:35 msgid "In the next chapter, we will look more closely at tests." msgstr "" #: src/cargo/test.md:3 msgid "" "As we know testing is integral to any piece of software! Rust has first-" "class support for unit and integration testing ([see this chapter](https://" "doc.rust-lang.org/book/ch11-00-testing.html) in TRPL)." msgstr "" #: src/cargo/test.md:7 msgid "" "From the testing chapters linked above, we see how to write unit tests and " "integration tests. Organizationally, we can place unit tests in the modules " "they test and integration tests in their own `tests/` directory:" msgstr "" #: src/cargo/test.md:22 msgid "" "Each file in `tests` is a separate [integration test](https://doc.rust-lang." "org/book/ch11-03-test-organization.html#integration-tests), i.e. a test that " "is meant to test your library as if it were being called from a dependent " "crate." msgstr "" #: src/cargo/test.md:27 msgid "" "The [Testing](../testing.md) chapter elaborates on the three different " "testing styles: [Unit](../testing/unit_testing.md), [Doc](../testing/" "doc_testing.md), and [Integration](../testing/integration_testing.md)." msgstr "" #: src/cargo/test.md:30 msgid "`cargo` naturally provides an easy way to run all of your tests!" msgstr "" #: src/cargo/test.md:36 msgid "You should see output like this:" msgstr "" #: src/cargo/test.md:38 msgid "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" msgstr "" #: src/cargo/test.md:53 msgid "You can also run tests whose name matches a pattern:" msgstr "" #: src/cargo/test.md:59 msgid "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" msgstr "" #: src/cargo/test.md:72 msgid "" "One word of caution: Cargo may run multiple tests concurrently, so make sure " "that they don't race with each other." msgstr "" #: src/cargo/test.md:75 msgid "" "One example of this concurrency causing issues is if two tests output to a " "file, such as below:" msgstr "" #: src/cargo/test.md:81 msgid "// Import the necessary modules\n" msgstr "" #: src/cargo/test.md:85 msgid "// This test writes to a file\n" msgstr "" #: src/cargo/test.md:88 src/cargo/test.md:105 msgid "// Opens the file ferris.txt or creates one if it doesn't exist.\n" msgstr "" #: src/cargo/test.md:92 src/cargo/test.md:109 msgid "\"ferris.txt\"" msgstr "" #: src/cargo/test.md:93 src/cargo/test.md:110 msgid "\"Failed to open ferris.txt\"" msgstr "" #: src/cargo/test.md:95 msgid "// Print \"Ferris\" 5 times.\n" msgstr "" #: src/cargo/test.md:97 msgid "\"Ferris\\n\"" msgstr "" #: src/cargo/test.md:98 src/cargo/test.md:115 msgid "\"Could not write to ferris.txt\"" msgstr "" #: src/cargo/test.md:102 msgid "// This test tries to write to the same file\n" msgstr "" #: src/cargo/test.md:112 msgid "// Print \"Corro\" 5 times.\n" msgstr "" #: src/cargo/test.md:114 msgid "\"Corro\\n\"" msgstr "" #: src/cargo/test.md:121 msgid "Although the intent is to get the following:" msgstr "" #: src/cargo/test.md:137 msgid "What actually gets put into `ferris.txt` is this:" msgstr "" #: src/cargo/build_scripts.md:3 msgid "" "Sometimes a normal build from `cargo` is not enough. Perhaps your crate " "needs some pre-requisites before `cargo` will successfully compile, things " "like code generation, or some native code that needs to be compiled. To " "solve this problem we have build scripts that Cargo can run." msgstr "" #: src/cargo/build_scripts.md:8 msgid "" "To add a build script to your package it can either be specified in the " "`Cargo.toml` as follows:" msgstr "" #: src/cargo/build_scripts.md:11 msgid "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" msgstr "" #: src/cargo/build_scripts.md:17 msgid "" "Otherwise Cargo will look for a `build.rs` file in the project directory by " "default." msgstr "" #: src/cargo/build_scripts.md:20 msgid "How to use a build script" msgstr "" #: src/cargo/build_scripts.md:22 msgid "" "The build script is simply another Rust file that will be compiled and " "invoked prior to compiling anything else in the package. Hence it can be " "used to fulfill pre-requisites of your crate." msgstr "" #: src/cargo/build_scripts.md:26 msgid "" "Cargo provides the script with inputs via environment variables [specified " "here](https://doc.rust-lang.org/cargo/reference/environment-variables." "html#environment-variables-cargo-sets-for-build-scripts) that can be used." msgstr "" #: src/cargo/build_scripts.md:29 msgid "" "The script provides output via stdout. All lines printed are written to " "`target/debug/build//output`. Further, lines prefixed with `cargo:` " "will be interpreted by Cargo directly and hence can be used to define " "parameters for the package's compilation." msgstr "" #: src/cargo/build_scripts.md:34 msgid "" "For further specification and examples have a read of the [Cargo " "specification](https://doc.rust-lang.org/cargo/reference/build-scripts.html)." msgstr "" #: src/attribute.md:3 msgid "" "An attribute is metadata applied to some module, crate or item. This " "metadata can be used to/for:" msgstr "" #: src/attribute.md:8 msgid "[conditional compilation of code](attribute/cfg.md)" msgstr "" #: src/attribute.md:9 msgid "" "[set crate name, version and type (binary or library)](attribute/crate.md)" msgstr "" #: src/attribute.md:10 msgid "" "disable [lints](https://en.wikipedia.org/wiki/Lint_%28software%29) (warnings)" msgstr "" #: src/attribute.md:11 msgid "enable compiler features (macros, glob imports, etc.)" msgstr "" #: src/attribute.md:12 msgid "link to a foreign library" msgstr "" #: src/attribute.md:13 msgid "mark functions as unit tests" msgstr "" #: src/attribute.md:14 msgid "mark functions that will be part of a benchmark" msgstr "" #: src/attribute.md:15 msgid "" "[attribute like macros](https://doc.rust-lang.org/book/ch19-06-macros." "html#attribute-like-macros)" msgstr "" #: src/attribute.md:17 msgid "" "Attributes look like `#[outer_attribute]` or `#![inner_attribute]`, with the " "difference between them being where they apply." msgstr "" #: src/attribute.md:20 msgid "" "`#[outer_attribute]` applies to the [item](https://doc.rust-lang.org/stable/" "reference/items.html) immediately following it. Some examples of items are: " "a function, a module declaration, a constant, a structure, an enum. Here is " "an example where attribute `#[derive(Debug)]` applies to the struct " "`Rectangle`:" msgstr "" #: src/attribute.md:34 msgid "" "`#![inner_attribute]` applies to the enclosing [item](https://doc.rust-lang." "org/stable/reference/items.html) (typically a module or a crate). In other " "words, this attribute is interpreted as applying to the entire scope in " "which it's placed. Here is an example where `#![allow(unused_variables)]` " "applies to the whole crate (if placed in `main.rs`):" msgstr "" #: src/attribute.md:44 msgid "// This would normally warn about an unused variable.\n" msgstr "" #: src/attribute.md:48 msgid "Attributes can take arguments with different syntaxes:" msgstr "" #: src/attribute.md:50 msgid "`#[attribute = \"value\"]`" msgstr "" #: src/attribute.md:51 msgid "`#[attribute(key = \"value\")]`" msgstr "" #: src/attribute.md:52 msgid "`#[attribute(value)]`" msgstr "" #: src/attribute.md:54 msgid "" "Attributes can have multiple values and can be separated over multiple " "lines, too:" msgstr "" #: src/attribute/unused.md:3 msgid "" "The compiler provides a `dead_code` [_lint_](https://en.wikipedia.org/wiki/" "Lint_%28software%29) that will warn about unused functions. An _attribute_ " "can be used to disable the lint." msgstr "" #: src/attribute/unused.md:9 msgid "" "// `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint\n" msgstr "" #: src/attribute/unused.md:14 msgid "// FIXME ^ Add an attribute to suppress the warning\n" msgstr "" #: src/attribute/unused.md:22 msgid "" "Note that in real programs, you should eliminate dead code. In these " "examples we'll allow dead code in some places because of the interactive " "nature of the examples." msgstr "" #: src/attribute/crate.md:3 msgid "" "The `crate_type` attribute can be used to tell the compiler whether a crate " "is a binary or a library (and even which type of library), and the " "`crate_name` attribute can be used to set the name of the crate." msgstr "" #: src/attribute/crate.md:7 msgid "" "However, it is important to note that both the `crate_type` and `crate_name` " "attributes have **no** effect whatsoever when using Cargo, the Rust package " "manager. Since Cargo is used for the majority of Rust projects, this means " "real-world uses of `crate_type` and `crate_name` are relatively limited." msgstr "" #: src/attribute/crate.md:13 msgid "// This crate is a library\n" msgstr "" #: src/attribute/crate.md:14 msgid "\"lib\"" msgstr "" #: src/attribute/crate.md:14 msgid "// The library is named \"rary\"\n" msgstr "" #: src/attribute/crate.md:16 msgid "\"rary\"" msgstr "" #: src/attribute/crate.md:33 msgid "" "When the `crate_type` attribute is used, we no longer need to pass the `--" "crate-type` flag to `rustc`." msgstr "" #: src/attribute/cfg.md:3 msgid "" "Configuration conditional checks are possible through two different " "operators:" msgstr "" #: src/attribute/cfg.md:5 msgid "the `cfg` attribute: `#[cfg(...)]` in attribute position" msgstr "" #: src/attribute/cfg.md:6 msgid "the `cfg!` macro: `cfg!(...)` in boolean expressions" msgstr "" #: src/attribute/cfg.md:8 msgid "" "While the former enables conditional compilation, the latter conditionally " "evaluates to `true` or `false` literals allowing for checks at run-time. " "Both utilize identical argument syntax." msgstr "" #: src/attribute/cfg.md:12 msgid "" "`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true " "or false. For example, all blocks in an if/else expression need to be valid " "when `cfg!` is used for the condition, regardless of what `cfg!` is " "evaluating." msgstr "" #: src/attribute/cfg.md:15 msgid "// This function only gets compiled if the target OS is linux\n" msgstr "" #: src/attribute/cfg.md:16 src/attribute/cfg.md:22 src/attribute/cfg.md:31 msgid "\"linux\"" msgstr "" #: src/attribute/cfg.md:18 msgid "\"You are running linux!\"" msgstr "" #: src/attribute/cfg.md:20 msgid "" "// And this function only gets compiled if the target OS is *not* linux\n" msgstr "" #: src/attribute/cfg.md:24 msgid "\"You are *not* running linux!\"" msgstr "" #: src/attribute/cfg.md:30 msgid "\"Are you sure?\"" msgstr "" #: src/attribute/cfg.md:32 msgid "\"Yes. It's definitely linux!\"" msgstr "" #: src/attribute/cfg.md:34 msgid "\"Yes. It's definitely *not* linux!\"" msgstr "" #: src/attribute/cfg.md:41 msgid "" "[the reference](https://doc.rust-lang.org/reference/attributes." "html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/std/macro." "cfg!.html), and [macros](../macros.md)." msgstr "" #: src/attribute/cfg/custom.md:3 msgid "" "Some conditionals like `target_os` are implicitly provided by `rustc`, but " "custom conditionals must be passed to `rustc` using the `--cfg` flag." msgstr "" #: src/attribute/cfg/custom.md:9 msgid "\"condition met!\"" msgstr "" #: src/attribute/cfg/custom.md:17 msgid "Try to run this to see what happens without the custom `cfg` flag." msgstr "" #: src/attribute/cfg/custom.md:19 msgid "With the custom `cfg` flag:" msgstr "" #: src/generics.md:3 msgid "" "_Generics_ is the topic of generalizing types and functionalities to broader " "cases. This is extremely useful for reducing code duplication in many ways, " "but can call for rather involved syntax. Namely, being generic requires " "taking great care to specify over which types a generic type is actually " "considered valid. The simplest and most common use of generics is for type " "parameters." msgstr "" #: src/generics.md:10 msgid "" "A type parameter is specified as generic by the use of angle brackets and " "upper [camel case](https://en.wikipedia.org/wiki/CamelCase): ``. \"Generic type parameters\" are typically represented as ``. In Rust, " "\"generic\" also describes anything that accepts one or more generic type " "parameters ``. Any type specified as a generic type parameter is generic, " "and everything else is concrete (non-generic)." msgstr "" #: src/generics.md:16 msgid "" "For example, defining a _generic function_ named `foo` that takes an " "argument `T` of any type:" msgstr "" #: src/generics.md:23 msgid "" "Because `T` has been specified as a generic type parameter using ``, it " "is considered generic when used here as `(arg: T)`. This is the case even if " "`T` has previously been defined as a `struct`." msgstr "" #: src/generics.md:27 msgid "This example shows some of the syntax in action:" msgstr "" #: src/generics.md:30 msgid "// A concrete type `A`.\n" msgstr "" #: src/generics.md:32 msgid "" "// In defining the type `Single`, the first use of `A` is not preceded by " "``.\n" "// Therefore, `Single` is a concrete type, and `A` is defined as above.\n" msgstr "" #: src/generics.md:35 msgid "// ^ Here is `Single`s first use of the type `A`.\n" msgstr "" #: src/generics.md:37 msgid "" "// Here, `` precedes the first use of `T`, so `SingleGen` is a generic " "type.\n" "// Because the type parameter `T` is generic, it could be anything, " "including\n" "// the concrete type `A` defined at the top.\n" msgstr "" #: src/generics.md:44 msgid "// `Single` is concrete and explicitly takes `A`.\n" msgstr "" #: src/generics.md:47 msgid "" "// Create a variable `_char` of type `SingleGen`\n" " // and give it the value `SingleGen('a')`.\n" " // Here, `SingleGen` has a type parameter explicitly specified.\n" msgstr "" #: src/generics.md:52 msgid "// `SingleGen` can also have a type parameter implicitly specified:\n" msgstr "" #: src/generics.md:53 msgid "// Uses `A` defined at the top.\n" msgstr "" #: src/generics.md:54 msgid "// Uses `i32`.\n" msgstr "" #: src/generics.md:55 msgid "// Uses `char`.\n" msgstr "" #: src/generics.md:61 msgid "[`structs`](custom_types/structs.md)" msgstr "" #: src/generics/gen_fn.md:3 msgid "" "The same set of rules can be applied to functions: a type `T` becomes " "generic when preceded by ``." msgstr "" #: src/generics/gen_fn.md:6 msgid "" "Using generic functions sometimes requires explicitly specifying type " "parameters. This may be the case if the function is called where the return " "type is generic, or if the compiler doesn't have enough information to infer " "the necessary type parameters." msgstr "" #: src/generics/gen_fn.md:11 msgid "" "A function call with explicitly specified type parameters looks like: `fun::" "()`." msgstr "" #: src/generics/gen_fn.md:15 msgid "// Concrete type `A`.\n" msgstr "" #: src/generics/gen_fn.md:16 msgid "// Concrete type `S`.\n" msgstr "" #: src/generics/gen_fn.md:17 msgid "// Generic type `SGen`.\n" msgstr "" #: src/generics/gen_fn.md:18 msgid "" "// The following functions all take ownership of the variable passed into\n" "// them and immediately go out of scope, freeing the variable.\n" msgstr "" #: src/generics/gen_fn.md:21 msgid "" "// Define a function `reg_fn` that takes an argument `_s` of type `S`.\n" "// This has no `` so this is not a generic function.\n" msgstr "" #: src/generics/gen_fn.md:25 msgid "" "// Define a function `gen_spec_t` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `A`, but because `A` has " "not \n" "// been specified as a generic type parameter for `gen_spec_t`, it is not " "generic.\n" msgstr "" #: src/generics/gen_fn.md:30 msgid "" "// Define a function `gen_spec_i32` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `i32`, which is a " "specific type.\n" "// Because `i32` is not a generic type, this function is also not generic.\n" msgstr "" #: src/generics/gen_fn.md:35 msgid "" "// Define a function `generic` that takes an argument `_s` of type " "`SGen`.\n" "// Because `SGen` is preceded by ``, this function is generic over " "`T`.\n" msgstr "" #: src/generics/gen_fn.md:41 msgid "// Using the non-generic functions\n" msgstr "" #: src/generics/gen_fn.md:42 msgid "// Concrete type.\n" msgstr "" #: src/generics/gen_fn.md:43 msgid "// Implicitly specified type parameter `A`.\n" msgstr "" #: src/generics/gen_fn.md:44 msgid "// Implicitly specified type parameter `i32`.\n" msgstr "" #: src/generics/gen_fn.md:46 msgid "// Explicitly specified type parameter `char` to `generic()`.\n" msgstr "" #: src/generics/gen_fn.md:49 msgid "// Implicitly specified type parameter `char` to `generic()`.\n" msgstr "" #: src/generics/gen_fn.md:50 msgid "'c'" msgstr "" #: src/generics/gen_fn.md:56 msgid "[functions](../fn.md) and [`struct`s](../custom_types/structs.md)" msgstr "" #: src/generics/impl.md:3 msgid "Similar to functions, implementations require care to remain generic." msgstr "" #: src/generics/impl.md:6 msgid "// Concrete type `S`\n" msgstr "" #: src/generics/impl.md:7 msgid "// Generic type `GenericVal`\n" msgstr "" #: src/generics/impl.md:8 msgid "// impl of GenericVal where we explicitly specify type parameters:\n" msgstr "" #: src/generics/impl.md:10 msgid "// Specify `f32`\n" msgstr "" #: src/generics/impl.md:11 msgid "// Specify `S` as defined above\n" msgstr "" #: src/generics/impl.md:12 msgid "// `` Must precede the type to remain generic\n" msgstr "" #: src/generics/impl.md:25 msgid "// impl of Val\n" msgstr "" #: src/generics/impl.md:32 msgid "// impl of GenVal for a generic type `T`\n" msgstr "" #: src/generics/impl.md:50 msgid "" "[functions returning references](../scope/lifetime/fn.md), [`impl`](../fn/" "methods.md), and [`struct`](../custom_types/structs.md)" msgstr "" #: src/generics/gen_trait.md:3 msgid "" "Of course `trait`s can also be generic. Here we define one which " "reimplements the `Drop` `trait` as a generic method to `drop` itself and an " "input." msgstr "" #: src/generics/gen_trait.md:7 msgid "// Non-copyable types.\n" msgstr "" #: src/generics/gen_trait.md:10 msgid "// A trait generic over `T`.\n" msgstr "" #: src/generics/gen_trait.md:13 msgid "" "// Define a method on the caller type which takes an\n" " // additional single parameter `T` and does nothing with it.\n" msgstr "" #: src/generics/gen_trait.md:17 msgid "" "// Implement `DoubleDrop` for any generic parameter `T` and\n" "// caller `U`.\n" msgstr "" #: src/generics/gen_trait.md:21 msgid "" "// This method takes ownership of both passed arguments,\n" " // deallocating both.\n" msgstr "" #: src/generics/gen_trait.md:30 msgid "// Deallocate `empty` and `null`.\n" msgstr "" #: src/generics/gen_trait.md:33 msgid "" "//empty;\n" " //null;\n" " // ^ TODO: Try uncommenting these lines.\n" msgstr "" #: src/generics/gen_trait.md:41 msgid "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`struct`](../" "custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" #: src/generics/bounds.md:3 msgid "" "When working with generics, the type parameters often must use traits as " "_bounds_ to stipulate what functionality a type implements. For example, the " "following example uses the trait `Display` to print and so it requires `T` " "to be bound by `Display`; that is, `T` _must_ implement `Display`." msgstr "" #: src/generics/bounds.md:9 msgid "" "// Define a function `printer` that takes a generic type `T` which\n" "// must implement trait `Display`.\n" msgstr "" #: src/generics/bounds.md:16 msgid "" "Bounding restricts the generic to types that conform to the bounds. That is:" msgstr "" #: src/generics/bounds.md:20 msgid "" "// Error! `Vec` does not implement `Display`. This\n" "// specialization will fail.\n" msgstr "" #: src/generics/bounds.md:26 msgid "" "Another effect of bounding is that generic instances are allowed to access " "the [methods](../fn/methods.md) of traits specified in the bounds. For " "example:" msgstr "" #: src/generics/bounds.md:30 msgid "// A trait which implements the print marker: `{:?}`.\n" msgstr "" #: src/generics/bounds.md:45 msgid "" "// The generic `T` must implement `Debug`. Regardless\n" "// of the type, this will work properly.\n" msgstr "" #: src/generics/bounds.md:51 msgid "" "// `T` must implement `HasArea`. Any type which meets\n" "// the bound can access `HasArea`'s function `area`.\n" msgstr "" #: src/generics/bounds.md:61 msgid "\"Area: {}\"" msgstr "" #: src/generics/bounds.md:63 msgid "" "//print_debug(&_triangle);\n" " //println!(\"Area: {}\", area(&_triangle));\n" " // ^ TODO: Try uncommenting these.\n" " // | Error: Does not implement either `Debug` or `HasArea`. \n" msgstr "" #: src/generics/bounds.md:70 msgid "" "As an additional note, [`where`](../generics/where.md) clauses can also be " "used to apply bounds in some cases to be more expressive." msgstr "" #: src/generics/bounds.md:75 msgid "" "[`std::fmt`](../hello/print.md), [`struct`s](../custom_types/structs.md), " "and [`trait`s](../trait.md)" msgstr "" #: src/generics/bounds/testcase_empty.md:3 msgid "" "A consequence of how bounds work is that even if a `trait` doesn't include " "any functionality, you can still use it as a bound. `Eq` and `Copy` are " "examples of such `trait`s from the `std` library." msgstr "" #: src/generics/bounds/testcase_empty.md:17 msgid "" "// These functions are only valid for types which implement these\n" "// traits. The fact that the traits are empty is irrelevant.\n" msgstr "" #: src/generics/bounds/testcase_empty.md:20 msgid "\"red\"" msgstr "" #: src/generics/bounds/testcase_empty.md:21 msgid "\"blue\"" msgstr "" #: src/generics/bounds/testcase_empty.md:28 msgid "" "// `red()` won't work on a blue jay nor vice versa\n" " // because of the bounds.\n" msgstr "" #: src/generics/bounds/testcase_empty.md:30 msgid "\"A cardinal is {}\"" msgstr "" #: src/generics/bounds/testcase_empty.md:31 msgid "\"A blue jay is {}\"" msgstr "" #: src/generics/bounds/testcase_empty.md:32 msgid "" "//println!(\"A turkey is {}\", red(&_turkey));\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" #: src/generics/bounds/testcase_empty.md:39 msgid "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), [`std::" "marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), and " "[`trait`s](../../trait.md)" msgstr "" #: src/generics/multi_bounds.md:3 msgid "" "Multiple bounds for a single type can be applied with a `+`. Like normal, " "different types are separated with `,`." msgstr "" #: src/generics/multi_bounds.md:10 msgid "\"Debug: `{:?}`\"" msgstr "" #: src/generics/multi_bounds.md:11 msgid "\"Display: `{}`\"" msgstr "" #: src/generics/multi_bounds.md:15 msgid "\"t: `{:?}`\"" msgstr "" #: src/generics/multi_bounds.md:16 msgid "\"u: `{:?}`\"" msgstr "" #: src/generics/multi_bounds.md:20 msgid "\"words\"" msgstr "" #: src/generics/multi_bounds.md:25 msgid "" "//compare_prints(&array);\n" " // TODO ^ Try uncommenting this.\n" msgstr "" #: src/generics/multi_bounds.md:34 msgid "[`std::fmt`](../hello/print.md) and [`trait`s](../trait.md)" msgstr "" #: src/generics/where.md:3 msgid "" "A bound can also be expressed using a `where` clause immediately before the " "opening `{`, rather than at the type's first mention. Additionally, `where` " "clauses can apply bounds to arbitrary types, rather than just to type " "parameters." msgstr "" #: src/generics/where.md:8 msgid "Some cases that a `where` clause is useful:" msgstr "" #: src/generics/where.md:10 msgid "When specifying generic types and bounds separately is clearer:" msgstr "" #: src/generics/where.md:14 msgid "// Expressing bounds with a `where` clause\n" msgstr "" #: src/generics/where.md:21 msgid "" "When using a `where` clause is more expressive than using normal syntax. The " "`impl` in this example cannot be directly expressed without a `where` clause:" msgstr "" #: src/generics/where.md:30 msgid "" "// Because we would otherwise have to express this as `T: Debug` or \n" "// use another method of indirect approach, this requires a `where` clause:\n" msgstr "" #: src/generics/where.md:35 msgid "" "// We want `Option: Debug` as our bound because that is what's\n" " // being printed. Doing otherwise would be using the wrong bound.\n" msgstr "" #: src/generics/where.md:51 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), " "[`struct`](../custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" #: src/generics/new_types.md:3 msgid "" "The `newtype` idiom gives compile time guarantees that the right type of " "value is supplied to a program." msgstr "" #: src/generics/new_types.md:6 msgid "" "For example, an age verification function that checks age in years, _must_ " "be given a value of type `Years`." msgstr "" #: src/generics/new_types.md:21 msgid "/// truncates partial years\n" msgstr "" #: src/generics/new_types.md:34 src/generics/new_types.md:35 msgid "\"Is an adult? {}\"" msgstr "" #: src/generics/new_types.md:36 msgid "// println!(\"Is an adult? {}\", is_adult(&age_days));\n" msgstr "" #: src/generics/new_types.md:40 msgid "" "Uncomment the last print statement to observe that the type supplied must be " "`Years`." msgstr "" #: src/generics/new_types.md:42 msgid "" "To obtain the `newtype`'s value as the base type, you may use the tuple or " "destructuring syntax like so:" msgstr "" #: src/generics/new_types.md:49 msgid "// Tuple\n" msgstr "" #: src/generics/new_types.md:50 msgid "// Destructuring\n" msgstr "" #: src/generics/new_types.md:56 msgid "[`structs`](../custom_types/structs.md)" msgstr "" #: src/generics/assoc_items.md:3 msgid "" "\"Associated Items\" refers to a set of rules pertaining to [`item`](https://" "doc.rust-lang.org/reference/items.html)s of various types. It is an " "extension to `trait` generics, and allows `trait`s to internally define new " "items." msgstr "" #: src/generics/assoc_items.md:7 msgid "" "One such item is called an _associated type_, providing simpler usage " "patterns when the `trait` is generic over its container type." msgstr "" #: src/generics/assoc_items.md:12 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" msgstr "" #: src/generics/assoc_items/the_problem.md:3 msgid "" "A `trait` that is generic over its container type has type specification " "requirements - users of the `trait` _must_ specify all of its generic types." msgstr "" #: src/generics/assoc_items/the_problem.md:6 msgid "" "In the example below, the `Contains` `trait` allows the use of the generic " "types `A` and `B`. The trait is then implemented for the `Container` type, " "specifying `i32` for `A` and `B` so that it can be used with `fn " "difference()`." msgstr "" #: src/generics/assoc_items/the_problem.md:10 msgid "" "Because `Contains` is generic, we are forced to explicitly state _all_ of " "the generic types for `fn difference()`. In practice, we want a way to " "express that `A` and `B` are determined by the _input_ `C`. As you will see " "in the next section, associated types provide exactly that capability." msgstr "" #: src/generics/assoc_items/the_problem.md:17 #: src/generics/assoc_items/types.md:36 msgid "" "// A trait which checks if 2 items are stored inside of container.\n" "// Also retrieves first or last value.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:21 msgid "// Explicitly requires `A` and `B`.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:22 #: src/generics/assoc_items/the_problem.md:23 msgid "// Doesn't explicitly require `A` or `B`.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:27 msgid "// True if the numbers stored are equal.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:32 #: src/generics/assoc_items/types.md:60 msgid "// Grab the first number.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:35 #: src/generics/assoc_items/types.md:63 msgid "// Grab the last number.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:38 msgid "" "// `C` contains `A` and `B`. In light of that, having to express `A` and\n" "// `B` again is a nuisance.\n" msgstr "" #: src/generics/assoc_items/the_problem.md:52 #: src/generics/assoc_items/types.md:77 msgid "\"Does container contain {} and {}: {}\"" msgstr "" #: src/generics/assoc_items/the_problem.md:55 #: src/generics/assoc_items/types.md:80 msgid "\"First number: {}\"" msgstr "" #: src/generics/assoc_items/the_problem.md:56 #: src/generics/assoc_items/types.md:81 msgid "\"Last number: {}\"" msgstr "" #: src/generics/assoc_items/the_problem.md:58 #: src/generics/assoc_items/types.md:83 msgid "\"The difference is: {}\"" msgstr "" #: src/generics/assoc_items/the_problem.md:64 msgid "" "[`struct`s](../../custom_types/structs.md), and [`trait`s](../../trait.md)" msgstr "" #: src/generics/assoc_items/types.md:3 msgid "" "The use of \"Associated types\" improves the overall readability of code by " "moving inner types locally into a trait as _output_ types. Syntax for the " "`trait` definition is as follows:" msgstr "" #: src/generics/assoc_items/types.md:8 msgid "" "// `A` and `B` are defined in the trait via the `type` keyword.\n" "// (Note: `type` in this context is different from `type` when used for\n" "// aliases).\n" msgstr "" #: src/generics/assoc_items/types.md:15 msgid "// Updated syntax to refer to these new types generically.\n" msgstr "" #: src/generics/assoc_items/types.md:20 msgid "" "Note that functions that use the `trait` `Contains` are no longer required " "to express `A` or `B` at all:" msgstr "" #: src/generics/assoc_items/types.md:24 msgid "// Without using associated types\n" msgstr "" #: src/generics/assoc_items/types.md:27 msgid "// Using associated types\n" msgstr "" #: src/generics/assoc_items/types.md:32 msgid "" "Let's rewrite the example from the previous section using associated types:" msgstr "" #: src/generics/assoc_items/types.md:40 msgid "// Define generic types here which methods will be able to utilize.\n" msgstr "" #: src/generics/assoc_items/types.md:50 msgid "" "// Specify what types `A` and `B` are. If the `input` type\n" " // is `Container(i32, i32)`, the `output` types are determined\n" " // as `i32` and `i32`.\n" msgstr "" #: src/generics/assoc_items/types.md:56 msgid "// `&Self::A` and `&Self::B` are also valid here.\n" msgstr "" #: src/generics/phantom.md:3 msgid "" "A phantom type parameter is one that doesn't show up at runtime, but is " "checked statically (and only) at compile time." msgstr "" #: src/generics/phantom.md:6 msgid "" "Data types can use extra generic type parameters to act as markers or to " "perform type checking at compile time. These extra parameters hold no " "storage values, and have no runtime behavior." msgstr "" #: src/generics/phantom.md:10 msgid "" "In the following example, we combine [std::marker::PhantomData](https://doc." "rust-lang.org/std/marker/struct.PhantomData.html) with the phantom type " "parameter concept to create tuples containing different data types." msgstr "" #: src/generics/phantom.md:16 msgid "" "// A phantom tuple struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "" #: src/generics/phantom.md:18 src/generics/phantom.md:22 msgid "// Allow equality test for this type.\n" msgstr "" #: src/generics/phantom.md:20 msgid "" "// A phantom type struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "" #: src/generics/phantom.md:24 msgid "" "// Note: Storage is allocated for generic type `A`, but not for `B`.\n" "// Therefore, `B` cannot be used in computations.\n" msgstr "" #: src/generics/phantom.md:29 msgid "" "// Here, `f32` and `f64` are the hidden parameters.\n" " // PhantomTuple type specified as ``.\n" msgstr "" #: src/generics/phantom.md:31 src/generics/phantom.md:33 #: src/generics/phantom.md:37 src/generics/phantom.md:42 #: src/scope/borrow/ref.md:12 msgid "'Q'" msgstr "" #: src/generics/phantom.md:32 msgid "// PhantomTuple type specified as ``.\n" msgstr "" #: src/generics/phantom.md:35 msgid "// Type specified as ``.\n" msgstr "" #: src/generics/phantom.md:40 msgid "// Type specified as ``.\n" msgstr "" #: src/generics/phantom.md:46 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_tuple1 == _tuple2 yields: {}\",\n" " // _tuple1 == _tuple2);\n" msgstr "" #: src/generics/phantom.md:50 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_struct1 == _struct2 yields: {}\",\n" " // _struct1 == _struct2);\n" msgstr "" #: src/generics/phantom.md:58 msgid "" "[Derive](../trait/derive.md), [struct](../custom_types/structs.md), and " "[TupleStructs](../custom_types/structs.md)" msgstr "" #: src/generics/phantom/testcase_units.md:3 msgid "" "A useful method of unit conversions can be examined by implementing `Add` " "with a phantom type parameter. The `Add` `trait` is examined below:" msgstr "" #: src/generics/phantom/testcase_units.md:7 msgid "" "// This construction would impose: `Self + RHS = Output`\n" "// where RHS defaults to Self if not specified in the implementation.\n" msgstr "" #: src/generics/phantom/testcase_units.md:14 msgid "// `Output` must be `T` so that `T + T = T`.\n" msgstr "" #: src/generics/phantom/testcase_units.md:22 msgid "The whole implementation:" msgstr "" #: src/generics/phantom/testcase_units.md:27 msgid "/// Create void enumerations to define unit types.\n" msgstr "" #: src/generics/phantom/testcase_units.md:33 msgid "" "/// `Length` is a type with phantom type parameter `Unit`,\n" "/// and is not generic over the length type (that is `f64`).\n" "///\n" "/// `f64` already implements the `Clone` and `Copy` traits.\n" msgstr "" #: src/generics/phantom/testcase_units.md:40 msgid "/// The `Add` trait defines the behavior of the `+` operator.\n" msgstr "" #: src/generics/phantom/testcase_units.md:45 msgid "// add() returns a new `Length` struct containing the sum.\n" msgstr "" #: src/generics/phantom/testcase_units.md:47 msgid "// `+` calls the `Add` implementation for `f64`.\n" msgstr "" #: src/generics/phantom/testcase_units.md:53 msgid "// Specifies `one_foot` to have phantom type parameter `Inch`.\n" msgstr "" #: src/generics/phantom/testcase_units.md:55 msgid "// `one_meter` has phantom type parameter `Mm`.\n" msgstr "" #: src/generics/phantom/testcase_units.md:58 msgid "" "// `+` calls the `add()` method we implemented for `Length`.\n" " //\n" " // Since `Length` implements `Copy`, `add()` does not consume\n" " // `one_foot` and `one_meter` but copies them into `self` and `rhs`.\n" msgstr "" #: src/generics/phantom/testcase_units.md:65 msgid "// Addition works.\n" msgstr "" #: src/generics/phantom/testcase_units.md:66 msgid "\"one foot + one_foot = {:?} in\"" msgstr "" #: src/generics/phantom/testcase_units.md:67 msgid "\"one meter + one_meter = {:?} mm\"" msgstr "" #: src/generics/phantom/testcase_units.md:69 msgid "" "// Nonsensical operations fail as they should:\n" " // Compile-time Error: type mismatch.\n" " //let one_feter = one_foot + one_meter;\n" msgstr "" #: src/generics/phantom/testcase_units.md:77 msgid "" "[Borrowing (`&`)](../../scope/borrow.md), [Bounds (`X: Y`)](../../generics/" "bounds.md), [enum](../../custom_types/enum.md), [impl & self](../../fn/" "methods.md), [Overloading](../../trait/ops.md), [ref](../../scope/borrow/ref." "md), [Traits (`X for Y`)](../../trait.md), and [TupleStructs](../../" "custom_types/structs.md)." msgstr "" #: src/scope.md:3 msgid "" "Scopes play an important part in ownership, borrowing, and lifetimes. That " "is, they indicate to the compiler when borrows are valid, when resources can " "be freed, and when variables are created or destroyed." msgstr "" #: src/scope/raii.md:3 msgid "" "Variables in Rust do more than just hold data in the stack: they also _own_ " "resources, e.g. `Box` owns memory in the heap. Rust enforces [RAII]" "(https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) " "(Resource Acquisition Is Initialization), so whenever an object goes out of " "scope, its destructor is called and its owned resources are freed." msgstr "" #: src/scope/raii.md:8 msgid "" "This behavior shields against _resource leak_ bugs, so you'll never have to " "manually free memory or worry about memory leaks again! Here's a quick " "showcase:" msgstr "" #: src/scope/raii.md:12 msgid "// raii.rs\n" msgstr "" #: src/scope/raii.md:14 src/scope/raii.md:21 src/scope/raii.md:26 msgid "// Allocate an integer on the heap\n" msgstr "" #: src/scope/raii.md:17 msgid "// `_box1` is destroyed here, and memory gets freed\n" msgstr "" #: src/scope/raii.md:24 msgid "// A nested scope:\n" msgstr "" #: src/scope/raii.md:29 msgid "// `_box3` is destroyed here, and memory gets freed\n" msgstr "" #: src/scope/raii.md:32 msgid "" "// Creating lots of boxes just for fun\n" " // There's no need to manually free memory!\n" msgstr "" #: src/scope/raii.md:38 msgid "// `_box2` is destroyed here, and memory gets freed\n" msgstr "" #: src/scope/raii.md:42 msgid "" "Of course, we can double check for memory errors using [`valgrind`](http://" "valgrind.org/info/):" msgstr "" #: src/scope/raii.md:65 msgid "No leaks here!" msgstr "" #: src/scope/raii.md:67 msgid "Destructor" msgstr "" #: src/scope/raii.md:69 msgid "" "The notion of a destructor in Rust is provided through the [`Drop`](https://" "doc.rust-lang.org/std/ops/trait.Drop.html) trait. The destructor is called " "when the resource goes out of scope. This trait is not required to be " "implemented for every type, only implement it for your type if you require " "its own destructor logic." msgstr "" #: src/scope/raii.md:74 msgid "" "Run the below example to see how the [`Drop`](https://doc.rust-lang.org/std/" "ops/trait.Drop.html) trait works. When the variable in the `main` function " "goes out of scope the custom destructor will be invoked." msgstr "" #: src/scope/raii.md:82 msgid "\"ToDrop is being dropped\"" msgstr "" #: src/scope/raii.md:88 msgid "\"Made a ToDrop!\"" msgstr "" #: src/scope/raii.md:94 msgid "[Box](../std/box.md)" msgstr "" #: src/scope/move.md:3 msgid "" "Because variables are in charge of freeing their own resources, **resources " "can only have one owner**. This prevents resources from being freed more " "than once. Note that not all variables own resources (e.g. [references](../" "flow_control/match/destructuring/destructure_pointers.md))." msgstr "" #: src/scope/move.md:8 msgid "" "When doing assignments (`let x = y`) or passing function arguments by value " "(`foo(x)`), the _ownership_ of the resources is transferred. In Rust-speak, " "this is known as a _move_." msgstr "" #: src/scope/move.md:12 msgid "" "After moving resources, the previous owner can no longer be used. This " "avoids creating dangling pointers." msgstr "" #: src/scope/move.md:16 msgid "// This function takes ownership of the heap allocated memory\n" msgstr "" #: src/scope/move.md:18 msgid "\"Destroying a box that contains {}\"" msgstr "" #: src/scope/move.md:20 msgid "// `c` is destroyed and the memory freed\n" msgstr "" #: src/scope/move.md:24 msgid "// _Stack_ allocated integer\n" msgstr "" #: src/scope/move.md:27 msgid "// *Copy* `x` into `y` - no resources are moved\n" msgstr "" #: src/scope/move.md:30 msgid "// Both values can be independently used\n" msgstr "" #: src/scope/move.md:31 msgid "\"x is {}, and y is {}\"" msgstr "" #: src/scope/move.md:33 msgid "// `a` is a pointer to a _heap_ allocated integer\n" msgstr "" #: src/scope/move.md:36 msgid "\"a contains: {}\"" msgstr "" #: src/scope/move.md:38 msgid "// *Move* `a` into `b`\n" msgstr "" #: src/scope/move.md:40 msgid "" "// The pointer address of `a` is copied (not the data) into `b`.\n" " // Both are now pointers to the same heap allocated data, but\n" " // `b` now owns it.\n" msgstr "" #: src/scope/move.md:44 msgid "" "// Error! `a` can no longer access the data, because it no longer owns the\n" " // heap memory\n" " //println!(\"a contains: {}\", a);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/scope/move.md:49 msgid "" "// This function takes ownership of the heap allocated memory from `b`\n" msgstr "" #: src/scope/move.md:52 msgid "" "// Since the heap memory has been freed at this point, this action would\n" " // result in dereferencing freed memory, but it's forbidden by the " "compiler\n" " // Error! Same reason as the previous Error\n" " //println!(\"b contains: {}\", b);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/scope/move/mut.md:3 msgid "Mutability of data can be changed when ownership is transferred." msgstr "" #: src/scope/move/mut.md:9 msgid "\"immutable_box contains {}\"" msgstr "" #: src/scope/move/mut.md:11 msgid "" "// Mutability error\n" " //*immutable_box = 4;\n" msgstr "" #: src/scope/move/mut.md:14 msgid "// *Move* the box, changing the ownership (and mutability)\n" msgstr "" #: src/scope/move/mut.md:17 msgid "\"mutable_box contains {}\"" msgstr "" #: src/scope/move/mut.md:19 msgid "// Modify the contents of the box\n" msgstr "" #: src/scope/move/mut.md:22 msgid "\"mutable_box now contains {}\"" msgstr "" #: src/scope/move/partial_move.md:3 msgid "" "Within the [destructuring](../../flow_control/match/destructuring.md) of a " "single variable, both `by-move` and `by-reference` pattern bindings can be " "used at the same time. Doing this will result in a _partial move_ of the " "variable, which means that parts of the variable will be moved while other " "parts stay. In such a case, the parent variable cannot be used afterwards as " "a whole, however the parts that are only referenced (and not moved) can " "still be used. Note that types that implement the [`Drop` trait](../../trait/" "drop.md) cannot be partially moved from, because its `drop` method would use " "it afterwards as a whole." msgstr "" #: src/scope/move/partial_move.md:22 msgid "" "// Error! cannot move out of a type which implements the `Drop` trait\n" " //impl Drop for Person {\n" " // fn drop(&mut self) {\n" " // println!(\"Dropping the person struct {:?}\", self)\n" " // }\n" " //}\n" " // TODO ^ Try uncommenting these lines\n" msgstr "" #: src/scope/move/partial_move.md:35 msgid "// `name` is moved out of person, but `age` is referenced\n" msgstr "" #: src/scope/move/partial_move.md:38 msgid "\"The person's age is {}\"" msgstr "" #: src/scope/move/partial_move.md:40 msgid "\"The person's name is {}\"" msgstr "" #: src/scope/move/partial_move.md:42 msgid "" "// Error! borrow of partially moved value: `person` partial move occurs\n" " //println!(\"The person struct is {:?}\", person);\n" msgstr "" #: src/scope/move/partial_move.md:45 msgid "" "// `person` cannot be used but `person.age` can be used as it is not moved\n" msgstr "" #: src/scope/move/partial_move.md:46 msgid "\"The person's age from person struct is {}\"" msgstr "" #: src/scope/move/partial_move.md:50 msgid "" "(In this example, we store the `age` variable on the heap to illustrate the " "partial move: deleting `ref` in the above code would give an error as the " "ownership of `person.age` would be moved to the variable `age`. If `Person." "age` were stored on the stack, `ref` would not be required as the definition " "of `age` would copy the data from `person.age` without moving it.)" msgstr "" #: src/scope/move/partial_move.md:59 msgid "[destructuring](../../flow_control/match/destructuring.md)" msgstr "" #: src/scope/borrow.md:3 msgid "" "Most of the time, we'd like to access data without taking ownership over it. " "To accomplish this, Rust uses a _borrowing_ mechanism. Instead of passing " "objects by value (`T`), objects can be passed by reference (`&T`)." msgstr "" #: src/scope/borrow.md:7 msgid "" "The compiler statically guarantees (via its borrow checker) that references " "_always_ point to valid objects. That is, while references to an object " "exist, the object cannot be destroyed." msgstr "" #: src/scope/borrow.md:12 msgid "// This function takes ownership of a box and destroys it\n" msgstr "" #: src/scope/borrow.md:14 msgid "\"Destroying box that contains {}\"" msgstr "" #: src/scope/borrow.md:16 msgid "// This function borrows an i32\n" msgstr "" #: src/scope/borrow.md:19 msgid "\"This int is: {}\"" msgstr "" #: src/scope/borrow.md:23 msgid "" "// Create a boxed i32 in the heap, and a i32 on the stack\n" " // Remember: numbers can have arbitrary underscores added for " "readability\n" " // 5_i32 is the same as 5i32\n" msgstr "" #: src/scope/borrow.md:29 msgid "" "// Borrow the contents of the box. Ownership is not taken,\n" " // so the contents can be borrowed again.\n" msgstr "" #: src/scope/borrow.md:35 msgid "// Take a reference to the data contained inside the box\n" msgstr "" #: src/scope/borrow.md:38 msgid "" "// Error!\n" " // Can't destroy `boxed_i32` while the inner value is borrowed later " "in scope.\n" msgstr "" #: src/scope/borrow.md:43 msgid "// Attempt to borrow `_ref_to_i32` after inner value is destroyed\n" msgstr "" #: src/scope/borrow.md:45 msgid "// `_ref_to_i32` goes out of scope and is no longer borrowed.\n" msgstr "" #: src/scope/borrow.md:48 msgid "" "// `boxed_i32` can now give up ownership to `eat_box_i32` and be destroyed\n" msgstr "" #: src/scope/borrow/mut.md:3 msgid "" "Mutable data can be mutably borrowed using `&mut T`. This is called a " "_mutable reference_ and gives read/write access to the borrower. In " "contrast, `&T` borrows the data via an immutable reference, and the borrower " "can read the data but not modify it:" msgstr "" #: src/scope/borrow/mut.md:12 msgid "" "// `&'static str` is a reference to a string allocated in read only memory\n" msgstr "" #: src/scope/borrow/mut.md:17 msgid "// This function takes a reference to a book\n" msgstr "" #: src/scope/borrow/mut.md:20 msgid "\"I immutably borrowed {} - {} edition\"" msgstr "" #: src/scope/borrow/mut.md:22 msgid "" "// This function takes a reference to a mutable book and changes `year` to " "2014\n" msgstr "" #: src/scope/borrow/mut.md:26 msgid "\"I mutably borrowed {} - {} edition\"" msgstr "" #: src/scope/borrow/mut.md:30 msgid "// Create an immutable Book named `immutabook`\n" msgstr "" #: src/scope/borrow/mut.md:32 msgid "// string literals have type `&'static str`\n" msgstr "" #: src/scope/borrow/mut.md:33 msgid "\"Douglas Hofstadter\"" msgstr "" #: src/scope/borrow/mut.md:34 msgid "\"Gödel, Escher, Bach\"" msgstr "" #: src/scope/borrow/mut.md:38 msgid "// Create a mutable copy of `immutabook` and call it `mutabook`\n" msgstr "" #: src/scope/borrow/mut.md:41 msgid "// Immutably borrow an immutable object\n" msgstr "" #: src/scope/borrow/mut.md:44 msgid "// Immutably borrow a mutable object\n" msgstr "" #: src/scope/borrow/mut.md:47 msgid "// Borrow a mutable object as mutable\n" msgstr "" #: src/scope/borrow/mut.md:50 msgid "// Error! Cannot borrow an immutable object as mutable\n" msgstr "" #: src/scope/borrow/mut.md:58 msgid "[`static`](../lifetime/static_lifetime.md)" msgstr "" #: src/scope/borrow/alias.md:3 msgid "" "Data can be immutably borrowed any number of times, but while immutably " "borrowed, the original data can't be mutably borrowed. On the other hand, " "only _one_ mutable borrow is allowed at a time. The original data can be " "borrowed again only _after_ the mutable reference has been used for the last " "time." msgstr "" #: src/scope/borrow/alias.md:17 msgid "// Data can be accessed via the references and the original owner\n" msgstr "" #: src/scope/borrow/alias.md:18 src/scope/borrow/alias.md:27 #: src/scope/borrow/alias.md:49 msgid "\"Point has coordinates: ({}, {}, {})\"" msgstr "" #: src/scope/borrow/alias.md:21 msgid "" "// Error! Can't borrow `point` as mutable because it's currently\n" " // borrowed as immutable.\n" " // let mutable_borrow = &mut point;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/scope/borrow/alias.md:26 msgid "// The borrowed values are used again here\n" msgstr "" #: src/scope/borrow/alias.md:30 msgid "" "// The immutable references are no longer used for the rest of the code so\n" " // it is possible to reborrow with a mutable reference.\n" msgstr "" #: src/scope/borrow/alias.md:34 msgid "// Change data via mutable reference\n" msgstr "" #: src/scope/borrow/alias.md:39 msgid "" "// Error! Can't borrow `point` as immutable because it's currently\n" " // borrowed as mutable.\n" " // let y = &point.y;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/scope/borrow/alias.md:44 msgid "" "// Error! Can't print because `println!` takes an immutable reference.\n" " // println!(\"Point Z coordinate is {}\", point.z);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/scope/borrow/alias.md:48 msgid "// Ok! Mutable references can be passed as immutable to `println!`\n" msgstr "" #: src/scope/borrow/alias.md:52 msgid "" "// The mutable reference is no longer used for the rest of the code so it\n" " // is possible to reborrow\n" msgstr "" #: src/scope/borrow/alias.md:55 msgid "\"Point now has coordinates: ({}, {}, {})\"" msgstr "" #: src/scope/borrow/ref.md:3 msgid "" "When doing pattern matching or destructuring via the `let` binding, the " "`ref` keyword can be used to take references to the fields of a struct/" "tuple. The example below shows a few instances where this can be useful:" msgstr "" #: src/scope/borrow/ref.md:14 msgid "" "// A `ref` borrow on the left side of an assignment is equivalent to\n" " // an `&` borrow on the right side.\n" msgstr "" #: src/scope/borrow/ref.md:19 msgid "\"ref_c1 equals ref_c2: {}\"" msgstr "" #: src/scope/borrow/ref.md:23 msgid "// `ref` is also valid when destructuring a struct.\n" msgstr "" #: src/scope/borrow/ref.md:25 msgid "// `ref_to_x` is a reference to the `x` field of `point`.\n" msgstr "" #: src/scope/borrow/ref.md:28 msgid "// Return a copy of the `x` field of `point`.\n" msgstr "" #: src/scope/borrow/ref.md:32 msgid "// A mutable copy of `point`\n" msgstr "" #: src/scope/borrow/ref.md:36 msgid "// `ref` can be paired with `mut` to take mutable references.\n" msgstr "" #: src/scope/borrow/ref.md:39 msgid "// Mutate the `y` field of `mutable_point` via a mutable reference.\n" msgstr "" #: src/scope/borrow/ref.md:43 msgid "\"point is ({}, {})\"" msgstr "" #: src/scope/borrow/ref.md:44 msgid "\"mutable_point is ({}, {})\"" msgstr "" #: src/scope/borrow/ref.md:46 msgid "// A mutable tuple that includes a pointer\n" msgstr "" #: src/scope/borrow/ref.md:50 msgid "// Destructure `mutable_tuple` to change the value of `last`.\n" msgstr "" #: src/scope/borrow/ref.md:55 msgid "\"tuple is {:?}\"" msgstr "" #: src/scope/lifetime.md:3 msgid "" "A _lifetime_ is a construct the compiler (or more specifically, its _borrow " "checker_) uses to ensure all borrows are valid. Specifically, a variable's " "lifetime begins when it is created and ends when it is destroyed. While " "lifetimes and scopes are often referred to together, they are not the same." msgstr "" #: src/scope/lifetime.md:8 msgid "" "Take, for example, the case where we borrow a variable via `&`. The borrow " "has a lifetime that is determined by where it is declared. As a result, the " "borrow is valid as long as it ends before the lender is destroyed. However, " "the scope of the borrow is determined by where the reference is used." msgstr "" #: src/scope/lifetime.md:13 msgid "" "In the following example and in the rest of this section, we will see how " "lifetimes relate to scopes, as well as how the two differ." msgstr "" #: src/scope/lifetime.md:17 msgid "" "// Lifetimes are annotated below with lines denoting the creation\n" "// and destruction of each variable.\n" "// `i` has the longest lifetime because its scope entirely encloses \n" "// both `borrow1` and `borrow2`. The duration of `borrow1` compared \n" "// to `borrow2` is irrelevant since they are disjoint.\n" msgstr "" #: src/scope/lifetime.md:23 msgid "" "// Lifetime for `i` starts. ────────────────┐\n" " // │\n" msgstr "" #: src/scope/lifetime.md:25 src/scope/lifetime.md:32 msgid "// │\n" msgstr "" #: src/scope/lifetime.md:26 msgid "" "// `borrow1` lifetime starts. ──┐│\n" " // ││\n" msgstr "" #: src/scope/lifetime.md:28 msgid "\"borrow1: {}\"" msgstr "" #: src/scope/lifetime.md:28 src/scope/lifetime.md:35 msgid "// ││\n" msgstr "" #: src/scope/lifetime.md:29 msgid "" "// `borrow1` ends. ─────────────────────────────────┘│\n" " // │\n" " // │\n" msgstr "" #: src/scope/lifetime.md:33 msgid "" "// `borrow2` lifetime starts. ──┐│\n" " // ││\n" msgstr "" #: src/scope/lifetime.md:35 msgid "\"borrow2: {}\"" msgstr "" #: src/scope/lifetime.md:36 msgid "" "// `borrow2` ends. ─────────────────────────────────┘│\n" " // │\n" msgstr "" #: src/scope/lifetime.md:38 msgid "// Lifetime ends. ─────────────────────────────────────┘\n" msgstr "" #: src/scope/lifetime.md:41 msgid "" "Note that no names or types are assigned to label lifetimes. This restricts " "how lifetimes will be able to be used as we will see." msgstr "" #: src/scope/lifetime/explicit.md:3 msgid "" "The borrow checker uses explicit lifetime annotations to determine how long " "references should be valid. In cases where lifetimes are not elided[^1], " "Rust requires explicit annotations to determine what the lifetime of a " "reference should be. The syntax for explicitly annotating a lifetime uses an " "apostrophe character as follows:" msgstr "" #: src/scope/lifetime/explicit.md:10 msgid "// `foo` has a lifetime parameter `'a`\n" msgstr "" #: src/scope/lifetime/explicit.md:14 msgid "" "Similar to [closures](../../fn/closures/anonymity.md), using lifetimes " "requires generics. Additionally, this lifetime syntax indicates that the " "lifetime of `foo` may not exceed that of `'a`. Explicit annotation of a type " "has the form `&'a T` where `'a` has already been introduced." msgstr "" #: src/scope/lifetime/explicit.md:19 msgid "In cases with multiple lifetimes, the syntax is similar:" msgstr "" #: src/scope/lifetime/explicit.md:22 msgid "// `foo` has lifetime parameters `'a` and `'b`\n" msgstr "" #: src/scope/lifetime/explicit.md:26 msgid "" "In this case, the lifetime of `foo` cannot exceed that of either `'a` _or_ " "`'b`." msgstr "" #: src/scope/lifetime/explicit.md:28 msgid "See the following example for explicit lifetime annotation in use:" msgstr "" #: src/scope/lifetime/explicit.md:31 msgid "" "// `print_refs` takes two references to `i32` which have different\n" "// lifetimes `'a` and `'b`. These two lifetimes must both be at\n" "// least as long as the function `print_refs`.\n" msgstr "" #: src/scope/lifetime/explicit.md:35 msgid "\"x is {} and y is {}\"" msgstr "" #: src/scope/lifetime/explicit.md:37 msgid "" "// A function which takes no arguments, but has a lifetime parameter `'a`.\n" msgstr "" #: src/scope/lifetime/explicit.md:42 msgid "// ERROR: `_x` does not live long enough\n" msgstr "" #: src/scope/lifetime/explicit.md:44 msgid "" "// Attempting to use the lifetime `'a` as an explicit type annotation \n" " // inside the function will fail because the lifetime of `&_x` is " "shorter\n" " // than that of `_y`. A short lifetime cannot be coerced into a longer " "one.\n" msgstr "" #: src/scope/lifetime/explicit.md:50 msgid "// Create variables to be borrowed below.\n" msgstr "" #: src/scope/lifetime/explicit.md:53 msgid "// Borrows (`&`) of both variables are passed into the function.\n" msgstr "" #: src/scope/lifetime/explicit.md:55 msgid "" "// Any input which is borrowed must outlive the borrower. \n" " // In other words, the lifetime of `four` and `nine` must \n" " // be longer than that of `print_refs`.\n" msgstr "" #: src/scope/lifetime/explicit.md:60 msgid "" "// `failed_borrow` contains no references to force `'a` to be \n" " // longer than the lifetime of the function, but `'a` is longer.\n" " // Because the lifetime is never constrained, it defaults to `'static`.\n" msgstr "" #: src/scope/lifetime/explicit.md:66 msgid "" "[elision](elision.md) implicitly annotates lifetimes and so is different." msgstr "" #: src/scope/lifetime/explicit.md:70 msgid "[generics](../../generics.md) and [closures](../../fn/closures.md)" msgstr "" #: src/scope/lifetime/fn.md:3 msgid "" "Ignoring [elision](elision.md), function signatures with lifetimes have a " "few constraints:" msgstr "" #: src/scope/lifetime/fn.md:5 msgid "any reference _must_ have an annotated lifetime." msgstr "" #: src/scope/lifetime/fn.md:6 msgid "" "any reference being returned _must_ have the same lifetime as an input or be " "`static`." msgstr "" #: src/scope/lifetime/fn.md:9 msgid "" "Additionally, note that returning references without input is banned if it " "would result in returning references to invalid data. The following example " "shows off some valid forms of functions with lifetimes:" msgstr "" #: src/scope/lifetime/fn.md:14 msgid "" "// One input reference with lifetime `'a` which must live\n" "// at least as long as the function.\n" msgstr "" #: src/scope/lifetime/fn.md:17 msgid "\"`print_one`: x is {}\"" msgstr "" #: src/scope/lifetime/fn.md:19 msgid "// Mutable references are possible with lifetimes as well.\n" msgstr "" #: src/scope/lifetime/fn.md:24 msgid "" "// Multiple elements with different lifetimes. In this case, it\n" "// would be fine for both to have the same lifetime `'a`, but\n" "// in more complex cases, different lifetimes may be required.\n" msgstr "" #: src/scope/lifetime/fn.md:29 msgid "\"`print_multi`: x is {}, y is {}\"" msgstr "" #: src/scope/lifetime/fn.md:31 msgid "" "// Returning references that have been passed in is acceptable.\n" "// However, the correct lifetime must be returned.\n" msgstr "" #: src/scope/lifetime/fn.md:35 msgid "" "//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n" "// The above is invalid: `'a` must live longer than the function.\n" "// Here, `&String::from(\"foo\")` would create a `String`, followed by a\n" "// reference. Then the data is dropped upon exiting the scope, leaving\n" "// a reference to invalid data to be returned.\n" msgstr "" #: src/scope/lifetime/fn.md:60 msgid "[Functions](../../fn.md)" msgstr "" #: src/scope/lifetime/methods.md:3 msgid "Methods are annotated similarly to functions:" msgstr "" #: src/scope/lifetime/methods.md:9 msgid "// Annotate lifetimes as in a standalone function.\n" msgstr "" #: src/scope/lifetime/methods.md:12 msgid "\"`print`: {}\"" msgstr "" #: src/scope/lifetime/methods.md:26 msgid "[methods](../../fn/methods.md)" msgstr "" #: src/scope/lifetime/struct.md:3 msgid "Annotation of lifetimes in structures are also similar to functions:" msgstr "" #: src/scope/lifetime/struct.md:6 msgid "" "// A type `Borrowed` which houses a reference to an\n" "// `i32`. The reference to `i32` must outlive `Borrowed`.\n" msgstr "" #: src/scope/lifetime/struct.md:10 msgid "// Similarly, both references here must outlive this structure.\n" msgstr "" #: src/scope/lifetime/struct.md:17 msgid "// An enum which is either an `i32` or a reference to one.\n" msgstr "" #: src/scope/lifetime/struct.md:34 src/scope/lifetime/struct.md:36 msgid "\"x is borrowed in {:?}\"" msgstr "" #: src/scope/lifetime/struct.md:35 msgid "\"x and y are borrowed in {:?}\"" msgstr "" #: src/scope/lifetime/struct.md:37 msgid "\"y is *not* borrowed in {:?}\"" msgstr "" #: src/scope/lifetime/struct.md:43 msgid "[`struct`s](../../custom_types/structs.md)" msgstr "" #: src/scope/lifetime/trait.md:3 msgid "" "Annotation of lifetimes in trait methods basically are similar to functions. " "Note that `impl` may have annotation of lifetimes too." msgstr "" #: src/scope/lifetime/trait.md:7 msgid "// A struct with annotation of lifetimes.\n" msgstr "" #: src/scope/lifetime/trait.md:12 msgid "// Annotate lifetimes to impl.\n" msgstr "" #: src/scope/lifetime/trait.md:24 msgid "\"b is {:?}\"" msgstr "" #: src/scope/lifetime/trait.md:30 msgid "[`trait`s](../../trait.md)" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:3 msgid "" "Just like generic types can be bounded, lifetimes (themselves generic) use " "bounds as well. The `:` character has a slightly different meaning here, but " "`+` is the same. Note how the following read:" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:7 msgid "`T: 'a`: _All_ references in `T` must outlive lifetime `'a`." msgstr "" #: src/scope/lifetime/lifetime_bounds.md:8 msgid "" "`T: Trait + 'a`: Type `T` must implement trait `Trait` and _all_ references " "in `T` must outlive `'a`." msgstr "" #: src/scope/lifetime/lifetime_bounds.md:11 msgid "" "The example below shows the above syntax in action used after keyword " "`where`:" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:14 msgid "// Trait to bound with.\n" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:17 msgid "" "// `Ref` contains a reference to a generic type `T` that has\n" "// some lifetime `'a` unknown by `Ref`. `T` is bounded such that any\n" "// *references* in `T` must outlive `'a`. Additionally, the lifetime\n" "// of `Ref` may not exceed `'a`.\n" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:22 msgid "// A generic function which prints using the `Debug` trait.\n" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:26 msgid "\"`print`: t is {:?}\"" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:28 msgid "" "// Here a reference to `T` is taken where `T` implements\n" "// `Debug` and all *references* in `T` outlive `'a`. In\n" "// addition, `'a` must outlive the function.\n" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:34 msgid "\"`print_ref`: t is {:?}\"" msgstr "" #: src/scope/lifetime/lifetime_bounds.md:48 msgid "" "[generics](../../generics.md), [bounds in generics](../../generics/bounds." "md), and [multiple bounds in generics](../../generics/multi_bounds.md)" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:3 msgid "" "A longer lifetime can be coerced into a shorter one so that it works inside " "a scope it normally wouldn't work in. This comes in the form of inferred " "coercion by the Rust compiler, and also in the form of declaring a lifetime " "difference:" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:9 msgid "" "// Here, Rust infers a lifetime that is as short as possible.\n" "// The two references are then coerced to that lifetime.\n" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:14 msgid "" "// `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`.\n" "// Here, we take in an `&'a i32` and return a `&'b i32` as a result of " "coercion.\n" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:22 msgid "// Longer lifetime\n" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:25 msgid "// Shorter lifetime\n" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:27 msgid "\"The product is {}\"" msgstr "" #: src/scope/lifetime/lifetime_coercion.md:28 msgid "\"{} is the first\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:3 msgid "" "Rust has a few reserved lifetime names. One of those is `'static`. You might " "encounter it in two situations:" msgstr "" #: src/scope/lifetime/static_lifetime.md:7 msgid "// A reference with 'static lifetime:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:8 msgid "\"hello world\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:9 msgid "// 'static as part of a trait bound:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:14 msgid "" "Both are related but subtly different and this is a common source for " "confusion when learning Rust. Here are some examples for each situation:" msgstr "" #: src/scope/lifetime/static_lifetime.md:17 msgid "Reference lifetime" msgstr "" #: src/scope/lifetime/static_lifetime.md:19 msgid "" "As a reference lifetime `'static` indicates that the data pointed to by the " "reference lives for the remaining lifetime of the running program. It can " "still be coerced to a shorter lifetime." msgstr "" #: src/scope/lifetime/static_lifetime.md:23 msgid "" "There are two common ways to make a variable with `'static` lifetime, and " "both are stored in the read-only memory of the binary:" msgstr "" #: src/scope/lifetime/static_lifetime.md:26 msgid "Make a constant with the `static` declaration." msgstr "" #: src/scope/lifetime/static_lifetime.md:27 msgid "Make a `string` literal which has type: `&'static str`." msgstr "" #: src/scope/lifetime/static_lifetime.md:29 msgid "See the following example for a display of each method:" msgstr "" #: src/scope/lifetime/static_lifetime.md:32 msgid "// Make a constant with `'static` lifetime.\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:34 msgid "" "// Returns a reference to `NUM` where its `'static`\n" "// lifetime is coerced to that of the input argument.\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:43 msgid "// Make a `string` literal and print it:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:44 msgid "\"I'm in read-only memory\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:45 msgid "\"static_string: {}\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:47 msgid "" "// When `static_string` goes out of scope, the reference\n" " // can no longer be used, but the data remains in the binary.\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:52 msgid "// Make an integer to use for `coerce_static`:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:55 msgid "// Coerce `NUM` to lifetime of `lifetime_num`:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:58 msgid "\"coerced_static: {}\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:61 msgid "\"NUM: {} stays accessible!\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:65 msgid "" "Since `'static` references only need to be valid for the _remainder_ of a " "program's life, they can be created while the program is executed. Just to " "demonstrate, the below example uses [`Box::leak`](https://doc.rust-lang.org/" "std/boxed/struct.Box.html#method.leak) to dynamically create `'static` " "references. In that case it definitely doesn't live for the entire duration, " "but only from the leaking point onward." msgstr "" #: src/scope/lifetime/static_lifetime.md:90 msgid "Trait bound" msgstr "" #: src/scope/lifetime/static_lifetime.md:92 msgid "" "As a trait bound, it means the type does not contain any non-static " "references. Eg. the receiver can hold on to the type for as long as they " "want and it will never become invalid until they drop it." msgstr "" #: src/scope/lifetime/static_lifetime.md:96 msgid "" "It's important to understand this means that any owned data always passes a " "`'static` lifetime bound, but a reference to that owned data generally does " "not:" msgstr "" #: src/scope/lifetime/static_lifetime.md:104 msgid "\"'static value passed in is: {:?}\"" msgstr "" #: src/scope/lifetime/static_lifetime.md:108 msgid "// i is owned and contains no references, thus it's 'static:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:112 msgid "" "// oops, &i only has the lifetime defined by the scope of\n" " // main(), so it's not 'static:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:118 msgid "The compiler will tell you:" msgstr "" #: src/scope/lifetime/static_lifetime.md:135 msgid "[`'static` constants](../../custom_types/constants.md)" msgstr "" #: src/scope/lifetime/elision.md:3 msgid "" "Some lifetime patterns are overwhelmingly common and so the borrow checker " "will allow you to omit them to save typing and to improve readability. This " "is known as elision. Elision exists in Rust solely because these patterns " "are common." msgstr "" #: src/scope/lifetime/elision.md:8 msgid "" "The following code shows a few examples of elision. For a more comprehensive " "description of elision, see [lifetime elision](https://doc.rust-lang.org/" "book/ch10-03-lifetime-syntax.html#lifetime-elision) in the book." msgstr "" #: src/scope/lifetime/elision.md:12 msgid "" "// `elided_input` and `annotated_input` essentially have identical " "signatures\n" "// because the lifetime of `elided_input` is inferred by the compiler:\n" msgstr "" #: src/scope/lifetime/elision.md:15 msgid "\"`elided_input`: {}\"" msgstr "" #: src/scope/lifetime/elision.md:19 msgid "\"`annotated_input`: {}\"" msgstr "" #: src/scope/lifetime/elision.md:21 msgid "" "// Similarly, `elided_pass` and `annotated_pass` have identical signatures\n" "// because the lifetime is added implicitly to `elided_pass`:\n" msgstr "" #: src/scope/lifetime/elision.md:34 msgid "\"`elided_pass`: {}\"" msgstr "" #: src/scope/lifetime/elision.md:35 msgid "\"`annotated_pass`: {}\"" msgstr "" #: src/scope/lifetime/elision.md:41 msgid "" "[elision](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax." "html#lifetime-elision)" msgstr "" #: src/trait.md:3 msgid "" "A `trait` is a collection of methods defined for an unknown type: `Self`. " "They can access other methods declared in the same trait." msgstr "" #: src/trait.md:6 msgid "" "Traits can be implemented for any data type. In the example below, we define " "`Animal`, a group of methods. The `Animal` `trait` is then implemented for " "the `Sheep` data type, allowing the use of methods from `Animal` with a " "`Sheep`." msgstr "" #: src/trait.md:15 msgid "" "// Associated function signature; `Self` refers to the implementor type.\n" msgstr "" #: src/trait.md:18 msgid "// Method signatures; these will return a string.\n" msgstr "" #: src/trait.md:22 msgid "// Traits can provide default method definitions.\n" msgstr "" #: src/trait.md:24 msgid "\"{} says {}\"" msgstr "" #: src/trait.md:35 msgid "// Implementor methods can use the implementor's trait methods.\n" msgstr "" #: src/trait.md:36 msgid "\"{} is already naked...\"" msgstr "" #: src/trait.md:38 msgid "\"{} gets a haircut!\"" msgstr "" #: src/trait.md:44 src/trait/dyn.md:25 msgid "// Implement the `Animal` trait for `Sheep`.\n" msgstr "" #: src/trait.md:47 msgid "// `Self` is the implementor type: `Sheep`.\n" msgstr "" #: src/trait.md:58 msgid "\"baaaaah?\"" msgstr "" #: src/trait.md:60 src/trait/dyn.md:29 msgid "\"baaaaah!\"" msgstr "" #: src/trait.md:64 msgid "// Default trait methods can be overridden.\n" msgstr "" #: src/trait.md:66 msgid "// For example, we can add some quiet contemplation.\n" msgstr "" #: src/trait.md:67 msgid "\"{} pauses briefly... {}\"" msgstr "" #: src/trait.md:72 msgid "// Type annotation is necessary in this case.\n" msgstr "" #: src/trait.md:73 msgid "\"Dolly\"" msgstr "" #: src/trait.md:74 msgid "// TODO ^ Try removing the type annotations.\n" msgstr "" #: src/trait/derive.md:3 msgid "" "The compiler is capable of providing basic implementations for some traits " "via the `#[derive]` [attribute](../attribute.md). These traits can still be " "manually implemented if a more complex behavior is required." msgstr "" #: src/trait/derive.md:7 msgid "The following is a list of derivable traits:" msgstr "" #: src/trait/derive.md:9 msgid "" "Comparison traits: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), " "[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]" "(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)." msgstr "" #: src/trait/derive.md:11 msgid "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), to create " "`T` from `&T` via a copy." msgstr "" #: src/trait/derive.md:12 msgid "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), to give a " "type 'copy semantics' instead of 'move semantics'." msgstr "" #: src/trait/derive.md:13 msgid "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), to compute a " "hash from `&T`." msgstr "" #: src/trait/derive.md:14 msgid "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), to " "create an empty instance of a data type." msgstr "" #: src/trait/derive.md:15 msgid "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), to format a " "value using the `{:?}` formatter." msgstr "" #: src/trait/derive.md:18 msgid "// `Centimeters`, a tuple struct that can be compared\n" msgstr "" #: src/trait/derive.md:21 msgid "// `Inches`, a tuple struct that can be printed\n" msgstr "" #: src/trait/derive.md:33 msgid "// `Seconds`, a tuple struct with no additional attributes\n" msgstr "" #: src/trait/derive.md:40 msgid "" "// Error: `Seconds` can't be printed; it doesn't implement the `Debug` " "trait\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/trait/derive.md:44 msgid "" "// Error: `Seconds` can't be compared; it doesn't implement the `PartialEq` " "trait\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/trait/derive.md:50 msgid "\"One foot equals {:?}\"" msgstr "" #: src/trait/derive.md:56 msgid "\"smaller\"" msgstr "" #: src/trait/derive.md:58 msgid "\"bigger\"" msgstr "" #: src/trait/derive.md:61 msgid "\"One foot is {} than one meter.\"" msgstr "" #: src/trait/derive.md:67 msgid "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)" msgstr "" #: src/trait/dyn.md:3 msgid "" "The Rust compiler needs to know how much space every function's return type " "requires. This means all your functions have to return a concrete type. " "Unlike other languages, if you have a trait like `Animal`, you can't write a " "function that returns `Animal`, because its different implementations will " "need different amounts of memory." msgstr "" #: src/trait/dyn.md:8 msgid "" "However, there's an easy workaround. Instead of returning a trait object " "directly, our functions return a `Box` which _contains_ some `Animal`. A " "`box` is just a reference to some memory in the heap. Because a reference " "has a statically-known size, and the compiler can guarantee it points to a " "heap-allocated `Animal`, we can return a trait from our function!" msgstr "" #: src/trait/dyn.md:13 msgid "" "Rust tries to be as explicit as possible whenever it allocates memory on the " "heap. So if your function returns a pointer-to-trait-on-heap in this way, " "you need to write the return type with the `dyn` keyword, e.g. `Box`." msgstr "" #: src/trait/dyn.md:22 msgid "// Instance method signature\n" msgstr "" #: src/trait/dyn.md:32 msgid "// Implement the `Animal` trait for `Cow`.\n" msgstr "" #: src/trait/dyn.md:36 msgid "\"moooooo!\"" msgstr "" #: src/trait/dyn.md:39 msgid "" "// Returns some struct that implements Animal, but we don't know which one " "at compile time.\n" msgstr "" #: src/trait/dyn.md:52 msgid "\"You've randomly chosen an animal, and it says {}\"" msgstr "" #: src/trait/ops.md:3 msgid "" "In Rust, many of the operators can be overloaded via traits. That is, some " "operators can be used to accomplish different tasks based on their input " "arguments. This is possible because operators are syntactic sugar for method " "calls. For example, the `+` operator in `a + b` calls the `add` method (as " "in `a.add(b)`). This `add` method is part of the `Add` trait. Hence, the `+` " "operator can be used by any implementor of the `Add` trait." msgstr "" #: src/trait/ops.md:9 msgid "" "A list of the traits, such as `Add`, that overload operators can be found in " "[`core::ops`](https://doc.rust-lang.org/core/ops/)." msgstr "" #: src/trait/ops.md:22 msgid "" "// The `std::ops::Add` trait is used to specify the functionality of `+`.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Bar`.\n" "// The following block implements the operation: Foo + Bar = FooBar\n" msgstr "" #: src/trait/ops.md:30 msgid "\"> Foo.add(Bar) was called\"" msgstr "" #: src/trait/ops.md:35 msgid "" "// By reversing the types, we end up implementing non-commutative addition.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Foo`.\n" "// This block implements the operation: Bar + Foo = BarFoo\n" msgstr "" #: src/trait/ops.md:43 msgid "\"> Bar.add(Foo) was called\"" msgstr "" #: src/trait/ops.md:50 msgid "\"Foo + Bar = {:?}\"" msgstr "" #: src/trait/ops.md:51 msgid "\"Bar + Foo = {:?}\"" msgstr "" #: src/trait/ops.md:55 src/testing.md:16 src/testing/doc_testing.md:104 #: src/testing/dev_dependencies.md:36 msgid "See Also" msgstr "" #: src/trait/ops.md:57 msgid "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [Syntax Index]" "(https://doc.rust-lang.org/book/appendix-02-operators.html)" msgstr "" #: src/trait/drop.md:3 msgid "" "The [`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) trait only " "has one method: `drop`, which is called automatically when an object goes " "out of scope. The main use of the `Drop` trait is to free the resources that " "the implementor instance owns." msgstr "" #: src/trait/drop.md:7 msgid "" "`Box`, `Vec`, `String`, `File`, and `Process` are some examples of types " "that implement the `Drop` trait to free resources. The `Drop` trait can also " "be manually implemented for any custom data type." msgstr "" #: src/trait/drop.md:11 msgid "" "The following example adds a print to console to the `drop` function to " "announce when it is called." msgstr "" #: src/trait/drop.md:18 msgid "// This trivial implementation of `drop` adds a print to console.\n" msgstr "" #: src/trait/drop.md:22 msgid "\"> Dropping {}\"" msgstr "" #: src/trait/drop.md:27 src/std_misc/path.md:33 src/std_misc/fs.md:44 #: src/std_misc/fs.md:87 msgid "\"a\"" msgstr "" #: src/trait/drop.md:29 msgid "// block A\n" msgstr "" #: src/trait/drop.md:31 src/std_misc/path.md:33 msgid "\"b\"" msgstr "" #: src/trait/drop.md:33 msgid "// block B\n" msgstr "" #: src/trait/drop.md:35 src/std_misc/path.md:36 msgid "\"c\"" msgstr "" #: src/trait/drop.md:36 msgid "\"d\"" msgstr "" #: src/trait/drop.md:38 msgid "\"Exiting block B\"" msgstr "" #: src/trait/drop.md:40 msgid "\"Just exited block B\"" msgstr "" #: src/trait/drop.md:42 msgid "\"Exiting block A\"" msgstr "" #: src/trait/drop.md:44 msgid "\"Just exited block A\"" msgstr "" #: src/trait/drop.md:46 msgid "// Variable can be manually dropped using the `drop` function\n" msgstr "" #: src/trait/drop.md:48 msgid "// TODO ^ Try commenting this line\n" msgstr "" #: src/trait/drop.md:50 msgid "\"end of the main function\"" msgstr "" #: src/trait/drop.md:52 msgid "" "// `_a` *won't* be `drop`ed again here, because it already has been\n" " // (manually) `drop`ed\n" msgstr "" #: src/trait/iter.md:3 msgid "" "The [`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "trait is used to implement iterators over collections such as arrays." msgstr "" #: src/trait/iter.md:6 msgid "" "The trait requires only a method to be defined for the `next` element, which " "may be manually defined in an `impl` block or automatically defined (as in " "arrays and ranges)." msgstr "" #: src/trait/iter.md:10 msgid "" "As a point of convenience for common situations, the `for` construct turns " "some collections into iterators using the [`.into_iter()`](https://doc.rust-" "lang.org/std/iter/trait.IntoIterator.html) method." msgstr "" #: src/trait/iter.md:18 msgid "" "// Implement `Iterator` for `Fibonacci`.\n" "// The `Iterator` trait only requires a method to be defined for the `next` " "element,\n" "// and an `associated type` to declare the return type of the iterator.\n" msgstr "" #: src/trait/iter.md:23 msgid "// We can refer to this type using Self::Item\n" msgstr "" #: src/trait/iter.md:26 msgid "" "// Here, we define the sequence using `.curr` and `.next`.\n" " // The return type is `Option`:\n" " // * When the `Iterator` is finished, `None` is returned.\n" " // * Otherwise, the next value is wrapped in `Some` and returned.\n" " // We use Self::Item in the return type, so we can change\n" " // the type without having to update the function signatures.\n" msgstr "" #: src/trait/iter.md:38 msgid "" "// Since there's no endpoint to a Fibonacci sequence, the `Iterator` \n" " // will never return `None`, and `Some` is always returned.\n" msgstr "" #: src/trait/iter.md:43 msgid "// Returns a Fibonacci sequence generator\n" msgstr "" #: src/trait/iter.md:50 msgid "// `0..3` is an `Iterator` that generates: 0, 1, and 2.\n" msgstr "" #: src/trait/iter.md:53 msgid "\"Four consecutive `next` calls on 0..3\"" msgstr "" #: src/trait/iter.md:54 src/trait/iter.md:55 src/trait/iter.md:56 #: src/trait/iter.md:57 src/std_misc/fs.md:90 msgid "\"> {:?}\"" msgstr "" #: src/trait/iter.md:59 msgid "" "// `for` works through an `Iterator` until it returns `None`.\n" " // Each `Some` value is unwrapped and bound to a variable (here, `i`).\n" msgstr "" #: src/trait/iter.md:61 msgid "\"Iterate through 0..3 using `for`\"" msgstr "" #: src/trait/iter.md:63 src/trait/iter.md:69 src/trait/iter.md:75 #: src/trait/iter.md:83 src/std/vec.md:50 src/std/str.md:22 #: src/std_misc/fs.md:82 msgid "\"> {}\"" msgstr "" #: src/trait/iter.md:66 msgid "// The `take(n)` method reduces an `Iterator` to its first `n` terms.\n" msgstr "" #: src/trait/iter.md:67 msgid "\"The first four terms of the Fibonacci sequence are: \"" msgstr "" #: src/trait/iter.md:72 msgid "" "// The `skip(n)` method shortens an `Iterator` by dropping its first `n` " "terms.\n" msgstr "" #: src/trait/iter.md:73 msgid "\"The next four terms of the Fibonacci sequence are: \"" msgstr "" #: src/trait/iter.md:80 msgid "// The `iter` method produces an `Iterator` over an array/slice.\n" msgstr "" #: src/trait/iter.md:81 msgid "\"Iterate the following array {:?}\"" msgstr "" #: src/trait/impl_trait.md:3 msgid "`impl Trait` can be used in two locations:" msgstr "" #: src/trait/impl_trait.md:5 msgid "as an argument type" msgstr "" #: src/trait/impl_trait.md:6 msgid "as a return type" msgstr "" #: src/trait/impl_trait.md:8 msgid "As an argument type" msgstr "" #: src/trait/impl_trait.md:10 msgid "" "If your function is generic over a trait but you don't mind the specific " "type, you can simplify the function declaration using `impl Trait` as the " "type of the argument." msgstr "" #: src/trait/impl_trait.md:12 msgid "For example, consider the following code:" msgstr "" #: src/trait/impl_trait.md:18 src/trait/impl_trait.md:37 msgid "// For each line in the source\n" msgstr "" #: src/trait/impl_trait.md:20 src/trait/impl_trait.md:39 msgid "" "// If the line was read successfully, process it, if not, return the error\n" msgstr "" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 src/std/str.md:41 msgid "','" msgstr "" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 msgid "// Split the line separated by commas\n" msgstr "" #: src/trait/impl_trait.md:22 src/trait/impl_trait.md:41 msgid "// Remove leading and trailing whitespace\n" msgstr "" #: src/trait/impl_trait.md:23 src/trait/impl_trait.md:42 msgid "// Collect all strings in a row into a Vec\n" msgstr "" #: src/trait/impl_trait.md:26 src/trait/impl_trait.md:45 msgid "// Collect all lines into a Vec>\n" msgstr "" #: src/trait/impl_trait.md:30 msgid "" "`parse_csv_document` is generic, allowing it to take any type which " "implements BufRead, such as `BufReader` or `[u8]`, but it's not " "important what type `R` is, and `R` is only used to declare the type of " "`src`, so the function can also be written as:" msgstr "" #: src/trait/impl_trait.md:49 msgid "" "Note that using `impl Trait` as an argument type means that you cannot " "explicitly state what form of the function you use, i.e. " "`parse_csv_document::(std::io::empty())` will not work with " "the second example." msgstr "" #: src/trait/impl_trait.md:51 msgid "As a return type" msgstr "" #: src/trait/impl_trait.md:53 msgid "" "If your function returns a type that implements `MyTrait`, you can write its " "return type as `-> impl MyTrait`. This can help simplify your type " "signatures quite a lot!" msgstr "" #: src/trait/impl_trait.md:59 msgid "" "// This function combines two `Vec` and returns an iterator over it.\n" "// Look how complicated its return type is!\n" msgstr "" #: src/trait/impl_trait.md:68 msgid "" "// This is the exact same function, but its return type uses `impl Trait`.\n" "// Look how much simpler it is!\n" msgstr "" #: src/trait/impl_trait.md:87 msgid "\"all done\"" msgstr "" #: src/trait/impl_trait.md:91 msgid "" "More importantly, some Rust types can't be written out. For example, every " "closure has its own unnamed concrete type. Before `impl Trait` syntax, you " "had to allocate on the heap in order to return a closure. But now you can do " "it all statically, like this:" msgstr "" #: src/trait/impl_trait.md:97 msgid "// Returns a function that adds `y` to its input\n" msgstr "" #: src/trait/impl_trait.md:109 msgid "" "You can also use `impl Trait` to return an iterator that uses `map` or " "`filter` closures! This makes using `map` and `filter` easier. Because " "closure types don't have names, you can't write out an explicit return type " "if your function returns iterators with closures. But with `impl Trait` you " "can do this easily:" msgstr "" #: src/trait/clone.md:3 msgid "" "When dealing with resources, the default behavior is to transfer them during " "assignments or function calls. However, sometimes we need to make a copy of " "the resource as well." msgstr "" #: src/trait/clone.md:7 msgid "" "The [`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) trait " "helps us do exactly this. Most commonly, we can use the `.clone()` method " "defined by the `Clone` trait." msgstr "" #: src/trait/clone.md:11 msgid "// A unit struct without resources\n" msgstr "" #: src/trait/clone.md:14 msgid "// A tuple struct with resources that implements the `Clone` trait\n" msgstr "" #: src/trait/clone.md:20 msgid "// Instantiate `Unit`\n" msgstr "" #: src/trait/clone.md:22 msgid "// Copy `Unit`, there are no resources to move\n" msgstr "" #: src/trait/clone.md:25 msgid "// Both `Unit`s can be used independently\n" msgstr "" #: src/trait/clone.md:26 src/trait/clone.md:31 msgid "\"original: {:?}\"" msgstr "" #: src/trait/clone.md:27 msgid "\"copy: {:?}\"" msgstr "" #: src/trait/clone.md:29 msgid "// Instantiate `Pair`\n" msgstr "" #: src/trait/clone.md:33 msgid "// Move `pair` into `moved_pair`, moves resources\n" msgstr "" #: src/trait/clone.md:35 msgid "\"moved: {:?}\"" msgstr "" #: src/trait/clone.md:37 msgid "" "// Error! `pair` has lost its resources\n" " //println!(\"original: {:?}\", pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/trait/clone.md:41 msgid "// Clone `moved_pair` into `cloned_pair` (resources are included)\n" msgstr "" #: src/trait/clone.md:43 msgid "// Drop the moved original pair using std::mem::drop\n" msgstr "" #: src/trait/clone.md:46 msgid "" "// Error! `moved_pair` has been dropped\n" " //println!(\"moved and dropped: {:?}\", moved_pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/trait/clone.md:50 msgid "// The result from .clone() can still be used!\n" msgstr "" #: src/trait/clone.md:51 msgid "\"clone: {:?}\"" msgstr "" #: src/trait/supertraits.md:3 msgid "" "Rust doesn't have \"inheritance\", but you can define a trait as being a " "superset of another trait. For example:" msgstr "" #: src/trait/supertraits.md:10 msgid "" "// Person is a supertrait of Student.\n" "// Implementing Student requires you to also impl Person.\n" msgstr "" #: src/trait/supertraits.md:20 msgid "" "// CompSciStudent (computer science student) is a subtrait of both " "Programmer \n" "// and Student. Implementing CompSciStudent requires you to impl both " "supertraits.\n" msgstr "" #: src/trait/supertraits.md:29 msgid "" "\"My name is {} and I attend {}. My favorite language is {}. My Git username " "is {}\"" msgstr "" #: src/trait/supertraits.md:42 msgid "" "[The Rust Programming Language chapter on supertraits](https://doc.rust-lang." "org/book/ch19-03-advanced-traits.html#using-supertraits-to-require-one-" "traits-functionality-within-another-trait)" msgstr "" #: src/trait/disambiguating.md:3 msgid "" "A type can implement many different traits. What if two traits both require " "the same name for a function? For example, many traits might have a method " "named `get()`. They might even have different return types!" msgstr "" #: src/trait/disambiguating.md:7 msgid "" "Good news: because each trait implementation gets its own `impl` block, it's " "clear which trait's `get` method you're implementing." msgstr "" #: src/trait/disambiguating.md:10 msgid "" "What about when it comes time to _call_ those methods? To disambiguate " "between them, we have to use Fully Qualified Syntax." msgstr "" #: src/trait/disambiguating.md:15 msgid "// Get the selected username out of this widget\n" msgstr "" #: src/trait/disambiguating.md:20 msgid "// Get the selected age out of this widget\n" msgstr "" #: src/trait/disambiguating.md:23 msgid "// A form with both a UsernameWidget and an AgeWidget\n" msgstr "" #: src/trait/disambiguating.md:44 src/trait/disambiguating.md:54 msgid "\"rustacean\"" msgstr "" #: src/trait/disambiguating.md:48 msgid "" "// If you uncomment this line, you'll get an error saying\n" " // \"multiple `get` found\". Because, after all, there are multiple " "methods\n" " // named `get`.\n" " // println!(\"{}\", form.get());\n" msgstr "" #: src/trait/disambiguating.md:62 msgid "" "[The Rust Programming Language chapter on Fully Qualified syntax](https://" "doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-" "for-disambiguation-calling-methods-with-the-same-name)" msgstr "" #: src/macros.md:1 msgid "`macro_rules!`" msgstr "" #: src/macros.md:3 msgid "" "Rust provides a powerful macro system that allows metaprogramming. As you've " "seen in previous chapters, macros look like functions, except that their " "name ends with a bang `!`, but instead of generating a function call, macros " "are expanded into source code that gets compiled with the rest of the " "program. However, unlike macros in C and other languages, Rust macros are " "expanded into abstract syntax trees, rather than string preprocessing, so " "you don't get unexpected precedence bugs." msgstr "" #: src/macros.md:11 msgid "Macros are created using the `macro_rules!` macro." msgstr "" #: src/macros.md:14 msgid "// This is a simple macro named `say_hello`.\n" msgstr "" #: src/macros.md:16 msgid "// `()` indicates that the macro takes no argument.\n" msgstr "" #: src/macros.md:18 msgid "// The macro will expand into the contents of this block.\n" msgstr "" #: src/macros.md:19 msgid "\"Hello!\"" msgstr "" #: src/macros.md:24 msgid "// This call will expand into `println!(\"Hello!\")`\n" msgstr "" #: src/macros.md:29 msgid "So why are macros useful?" msgstr "" #: src/macros.md:31 msgid "" "Don't repeat yourself. There are many cases where you may need similar " "functionality in multiple places but with different types. Often, writing a " "macro is a useful way to avoid repeating code. (More on this later)" msgstr "" #: src/macros.md:35 msgid "" "Domain-specific languages. Macros allow you to define special syntax for a " "specific purpose. (More on this later)" msgstr "" #: src/macros.md:38 msgid "" "Variadic interfaces. Sometimes you want to define an interface that takes a " "variable number of arguments. An example is `println!` which could take any " "number of arguments, depending on the format string. (More on this later)" msgstr "" #: src/macros/syntax.md:3 msgid "" "In following subsections, we will show how to define macros in Rust. There " "are three basic ideas:" msgstr "" #: src/macros/syntax.md:6 msgid "[Patterns and Designators](designators.md)" msgstr "" #: src/macros/syntax.md:7 msgid "[Overloading](overload.md)" msgstr "" #: src/macros/syntax.md:8 msgid "[Repetition](repeat.md)" msgstr "" #: src/macros/designators.md:3 msgid "" "The arguments of a macro are prefixed by a dollar sign `$` and type " "annotated with a _designator_:" msgstr "" #: src/macros/designators.md:8 msgid "" "// This macro takes an argument of designator `ident` and\n" " // creates a function named `$func_name`.\n" " // The `ident` designator is used for variable/function names.\n" msgstr "" #: src/macros/designators.md:13 msgid "// The `stringify!` macro converts an `ident` into a string.\n" msgstr "" #: src/macros/designators.md:14 msgid "\"You called {:?}()\"" msgstr "" #: src/macros/designators.md:19 msgid "// Create functions named `foo` and `bar` with the above macro.\n" msgstr "" #: src/macros/designators.md:25 msgid "" "// This macro takes an expression of type `expr` and prints\n" " // it as a string along with its result.\n" " // The `expr` designator is used for expressions.\n" msgstr "" #: src/macros/designators.md:29 msgid "// `stringify!` will convert the expression *as it is* into a string.\n" msgstr "" #: src/macros/designators.md:30 msgid "\"{:?} = {:?}\"" msgstr "" #: src/macros/designators.md:42 msgid "// Recall that blocks are expressions too!\n" msgstr "" #: src/macros/designators.md:51 msgid "These are some of the available designators:" msgstr "" #: src/macros/designators.md:53 msgid "`block`" msgstr "" #: src/macros/designators.md:54 msgid "`expr` is used for expressions" msgstr "" #: src/macros/designators.md:55 msgid "`ident` is used for variable/function names" msgstr "" #: src/macros/designators.md:56 msgid "`item`" msgstr "" #: src/macros/designators.md:57 msgid "`literal` is used for literal constants" msgstr "" #: src/macros/designators.md:58 msgid "`pat` (_pattern_)" msgstr "" #: src/macros/designators.md:59 msgid "`path`" msgstr "" #: src/macros/designators.md:60 msgid "`stmt` (_statement_)" msgstr "" #: src/macros/designators.md:61 msgid "`tt` (_token tree_)" msgstr "" #: src/macros/designators.md:62 msgid "`ty` (_type_)" msgstr "" #: src/macros/designators.md:63 msgid "`vis` (_visibility qualifier_)" msgstr "" #: src/macros/designators.md:65 msgid "" "For a complete list, see the [Rust Reference](https://doc.rust-lang.org/" "reference/macros-by-example.html)." msgstr "" #: src/macros/overload.md:3 msgid "" "Macros can be overloaded to accept different combinations of arguments. In " "that regard, `macro_rules!` can work similarly to a match block:" msgstr "" #: src/macros/overload.md:7 msgid "" "// `test!` will compare `$left` and `$right`\n" "// in different ways depending on how you invoke it:\n" msgstr "" #: src/macros/overload.md:10 msgid "" "// Arguments don't need to be separated by a comma.\n" " // Any template can be used!\n" msgstr "" #: src/macros/overload.md:13 msgid "\"{:?} and {:?} is {:?}\"" msgstr "" #: src/macros/overload.md:18 msgid "// ^ each arm must end with a semicolon.\n" msgstr "" #: src/macros/overload.md:20 msgid "\"{:?} or {:?} is {:?}\"" msgstr "" #: src/macros/repeat.md:3 msgid "" "Macros can use `+` in the argument list to indicate that an argument may " "repeat at least once, or `*`, to indicate that the argument may repeat zero " "or more times." msgstr "" #: src/macros/repeat.md:7 msgid "" "In the following example, surrounding the matcher with `$(...),+` will match " "one or more expression, separated by commas. Also note that the semicolon is " "optional on the last case." msgstr "" #: src/macros/repeat.md:12 msgid "// `find_min!` will calculate the minimum of any number of arguments.\n" msgstr "" #: src/macros/repeat.md:14 msgid "// Base case:\n" msgstr "" #: src/macros/repeat.md:16 msgid "// `$x` followed by at least one `$y,`\n" msgstr "" #: src/macros/repeat.md:18 msgid "// Call `find_min!` on the tail `$y`\n" msgstr "" #: src/macros/dry.md:3 msgid "" "Macros allow writing DRY code by factoring out the common parts of functions " "and/or test suites. Here is an example that implements and tests the `+=`, " "`*=` and `-=` operators on `Vec`:" msgstr "" #: src/macros/dry.md:11 msgid "" "// The `tt` (token tree) designator is used for\n" " // operators and tokens.\n" msgstr "" #: src/macros/dry.md:15 msgid "\"{:?}: dimension mismatch: {:?} {:?} {:?}\"" msgstr "" #: src/macros/dry.md:30 msgid "// *x = x.$method(*y);\n" msgstr "" #: src/macros/dry.md:35 msgid "// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.\n" msgstr "" #: src/macros/dry.md:60 msgid "// Test `add_assign`, `mul_assign`, and `sub_assign`.\n" msgstr "" #: src/macros/dsl.md:1 msgid "Domain Specific Languages (DSLs)" msgstr "" #: src/macros/dsl.md:3 msgid "" "A DSL is a mini \"language\" embedded in a Rust macro. It is completely " "valid Rust because the macro system expands into normal Rust constructs, but " "it looks like a small language. This allows you to define concise or " "intuitive syntax for some special functionality (within bounds)." msgstr "" #: src/macros/dsl.md:8 msgid "" "Suppose that I want to define a little calculator API. I would like to " "supply an expression and have the output printed to console." msgstr "" #: src/macros/dsl.md:15 msgid "// Force types to be unsigned integers\n" msgstr "" #: src/macros/dsl.md:16 src/macros/variadics.md:15 msgid "\"{} = {}\"" msgstr "" #: src/macros/dsl.md:23 msgid "// hehehe `eval` is _not_ a Rust keyword!\n" msgstr "" #: src/macros/dsl.md:32 src/macros/variadics.md:35 msgid "Output:" msgstr "" #: src/macros/dsl.md:39 msgid "" "This was a very simple example, but much more complex interfaces have been " "developed, such as [`lazy_static`](https://crates.io/crates/lazy_static) or " "[`clap`](https://crates.io/crates/clap)." msgstr "" #: src/macros/dsl.md:43 msgid "" "Also, note the two pairs of braces in the macro. The outer ones are part of " "the syntax of `macro_rules!`, in addition to `()` or `[]`." msgstr "" #: src/macros/variadics.md:1 msgid "Variadic Interfaces" msgstr "" #: src/macros/variadics.md:3 msgid "" "A _variadic_ interface takes an arbitrary number of arguments. For example, " "`println!` can take an arbitrary number of arguments, as determined by the " "format string." msgstr "" #: src/macros/variadics.md:7 msgid "" "We can extend our `calculate!` macro from the previous section to be " "variadic:" msgstr "" #: src/macros/variadics.md:11 msgid "// The pattern for a single `eval`\n" msgstr "" #: src/macros/variadics.md:14 msgid "// Force types to be integers\n" msgstr "" #: src/macros/variadics.md:19 msgid "// Decompose multiple `eval`s recursively\n" msgstr "" #: src/macros/variadics.md:27 msgid "// Look ma! Variadic `calculate!`!\n" msgstr "" #: src/error.md:3 msgid "" "Error handling is the process of handling the possibility of failure. For " "example, failing to read a file and then continuing to use that _bad_ input " "would clearly be problematic. Noticing and explicitly managing those errors " "saves the rest of the program from various pitfalls." msgstr "" #: src/error.md:8 msgid "" "There are various ways to deal with errors in Rust, which are described in " "the following subchapters. They all have more or less subtle differences and " "different use cases. As a rule of thumb:" msgstr "" #: src/error.md:12 msgid "" "An explicit `panic` is mainly useful for tests and dealing with " "unrecoverable errors. For prototyping it can be useful, for example when " "dealing with functions that haven't been implemented yet, but in those cases " "the more descriptive `unimplemented` is better. In tests `panic` is a " "reasonable way to explicitly fail." msgstr "" #: src/error.md:17 msgid "" "The `Option` type is for when a value is optional or when the lack of a " "value is not an error condition. For example the parent of a directory - `/` " "and `C:` don't have one. When dealing with `Option`s, `unwrap` is fine for " "prototyping and cases where it's absolutely certain that there is guaranteed " "to be a value. However `expect` is more useful since it lets you specify an " "error message in case something goes wrong anyway." msgstr "" #: src/error.md:24 msgid "" "When there is a chance that things do go wrong and the caller has to deal " "with the problem, use `Result`. You can `unwrap` and `expect` them as well " "(please don't do that unless it's a test or quick prototype)." msgstr "" #: src/error.md:28 msgid "" "For a more rigorous discussion of error handling, refer to the error " "handling section in the [official book](https://doc.rust-lang.org/book/" "ch09-00-error-handling.html)." msgstr "" #: src/error/panic.md:3 msgid "" "The simplest error handling mechanism we will see is `panic`. It prints an " "error message, starts unwinding the stack, and usually exits the program. " "Here, we explicitly call `panic` on our error condition:" msgstr "" #: src/error/panic.md:9 src/error/abort_unwind.md:9 msgid "// You shouldn't drink too much sugary beverages.\n" msgstr "" #: src/error/panic.md:10 src/error/panic.md:17 src/error/abort_unwind.md:10 #: src/error/abort_unwind.md:23 src/error/abort_unwind.md:41 #: src/error/abort_unwind.md:50 src/error/option_unwrap.md:32 #: src/error/option_unwrap.md:43 src/error/option_unwrap.md:50 msgid "\"lemonade\"" msgstr "" #: src/error/panic.md:10 src/error/option_unwrap.md:43 msgid "\"AAAaaaaa!!!!\"" msgstr "" #: src/error/panic.md:12 src/error/abort_unwind.md:17 #: src/error/abort_unwind.md:44 msgid "\"Some refreshing {} is all I need.\"" msgstr "" #: src/error/panic.md:16 src/error/abort_unwind.md:22 #: src/error/abort_unwind.md:49 src/error/option_unwrap.md:49 msgid "\"water\"" msgstr "" #: src/error/panic.md:18 msgid "\"still water\"" msgstr "" #: src/error/panic.md:22 msgid "" "The first call to `drink` works. The second panics and thus the third is " "never called." msgstr "" #: src/error/abort_unwind.md:1 msgid "`abort` and `unwind`" msgstr "" #: src/error/abort_unwind.md:3 msgid "" "The previous section illustrates the error handling mechanism `panic`. " "Different code paths can be conditionally compiled based on the panic " "setting. The current values available are `unwind` and `abort`." msgstr "" #: src/error/abort_unwind.md:5 msgid "" "Building on the prior lemonade example, we explicitly use the panic strategy " "to exercise different lines of code." msgstr "" #: src/error/abort_unwind.md:11 msgid "\"abort\"" msgstr "" #: src/error/abort_unwind.md:12 src/error/abort_unwind.md:37 msgid "\"This is not your party. Run!!!!\"" msgstr "" #: src/error/abort_unwind.md:14 src/error/abort_unwind.md:32 msgid "\"Spit it out!!!!\"" msgstr "" #: src/error/abort_unwind.md:27 msgid "" "Here is another example focusing on rewriting `drink()` and explicitly use " "the `unwind` keyword." msgstr "" #: src/error/abort_unwind.md:30 src/error/abort_unwind.md:35 msgid "\"unwind\"" msgstr "" #: src/error/abort_unwind.md:54 msgid "" "The panic strategy can be set from the command line by using `abort` or " "`unwind`." msgstr "" #: src/error/option_unwrap.md:3 msgid "" "In the last example, we showed that we can induce program failure at will. " "We told our program to `panic` if we drink a sugary lemonade. But what if we " "expect _some_ drink but don't receive one? That case would be just as bad, " "so it needs to be handled!" msgstr "" #: src/error/option_unwrap.md:8 msgid "" "We _could_ test this against the null string (`\"\"`) as we do with a " "lemonade. Since we're using Rust, let's instead have the compiler point out " "cases where there's no drink." msgstr "" #: src/error/option_unwrap.md:12 msgid "" "An `enum` called `Option` in the `std` library is used when absence is a " "possibility. It manifests itself as one of two \"options\":" msgstr "" #: src/error/option_unwrap.md:15 msgid "`Some(T)`: An element of type `T` was found" msgstr "" #: src/error/option_unwrap.md:16 msgid "`None`: No element was found" msgstr "" #: src/error/option_unwrap.md:18 msgid "" "These cases can either be explicitly handled via `match` or implicitly with " "`unwrap`. Implicit handling will either return the inner element or `panic`." msgstr "" #: src/error/option_unwrap.md:21 msgid "" "Note that it's possible to manually customize `panic` with [expect](https://" "doc.rust-lang.org/std/option/enum.Option.html#method.expect), but `unwrap` " "otherwise leaves us with a less meaningful output than explicit handling. In " "the following example, explicit handling yields a more controlled result " "while retaining the option to `panic` if desired." msgstr "" #: src/error/option_unwrap.md:27 msgid "" "// The adult has seen it all, and can handle any drink well.\n" "// All drinks are handled explicitly using `match`.\n" msgstr "" #: src/error/option_unwrap.md:30 msgid "// Specify a course of action for each case.\n" msgstr "" #: src/error/option_unwrap.md:32 msgid "\"Yuck! Too sugary.\"" msgstr "" #: src/error/option_unwrap.md:33 msgid "\"{}? How nice.\"" msgstr "" #: src/error/option_unwrap.md:34 msgid "\"No drink? Oh well.\"" msgstr "" #: src/error/option_unwrap.md:37 msgid "" "// Others will `panic` before drinking sugary drinks.\n" "// All drinks are handled implicitly using `unwrap`.\n" msgstr "" #: src/error/option_unwrap.md:41 msgid "// `unwrap` returns a `panic` when it receives a `None`.\n" msgstr "" #: src/error/option_unwrap.md:45 msgid "\"I love {}s!!!!!\"" msgstr "" #: src/error/option_unwrap.md:57 msgid "\"coffee\"" msgstr "" #: src/error/option_unwrap/question_mark.md:3 msgid "" "You can unpack `Option`s by using `match` statements, but it's often easier " "to use the `?` operator. If `x` is an `Option`, then evaluating `x?` will " "return the underlying value if `x` is `Some`, otherwise it will terminate " "whatever function is being executed and return `None`." msgstr "" #: src/error/option_unwrap/question_mark.md:10 msgid "" "// If `current_age` is `None`, this returns `None`.\n" " // If `current_age` is `Some`, the inner `u8` value + 1\n" " // gets assigned to `next_age`\n" msgstr "" #: src/error/option_unwrap/question_mark.md:14 msgid "\"Next year I will be {}\"" msgstr "" #: src/error/option_unwrap/question_mark.md:18 msgid "You can chain many `?`s together to make your code much more readable." msgstr "" #: src/error/option_unwrap/question_mark.md:38 msgid "" "// Gets the area code of the phone number of the person's job, if it " "exists.\n" msgstr "" #: src/error/option_unwrap/question_mark.md:40 msgid "" "// This would need many nested `match` statements without the `?` operator.\n" " // It would take a lot more code - try writing it yourself and see " "which\n" " // is easier.\n" msgstr "" #: src/error/option_unwrap/map.md:3 msgid "" "`match` is a valid method for handling `Option`s. However, you may " "eventually find heavy usage tedious, especially with operations only valid " "with an input. In these cases, [combinators](https://doc.rust-lang.org/" "reference/glossary.html#combinator) can be used to manage control flow in a " "modular fashion." msgstr "" #: src/error/option_unwrap/map.md:8 msgid "" "`Option` has a built in method called `map()`, a combinator for the simple " "mapping of `Some -> Some` and `None -> None`. Multiple `map()` calls can be " "chained together for even more flexibility." msgstr "" #: src/error/option_unwrap/map.md:12 msgid "" "In the following example, `process()` replaces all functions previous to it " "while staying compact." msgstr "" #: src/error/option_unwrap/map.md:23 msgid "" "// Peeling food. If there isn't any, then return `None`.\n" "// Otherwise, return the peeled food.\n" msgstr "" #: src/error/option_unwrap/map.md:32 msgid "" "// Chopping food. If there isn't any, then return `None`.\n" "// Otherwise, return the chopped food.\n" msgstr "" #: src/error/option_unwrap/map.md:41 msgid "" "// Cooking food. Here, we showcase `map()` instead of `match` for case " "handling.\n" msgstr "" #: src/error/option_unwrap/map.md:46 msgid "" "// A function to peel, chop, and cook food all in sequence.\n" "// We chain multiple uses of `map()` to simplify the code.\n" msgstr "" #: src/error/option_unwrap/map.md:54 msgid "// Check whether there's food or not before trying to eat it!\n" msgstr "" #: src/error/option_unwrap/map.md:58 msgid "\"Mmm. I love {:?}\"" msgstr "" #: src/error/option_unwrap/map.md:59 msgid "\"Oh no! It wasn't edible.\"" msgstr "" #: src/error/option_unwrap/map.md:70 msgid "// Let's try the simpler looking `process()` now.\n" msgstr "" #: src/error/option_unwrap/map.md:81 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" msgstr "" #: src/error/option_unwrap/and_then.md:3 msgid "" "`map()` was described as a chainable way to simplify `match` statements. " "However, using `map()` on a function that returns an `Option` results in " "the nested `Option>`. Chaining multiple calls together can then " "become confusing. That's where another combinator called `and_then()`, known " "in some languages as flatmap, comes in." msgstr "" #: src/error/option_unwrap/and_then.md:9 msgid "" "`and_then()` calls its function input with the wrapped value and returns the " "result. If the `Option` is `None`, then it returns `None` instead." msgstr "" #: src/error/option_unwrap/and_then.md:11 msgid "" "In the following example, `cookable_v3()` results in an `Option`. " "Using `map()` instead of `and_then()` would have given an " "`Option>`, which is an invalid type for `eat()`." msgstr "" #: src/error/option_unwrap/and_then.md:20 msgid "// We don't have the ingredients to make Sushi.\n" msgstr "" #: src/error/option_unwrap/and_then.md:28 msgid "// We have the recipe for everything except Cordon Bleu.\n" msgstr "" #: src/error/option_unwrap/and_then.md:36 msgid "" "// To make a dish, we need both the recipe and the ingredients.\n" "// We can represent the logic with a chain of `match`es:\n" msgstr "" #: src/error/option_unwrap/and_then.md:45 msgid "" "// This can conveniently be rewritten more compactly with `and_then()`:\n" msgstr "" #: src/error/option_unwrap/and_then.md:50 msgid "" "// Otherwise we'd need to `flatten()` an `Option>`\n" "// to get an `Option`:\n" msgstr "" #: src/error/option_unwrap/and_then.md:59 msgid "\"Yay! On {:?} we get to eat {:?}.\"" msgstr "" #: src/error/option_unwrap/and_then.md:60 msgid "\"Oh no. We don't get to eat on {:?}?\"" msgstr "" #: src/error/option_unwrap/and_then.md:75 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then), and [`Option::flatten()`]" "(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" msgstr "" #: src/error/option_unwrap/defaults.md:1 msgid "Unpacking options and defaults" msgstr "" #: src/error/option_unwrap/defaults.md:3 msgid "" "There is more than one way to unpack an `Option` and fall back on a default " "if it is `None`. To choose the one that meets our needs, we need to consider " "the following:" msgstr "" #: src/error/option_unwrap/defaults.md:5 msgid "do we need eager or lazy evaluation?" msgstr "" #: src/error/option_unwrap/defaults.md:6 msgid "" "do we need to keep the original empty value intact, or modify it in place?" msgstr "" #: src/error/option_unwrap/defaults.md:8 msgid "`or()` is chainable, evaluates eagerly, keeps empty value intact" msgstr "" #: src/error/option_unwrap/defaults.md:10 msgid "" "`or()`is chainable and eagerly evaluates its argument, as is shown in the " "following example. Note that because `or`'s arguments are evaluated eagerly, " "the variable passed to `or` is moved." msgstr "" #: src/error/option_unwrap/defaults.md:22 #: src/error/option_unwrap/defaults.md:55 msgid "\"first_available_fruit: {:?}\"" msgstr "" #: src/error/option_unwrap/defaults.md:23 msgid "// first_available_fruit: Some(Orange)\n" msgstr "" #: src/error/option_unwrap/defaults.md:25 msgid "" "// `or` moves its argument.\n" " // In the example above, `or(orange)` returned a `Some`, so `or(apple)` " "was not invoked.\n" " // But the variable named `apple` has been moved regardless, and cannot " "be used anymore.\n" " // println!(\"Variable apple was moved, so this line won't compile: " "{:?}\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" #: src/error/option_unwrap/defaults.md:33 msgid "`or_else()` is chainable, evaluates lazily, keeps empty value intact" msgstr "" #: src/error/option_unwrap/defaults.md:35 msgid "" "Another alternative is to use `or_else`, which is also chainable, and " "evaluates lazily, as is shown in the following example:" msgstr "" #: src/error/option_unwrap/defaults.md:44 msgid "\"Providing kiwi as fallback\"" msgstr "" #: src/error/option_unwrap/defaults.md:48 #: src/error/option_unwrap/defaults.md:93 msgid "\"Providing lemon as fallback\"" msgstr "" #: src/error/option_unwrap/defaults.md:56 msgid "" "// Providing kiwi as fallback\n" " // first_available_fruit: Some(Kiwi)\n" msgstr "" #: src/error/option_unwrap/defaults.md:61 msgid "`get_or_insert()` evaluates eagerly, modifies empty value in place" msgstr "" #: src/error/option_unwrap/defaults.md:63 msgid "" "To make sure that an `Option` contains a value, we can use `get_or_insert` " "to modify it in place with a fallback value, as is shown in the following " "example. Note that `get_or_insert` eagerly evaluates its parameter, so " "variable `apple` is moved:" msgstr "" #: src/error/option_unwrap/defaults.md:73 #: src/error/option_unwrap/defaults.md:98 msgid "\"first_available_fruit is: {:?}\"" msgstr "" #: src/error/option_unwrap/defaults.md:74 #: src/error/option_unwrap/defaults.md:99 msgid "\"my_fruit is: {:?}\"" msgstr "" #: src/error/option_unwrap/defaults.md:75 msgid "" "// first_available_fruit is: Apple\n" " // my_fruit is: Some(Apple)\n" " //println!(\"Variable named `apple` is moved: {:?}\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" #: src/error/option_unwrap/defaults.md:82 msgid "`get_or_insert_with()` evaluates lazily, modifies empty value in place" msgstr "" #: src/error/option_unwrap/defaults.md:84 msgid "" "Instead of explicitly providing a value to fall back on, we can pass a " "closure to `get_or_insert_with`, as follows:" msgstr "" #: src/error/option_unwrap/defaults.md:100 msgid "" "// Providing lemon as fallback\n" " // first_available_fruit is: Lemon\n" " // my_fruit is: Some(Lemon)\n" msgstr "" #: src/error/option_unwrap/defaults.md:104 msgid "" "// If the Option has a value, it is left unchanged, and the closure is not " "invoked\n" msgstr "" #: src/error/option_unwrap/defaults.md:107 msgid "\"should_be_apple is: {:?}\"" msgstr "" #: src/error/option_unwrap/defaults.md:108 msgid "\"my_apple is unchanged: {:?}\"" msgstr "" #: src/error/option_unwrap/defaults.md:109 msgid "" "// The output is a follows. Note that the closure `get_lemon_as_fallback` is " "not invoked\n" " // should_be_apple is: Apple\n" " // my_apple is unchanged: Some(Apple)\n" msgstr "" #: src/error/option_unwrap/defaults.md:117 msgid "" "[`closures`](https://doc.rust-lang.org/book/ch13-01-closures.html), " "[`get_or_insert`](https://doc.rust-lang.org/core/option/enum.Option." "html#method.get_or_insert), [`get_or_insert_with`](https://doc.rust-lang.org/" "core/option/enum.Option.html#method.get_or_insert_with), [`moved variables`]" "(https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html), " "[`or`](https://doc.rust-lang.org/core/option/enum.Option.html#method.or), " "[`or_else`](https://doc.rust-lang.org/core/option/enum.Option.html#method." "or_else)" msgstr "" #: src/error/result.md:3 msgid "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) is a " "richer version of the [`Option`](https://doc.rust-lang.org/std/option/enum." "Option.html) type that describes possible _error_ instead of possible " "_absence_." msgstr "" #: src/error/result.md:6 msgid "That is, `Result` could have one of two outcomes:" msgstr "" #: src/error/result.md:8 msgid "`Ok(T)`: An element `T` was found" msgstr "" #: src/error/result.md:9 msgid "`Err(E)`: An error was found with element `E`" msgstr "" #: src/error/result.md:11 msgid "" "By convention, the expected outcome is `Ok` while the unexpected outcome is " "`Err`." msgstr "" #: src/error/result.md:13 msgid "" "Like `Option`, `Result` has many methods associated with it. `unwrap()`, for " "example, either yields the element `T` or `panic`s. For case handling, there " "are many combinators between `Result` and `Option` that overlap." msgstr "" #: src/error/result.md:17 msgid "" "In working with Rust, you will likely encounter methods that return the " "`Result` type, such as the [`parse()`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) method. It might not always be possible to " "parse a string into the other type, so `parse()` returns a `Result` " "indicating possible failure." msgstr "" #: src/error/result.md:22 msgid "" "Let's see what happens when we successfully and unsuccessfully `parse()` a " "string:" msgstr "" #: src/error/result.md:26 msgid "// Let's try using `unwrap()` to get the number out. Will it bite us?\n" msgstr "" #: src/error/result.md:33 src/error/result.md:36 #: src/error/result/result_map.md:42 src/error/result/result_map.md:46 #: src/error/result/result_map.md:75 src/error/result/result_map.md:79 #: src/error/result/result_alias.md:36 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:36 src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:67 #: src/error/result/enter_question_mark.md:68 msgid "\"2\"" msgstr "" #: src/error/result.md:34 src/error/result.md:37 msgid "\"double is {}\"" msgstr "" #: src/error/result.md:36 src/error/result/result_map.md:46 #: src/error/result/result_map.md:79 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:68 msgid "\"t\"" msgstr "" #: src/error/result.md:41 msgid "" "In the unsuccessful case, `parse()` leaves us with an error for `unwrap()` " "to `panic` on. Additionally, the `panic` exits our program and provides an " "unpleasant error message." msgstr "" #: src/error/result.md:45 msgid "" "To improve the quality of our error message, we should be more specific " "about the return type and consider explicitly handling the error." msgstr "" #: src/error/result.md:48 msgid "Using `Result` in `main`" msgstr "" #: src/error/result.md:50 msgid "" "The `Result` type can also be the return type of the `main` function if " "specified explicitly. Typically the `main` function will be of the form:" msgstr "" #: src/error/result.md:59 msgid "" "However `main` is also able to have a return type of `Result`. If an error " "occurs within the `main` function it will return an error code and print a " "debug representation of the error (using the [`Debug`](https://doc.rust-lang." "org/std/fmt/trait.Debug.html) trait). The following example shows such a " "scenario and touches on aspects covered in [the following section](result/" "early_returns.md)." msgstr "" #: src/error/result/result_map.md:3 msgid "" "Panicking in the previous example's `multiply` does not make for robust " "code. Generally, we want to return the error to the caller so it can decide " "what is the right way to respond to errors." msgstr "" #: src/error/result/result_map.md:7 msgid "" "We first need to know what kind of error type we are dealing with. To " "determine the `Err` type, we look to [`parse()`](https://doc.rust-lang.org/" "std/primitive.str.html#method.parse), which is implemented with the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "[`i32`](https://doc.rust-lang.org/std/primitive.i32.html). As a result, the " "`Err` type is specified as [`ParseIntError`](https://doc.rust-lang.org/std/" "num/struct.ParseIntError.html)." msgstr "" #: src/error/result/result_map.md:12 msgid "" "In the example below, the straightforward `match` statement leads to code " "that is overall more cumbersome." msgstr "" #: src/error/result/result_map.md:17 msgid "" "// With the return type rewritten, we use pattern matching without " "`unwrap()`.\n" msgstr "" #: src/error/result/result_map.md:35 src/error/result/result_map.md:68 #: src/error/result/result_alias.md:30 src/error/result/early_returns.md:30 #: src/error/result/enter_question_mark.md:28 #: src/error/result/enter_question_mark.md:61 msgid "\"n is {}\"" msgstr "" #: src/error/result/result_map.md:36 src/error/result/result_map.md:69 #: src/error/result/result_alias.md:31 src/error/result/early_returns.md:31 #: src/error/result/enter_question_mark.md:29 #: src/error/result/enter_question_mark.md:62 #: src/error/multiple_error_types/define_error_type.md:55 #: src/error/multiple_error_types/boxing_errors.md:42 #: src/error/multiple_error_types/reenter_question_mark.md:54 #: src/error/multiple_error_types/wrap_error.md:68 msgid "\"Error: {}\"" msgstr "" #: src/error/result/result_map.md:41 src/error/result/result_map.md:74 msgid "// This still presents a reasonable answer.\n" msgstr "" #: src/error/result/result_map.md:45 src/error/result/result_map.md:78 msgid "// The following now provides a much more helpful error message.\n" msgstr "" #: src/error/result/result_map.md:51 msgid "" "Luckily, `Option`'s `map`, `and_then`, and many other combinators are also " "implemented for `Result`. [`Result`](https://doc.rust-lang.org/std/result/" "enum.Result.html) contains a complete listing." msgstr "" #: src/error/result/result_map.md:56 msgid "" "// As with `Option`, we can use combinators such as `map()`.\n" "// This function is otherwise identical to the one above and reads:\n" "// Multiply if both values can be parsed from str, otherwise pass on the " "error.\n" msgstr "" #: src/error/result/result_alias.md:3 msgid "" "How about when we want to reuse a specific `Result` type many times? Recall " "that Rust allows us to create [aliases](../../types/alias.md). Conveniently, " "we can define one for the specific `Result` in question." msgstr "" #: src/error/result/result_alias.md:7 msgid "" "At a module level, creating aliases can be particularly helpful. Errors " "found in a specific module often have the same `Err` type, so a single alias " "can succinctly define _all_ associated `Results`. This is so useful that the " "`std` library even supplies one: [`io::Result`](https://doc.rust-lang.org/" "std/io/type.Result.html)!" msgstr "" #: src/error/result/result_alias.md:12 msgid "Here's a quick example to show off the syntax:" msgstr "" #: src/error/result/result_alias.md:16 msgid "" "// Define a generic alias for a `Result` with the error type " "`ParseIntError`.\n" msgstr "" #: src/error/result/result_alias.md:19 msgid "// Use the above alias to refer to our specific `Result` type.\n" msgstr "" #: src/error/result/result_alias.md:26 msgid "// Here, the alias again allows us to save some space.\n" msgstr "" #: src/error/result/result_alias.md:43 msgid "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" msgstr "" #: src/error/result/early_returns.md:3 msgid "" "In the previous example, we explicitly handled the errors using combinators. " "Another way to deal with this case analysis is to use a combination of " "`match` statements and _early returns_." msgstr "" #: src/error/result/early_returns.md:7 msgid "" "That is, we can simply stop executing the function and return the error if " "one occurs. For some, this form of code can be easier to both read and " "write. Consider this version of the previous example, rewritten using early " "returns:" msgstr "" #: src/error/result/early_returns.md:41 msgid "" "At this point, we've learned to explicitly handle errors using combinators " "and early returns. While we generally want to avoid panicking, explicitly " "handling all of our errors is cumbersome." msgstr "" #: src/error/result/early_returns.md:45 msgid "" "In the next section, we'll introduce `?` for the cases where we simply need " "to `unwrap` without possibly inducing `panic`." msgstr "" #: src/error/result/enter_question_mark.md:3 msgid "" "Sometimes we just want the simplicity of `unwrap` without the possibility of " "a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when " "what we really wanted was to get the variable _out_. This is exactly the " "purpose of `?`." msgstr "" #: src/error/result/enter_question_mark.md:7 msgid "Upon finding an `Err`, there are two valid actions to take:" msgstr "" #: src/error/result/enter_question_mark.md:9 msgid "`panic!` which we already decided to try to avoid if possible" msgstr "" #: src/error/result/enter_question_mark.md:10 msgid "`return` because an `Err` means it cannot be handled" msgstr "" #: src/error/result/enter_question_mark.md:12 msgid "" "`?` is _almost_[^†] exactly equivalent to an `unwrap` which `return`s " "instead of `panic`king on `Err`s. Let's see how we can simplify the earlier " "example that used combinators:" msgstr "" #: src/error/result/enter_question_mark.md:39 msgid "The `try!` macro" msgstr "" #: src/error/result/enter_question_mark.md:41 msgid "" "Before there was `?`, the same functionality was achieved with the `try!` " "macro. The `?` operator is now recommended, but you may still find `try!` " "when looking at older code. The same `multiply` function from the previous " "example would look like this using `try!`:" msgstr "" #: src/error/result/enter_question_mark.md:47 msgid "" "// To compile and run this example without errors, while using Cargo, change " "the value \n" "// of the `edition` field, in the `[package]` section of the `Cargo.toml` " "file, to \"2015\".\n" msgstr "" #: src/error/result/enter_question_mark.md:72 msgid "" "See [re-enter ?](../multiple_error_types/reenter_question_mark.md) for more " "details." msgstr "" #: src/error/multiple_error_types.md:3 msgid "" "The previous examples have always been very convenient; `Result`s interact " "with other `Result`s and `Option`s interact with other `Option`s." msgstr "" #: src/error/multiple_error_types.md:6 msgid "" "Sometimes an `Option` needs to interact with a `Result`, or a `Result` needs to interact with a `Result`. In those cases, we " "want to manage our different error types in a way that makes them composable " "and easy to interact with." msgstr "" #: src/error/multiple_error_types.md:11 msgid "" "In the following code, two instances of `unwrap` generate different error " "types. `Vec::first` returns an `Option`, while `parse::` returns a " "`Result`:" msgstr "" #: src/error/multiple_error_types.md:17 msgid "// Generate error 1\n" msgstr "" #: src/error/multiple_error_types.md:18 msgid "// Generate error 2\n" msgstr "" #: src/error/multiple_error_types.md:22 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/wrap_error.md:77 src/error/iter_result.md:40 msgid "\"42\"" msgstr "" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"93\"" msgstr "" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"18\"" msgstr "" #: src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"tofu\"" msgstr "" #: src/error/multiple_error_types.md:26 src/error/multiple_error_types.md:28 #: src/error/multiple_error_types.md:31 #: src/error/multiple_error_types/define_error_type.md:54 #: src/error/multiple_error_types/boxing_errors.md:41 #: src/error/multiple_error_types/reenter_question_mark.md:53 #: src/error/multiple_error_types/wrap_error.md:66 msgid "\"The first doubled is {}\"" msgstr "" #: src/error/multiple_error_types.md:29 #: src/error/multiple_error_types/option_result.md:23 msgid "// Error 1: the input vector is empty\n" msgstr "" #: src/error/multiple_error_types.md:32 #: src/error/multiple_error_types/option_result.md:26 msgid "// Error 2: the element doesn't parse to a number\n" msgstr "" #: src/error/multiple_error_types.md:36 msgid "" "Over the next sections, we'll see several strategies for handling these kind " "of problems." msgstr "" #: src/error/multiple_error_types/option_result.md:3 msgid "" "The most basic way of handling mixed error types is to just embed them in " "each other." msgstr "" #: src/error/multiple_error_types/option_result.md:20 #: src/error/multiple_error_types/option_result.md:22 #: src/error/multiple_error_types/option_result.md:25 #: src/error/multiple_error_types/option_result.md:49 #: src/error/multiple_error_types/option_result.md:50 #: src/error/multiple_error_types/option_result.md:51 msgid "\"The first doubled is {:?}\"" msgstr "" #: src/error/multiple_error_types/option_result.md:30 msgid "" "There are times when we'll want to stop processing on errors (like with [`?`]" "(../result/enter_question_mark.md)) but keep going when the `Option` is " "`None`. The `transpose` function comes in handy to swap the `Result` and " "`Option`." msgstr "" #: src/error/multiple_error_types/define_error_type.md:3 msgid "" "Sometimes it simplifies the code to mask all of the different errors with a " "single type of error. We'll show this with a custom error." msgstr "" #: src/error/multiple_error_types/define_error_type.md:6 msgid "" "Rust allows us to define our own error types. In general, a \"good\" error " "type:" msgstr "" #: src/error/multiple_error_types/define_error_type.md:8 msgid "Represents different errors with the same type" msgstr "" #: src/error/multiple_error_types/define_error_type.md:9 msgid "Presents nice error messages to the user" msgstr "" #: src/error/multiple_error_types/define_error_type.md:10 msgid "Is easy to compare with other types" msgstr "" #: src/error/multiple_error_types/define_error_type.md:11 msgid "Good: `Err(EmptyVec)`" msgstr "" #: src/error/multiple_error_types/define_error_type.md:12 msgid "" "Bad: `Err(\"Please use a vector with at least one element\".to_owned())`" msgstr "" #: src/error/multiple_error_types/define_error_type.md:13 msgid "Can hold information about the error" msgstr "" #: src/error/multiple_error_types/define_error_type.md:14 msgid "Good: `Err(BadChar(c, position))`" msgstr "" #: src/error/multiple_error_types/define_error_type.md:15 msgid "Bad: `Err(\"+ cannot be used here\".to_owned())`" msgstr "" #: src/error/multiple_error_types/define_error_type.md:16 msgid "Composes well with other errors" msgstr "" #: src/error/multiple_error_types/define_error_type.md:22 msgid "" "// Define our error types. These may be customized for our error handling " "cases.\n" "// Now we will be able to write our own errors, defer to an underlying " "error\n" "// implementation, or do something in between.\n" msgstr "" #: src/error/multiple_error_types/define_error_type.md:28 msgid "" "// Generation of an error is completely separate from how it is displayed.\n" "// There's no need to be concerned about cluttering complex logic with the " "display style.\n" "//\n" "// Note that we don't store any extra info about the errors. This means we " "can't state\n" "// which string failed to parse without modifying our types to carry that " "information.\n" msgstr "" #: src/error/multiple_error_types/define_error_type.md:36 #: src/error/multiple_error_types/boxing_errors.md:23 #: src/error/multiple_error_types/reenter_question_mark.md:37 msgid "\"invalid first item to double\"" msgstr "" #: src/error/multiple_error_types/define_error_type.md:42 msgid "// Change the error to our new type.\n" msgstr "" #: src/error/multiple_error_types/define_error_type.md:46 msgid "// Update to the new error type here also.\n" msgstr "" #: src/error/multiple_error_types/boxing_errors.md:3 msgid "" "A way to write simple code while preserving the original errors is to [`Box`]" "(https://doc.rust-lang.org/std/boxed/struct.Box.html) them. The drawback is " "that the underlying error type is only known at runtime and not [statically " "determined](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-" "objects-perform-dynamic-dispatch)." msgstr "" #: src/error/multiple_error_types/boxing_errors.md:7 msgid "" "The stdlib helps in boxing our errors by having `Box` implement conversion " "from any type that implements the `Error` trait into the trait object " "`Box`, via [`From`](https://doc.rust-lang.org/std/convert/trait.From." "html)." msgstr "" #: src/error/multiple_error_types/boxing_errors.md:14 #: src/error/multiple_error_types/reenter_question_mark.md:28 msgid "// Change the alias to use `Box`.\n" msgstr "" #: src/error/multiple_error_types/boxing_errors.md:31 #: src/error/multiple_error_types/boxing_errors.md:34 msgid "// Converts to Box\n" msgstr "" #: src/error/multiple_error_types/boxing_errors.md:59 msgid "" "[Dynamic dispatch](https://doc.rust-lang.org/book/ch17-02-trait-objects." "html#trait-objects-perform-dynamic-dispatch) and [`Error` trait](https://doc." "rust-lang.org/std/error/trait.Error.html)" msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:3 msgid "" "Notice in the previous example that our immediate reaction to calling " "`parse` is to `map` the error from a library error into a boxed error:" msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:12 msgid "" "Since this is a simple and common operation, it would be convenient if it " "could be elided. Alas, because `and_then` is not sufficiently flexible, it " "cannot. However, we can instead use `?`." msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:16 msgid "" "`?` was previously explained as either `unwrap` or `return Err(err)`. This " "is only mostly true. It actually means `unwrap` or `return Err(From::" "from(err))`. Since `From::from` is a conversion utility between different " "types, this means that if you `?` where the error is convertible to the " "return type, it will convert automatically." msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:22 msgid "" "Here, we rewrite the previous example using `?`. As a result, the `map_err` " "will go away when `From::from` is implemented for our error type:" msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:42 msgid "" "// The same structure as before but rather than chain all `Results`\n" "// and `Options` along, we `?` to get the inner value out immediately.\n" msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:69 msgid "" "This is actually fairly clean now. Compared with the original `panic`, it is " "very similar to replacing the `unwrap` calls with `?` except that the return " "types are `Result`. As a result, they must be destructured at the top level." msgstr "" #: src/error/multiple_error_types/reenter_question_mark.md:76 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`?" "`](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" msgstr "" #: src/error/multiple_error_types/wrap_error.md:3 msgid "An alternative to boxing errors is to wrap them in your own error type." msgstr "" #: src/error/multiple_error_types/wrap_error.md:16 msgid "" "// We will defer to the parse error implementation for their error.\n" " // Supplying extra info requires adding more data to the type.\n" msgstr "" #: src/error/multiple_error_types/wrap_error.md:25 msgid "\"please use a vector with at least one element\"" msgstr "" #: src/error/multiple_error_types/wrap_error.md:26 msgid "" "// The wrapped error contains additional information and is available\n" " // via the source() method.\n" msgstr "" #: src/error/multiple_error_types/wrap_error.md:29 msgid "\"the provided string could not be parsed as int\"" msgstr "" #: src/error/multiple_error_types/wrap_error.md:38 msgid "" "// The cause is the underlying implementation error type. Is implicitly\n" " // cast to the trait object `&error::Error`. This works because " "the\n" " // underlying type already implements the `Error` trait.\n" msgstr "" #: src/error/multiple_error_types/wrap_error.md:45 msgid "" "// Implement the conversion from `ParseIntError` to `DoubleError`.\n" "// This will be automatically called by `?` if a `ParseIntError`\n" "// needs to be converted into a `DoubleError`.\n" msgstr "" #: src/error/multiple_error_types/wrap_error.md:57 msgid "" "// Here we implicitly use the `ParseIntError` implementation of `From` " "(which\n" " // we defined above) in order to create a `DoubleError`.\n" msgstr "" #: src/error/multiple_error_types/wrap_error.md:70 msgid "\" Caused by: {}\"" msgstr "" #: src/error/multiple_error_types/wrap_error.md:87 msgid "" "This adds a bit more boilerplate for handling errors and might not be needed " "in all applications. There are some libraries that can take care of the " "boilerplate for you." msgstr "" #: src/error/multiple_error_types/wrap_error.md:93 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Enums`](../../custom_types/enum.md)" msgstr "" #: src/error/multiple_error_types/wrap_error.md:95 msgid "" "[`Crates for handling errors`](https://crates.io/keywords/error-handling)" msgstr "" #: src/error/iter_result.md:3 msgid "An `Iter::map` operation might fail, for example:" msgstr "" #: src/error/iter_result.md:12 src/error/iter_result.md:29 #: src/error/iter_result.md:65 msgid "\"Results: {:?}\"" msgstr "" #: src/error/iter_result.md:16 msgid "Let's step through strategies for handling this." msgstr "" #: src/error/iter_result.md:18 msgid "Ignore the failed items with `filter_map()`" msgstr "" #: src/error/iter_result.md:20 msgid "" "`filter_map` calls a function and filters out the results that are `None`." msgstr "" #: src/error/iter_result.md:33 msgid "Collect the failed items with `map_err()` and `filter_map()`" msgstr "" #: src/error/iter_result.md:35 msgid "" "`map_err` calls a function with the error, so by adding that to the previous " "`filter_map` solution we can save them off to the side while iterating." msgstr "" #: src/error/iter_result.md:40 msgid "\"999\"" msgstr "" #: src/error/iter_result.md:47 src/error/iter_result.md:80 #: src/error/iter_result.md:97 msgid "\"Numbers: {:?}\"" msgstr "" #: src/error/iter_result.md:48 src/error/iter_result.md:81 #: src/error/iter_result.md:98 msgid "\"Errors: {:?}\"" msgstr "" #: src/error/iter_result.md:52 msgid "Fail the entire operation with `collect()`" msgstr "" #: src/error/iter_result.md:54 msgid "" "`Result` implements `FromIterator` so that a vector of results " "(`Vec>`) can be turned into a result with a vector " "(`Result, E>`). Once an `Result::Err` is found, the iteration will " "terminate." msgstr "" #: src/error/iter_result.md:69 msgid "This same technique can be used with `Option`." msgstr "" #: src/error/iter_result.md:71 msgid "Collect all valid values and failures with `partition()`" msgstr "" #: src/error/iter_result.md:85 msgid "" "When you look at the results, you'll note that everything is still wrapped " "in `Result`. A little more boilerplate is needed for this." msgstr "" #: src/std.md:3 msgid "" "The `std` library provides many custom types which expands drastically on " "the `primitives`. Some of these include:" msgstr "" #: src/std.md:6 msgid "growable `String`s like: `\"hello world\"`" msgstr "" #: src/std.md:7 msgid "growable vectors: `[1, 2, 3]`" msgstr "" #: src/std.md:8 msgid "optional types: `Option`" msgstr "" #: src/std.md:9 msgid "error handling types: `Result`" msgstr "" #: src/std.md:10 msgid "heap allocated pointers: `Box`" msgstr "" #: src/std.md:14 src/std_misc.md:14 msgid "" "[primitives](primitives.md) and [the std library](https://doc.rust-lang.org/" "std/)" msgstr "" #: src/std/box.md:3 msgid "" "All values in Rust are stack allocated by default. Values can be _boxed_ " "(allocated on the heap) by creating a `Box`. A box is a smart pointer to " "a heap allocated value of type `T`. When a box goes out of scope, its " "destructor is called, the inner object is destroyed, and the memory on the " "heap is freed." msgstr "" #: src/std/box.md:8 msgid "" "Boxed values can be dereferenced using the `*` operator; this removes one " "layer of indirection." msgstr "" #: src/std/box.md:20 msgid "" "// A Rectangle can be specified by where its top left and bottom right \n" "// corners are in space\n" msgstr "" #: src/std/box.md:34 msgid "// Allocate this point on the heap, and return a pointer to it\n" msgstr "" #: src/std/box.md:39 msgid "" "// (all the type annotations are superfluous)\n" " // Stack allocated variables\n" msgstr "" #: src/std/box.md:47 msgid "// Heap allocated rectangle\n" msgstr "" #: src/std/box.md:53 msgid "// The output of functions can be boxed\n" msgstr "" #: src/std/box.md:56 msgid "// Double indirection\n" msgstr "" #: src/std/box.md:59 msgid "\"Point occupies {} bytes on the stack\"" msgstr "" #: src/std/box.md:61 msgid "\"Rectangle occupies {} bytes on the stack\"" msgstr "" #: src/std/box.md:64 msgid "// box size == pointer size\n" msgstr "" #: src/std/box.md:65 msgid "\"Boxed point occupies {} bytes on the stack\"" msgstr "" #: src/std/box.md:67 msgid "\"Boxed rectangle occupies {} bytes on the stack\"" msgstr "" #: src/std/box.md:69 msgid "\"Boxed box occupies {} bytes on the stack\"" msgstr "" #: src/std/box.md:72 msgid "// Copy the data contained in `boxed_point` into `unboxed_point`\n" msgstr "" #: src/std/box.md:74 msgid "\"Unboxed point occupies {} bytes on the stack\"" msgstr "" #: src/std/vec.md:3 msgid "" "Vectors are re-sizable arrays. Like slices, their size is not known at " "compile time, but they can grow or shrink at any time. A vector is " "represented using 3 parameters:" msgstr "" #: src/std/vec.md:7 msgid "pointer to the data" msgstr "" #: src/std/vec.md:8 msgid "length" msgstr "" #: src/std/vec.md:9 msgid "capacity" msgstr "" #: src/std/vec.md:11 msgid "" "The capacity indicates how much memory is reserved for the vector. The " "vector can grow as long as the length is smaller than the capacity. When " "this threshold needs to be surpassed, the vector is reallocated with a " "larger capacity." msgstr "" #: src/std/vec.md:17 msgid "// Iterators can be collected into vectors\n" msgstr "" #: src/std/vec.md:19 msgid "\"Collected (0..10) into: {:?}\"" msgstr "" #: src/std/vec.md:21 msgid "// The `vec!` macro can be used to initialize a vector\n" msgstr "" #: src/std/vec.md:23 msgid "\"Initial vector: {:?}\"" msgstr "" #: src/std/vec.md:25 msgid "// Insert new element at the end of the vector\n" msgstr "" #: src/std/vec.md:26 msgid "\"Push 4 into the vector\"" msgstr "" #: src/std/vec.md:28 msgid "\"Vector: {:?}\"" msgstr "" #: src/std/vec.md:30 msgid "// Error! Immutable vectors can't grow\n" msgstr "" #: src/std/vec.md:34 msgid "" "// The `len` method yields the number of elements currently stored in a " "vector\n" msgstr "" #: src/std/vec.md:35 msgid "\"Vector length: {}\"" msgstr "" #: src/std/vec.md:37 msgid "// Indexing is done using the square brackets (indexing starts at 0)\n" msgstr "" #: src/std/vec.md:38 msgid "\"Second element: {}\"" msgstr "" #: src/std/vec.md:40 msgid "// `pop` removes the last element from the vector and returns it\n" msgstr "" #: src/std/vec.md:41 msgid "\"Pop last element: {:?}\"" msgstr "" #: src/std/vec.md:43 msgid "// Out of bounds indexing yields a panic\n" msgstr "" #: src/std/vec.md:44 msgid "\"Fourth element: {}\"" msgstr "" #: src/std/vec.md:47 msgid "// `Vector`s can be easily iterated over\n" msgstr "" #: src/std/vec.md:48 msgid "\"Contents of xs:\"" msgstr "" #: src/std/vec.md:53 msgid "" "// A `Vector` can also be iterated over while the iteration\n" " // count is enumerated in a separate variable (`i`)\n" msgstr "" #: src/std/vec.md:56 msgid "\"In position {} we have value {}\"" msgstr "" #: src/std/vec.md:59 msgid "" "// Thanks to `iter_mut`, mutable `Vector`s can also be iterated\n" " // over in a way that allows modifying each value\n" msgstr "" #: src/std/vec.md:64 msgid "\"Updated vector: {:?}\"" msgstr "" #: src/std/vec.md:68 msgid "" "More `Vec` methods can be found under the [std::vec](https://doc.rust-lang." "org/std/vec/) module" msgstr "" #: src/std/str.md:3 msgid "The two most used string types in Rust are `String` and `&str`." msgstr "" #: src/std/str.md:5 msgid "" "A `String` is stored as a vector of bytes (`Vec`), but guaranteed to " "always be a valid UTF-8 sequence. `String` is heap allocated, growable and " "not null terminated." msgstr "" #: src/std/str.md:9 msgid "" "`&str` is a slice (`&[u8]`) that always points to a valid UTF-8 sequence, " "and can be used to view into a `String`, just like `&[T]` is a view into " "`Vec`." msgstr "" #: src/std/str.md:14 msgid "" "// (all the type annotations are superfluous)\n" " // A reference to a string allocated in read only memory\n" msgstr "" #: src/std/str.md:16 msgid "\"the quick brown fox jumps over the lazy dog\"" msgstr "" #: src/std/str.md:17 msgid "\"Pangram: {}\"" msgstr "" #: src/std/str.md:19 msgid "// Iterate over words in reverse, no new string is allocated\n" msgstr "" #: src/std/str.md:20 msgid "\"Words in reverse\"" msgstr "" #: src/std/str.md:25 msgid "// Copy chars into a vector, sort and remove duplicates\n" msgstr "" #: src/std/str.md:30 msgid "// Create an empty and growable `String`\n" msgstr "" #: src/std/str.md:33 msgid "// Insert a char at the end of string\n" msgstr "" #: src/std/str.md:35 msgid "// Insert a string at the end of string\n" msgstr "" #: src/std/str.md:39 msgid "" "// The trimmed string is a slice to the original string, hence no new\n" " // allocation is performed\n" msgstr "" #: src/std/str.md:43 msgid "\"Used characters: {}\"" msgstr "" #: src/std/str.md:45 msgid "// Heap allocate a string\n" msgstr "" #: src/std/str.md:46 msgid "\"I like dogs\"" msgstr "" #: src/std/str.md:47 msgid "// Allocate new memory and store the modified string there\n" msgstr "" #: src/std/str.md:48 msgid "\"dog\"" msgstr "" #: src/std/str.md:48 msgid "\"cat\"" msgstr "" #: src/std/str.md:50 msgid "\"Alice says: {}\"" msgstr "" #: src/std/str.md:51 msgid "\"Bob says: {}\"" msgstr "" #: src/std/str.md:55 msgid "" "More `str`/`String` methods can be found under the [std::str](https://doc." "rust-lang.org/std/str/) and [std::string](https://doc.rust-lang.org/std/" "string/) modules" msgstr "" #: src/std/str.md:60 msgid "Literals and escapes" msgstr "" #: src/std/str.md:62 msgid "" "There are multiple ways to write string literals with special characters in " "them. All result in a similar `&str` so it's best to use the form that is " "the most convenient to write. Similarly there are multiple ways to write " "byte string literals, which all result in `&[u8; N]`." msgstr "" #: src/std/str.md:67 msgid "" "Generally special characters are escaped with a backslash character: `\\`. " "This way you can add any character to your string, even unprintable ones and " "ones that you don't know how to type. If you want a literal backslash, " "escape it with another one: `\\\\`" msgstr "" #: src/std/str.md:72 msgid "" "String or character literal delimiters occurring within a literal must be " "escaped: `\"\\\"\"`, `'\\''`." msgstr "" #: src/std/str.md:76 msgid "// You can use escapes to write bytes by their hexadecimal values...\n" msgstr "" #: src/std/str.md:77 msgid "\"I'm writing \\x52\\x75\\x73\\x74!\"" msgstr "" #: src/std/str.md:78 msgid "\"What are you doing\\x3F (\\\\x3F means ?) {}\"" msgstr "" #: src/std/str.md:80 msgid "// ...or Unicode code points.\n" msgstr "" #: src/std/str.md:81 msgid "\"\\u{211D}\"" msgstr "" #: src/std/str.md:82 msgid "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\"" msgstr "" #: src/std/str.md:84 msgid "\"Unicode character {} (U+211D) is called {}\"" msgstr "" #: src/std/str.md:88 msgid "" "\"String literals\n" " can span multiple lines.\n" " The linebreak and indentation here ->\\\n" " <- can be escaped too!\"" msgstr "" #: src/std/str.md:96 msgid "" "Sometimes there are just too many characters that need to be escaped or it's " "just much more convenient to write a string out as-is. This is where raw " "string literals come into play." msgstr "" #: src/std/str.md:101 msgid "r\"Escapes don't work here: \\x3F \\u{211D}\"" msgstr "" #: src/std/str.md:104 msgid "// If you need quotes in a raw string, add a pair of #s\n" msgstr "" #: src/std/str.md:105 msgid "r#\"And then I said: \"There is no escape!\"\"#" msgstr "" #: src/std/str.md:108 msgid "" "// If you need \"# in your string, just use more #s in the delimiter.\n" " // You can use up to 255 #s.\n" msgstr "" #: src/std/str.md:110 msgid "r###\"A string with \"# in it. And even \"##!\"###" msgstr "" #: src/std/str.md:115 msgid "" "Want a string that's not UTF-8? (Remember, `str` and `String` must be valid " "UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings " "to the rescue!" msgstr "" #: src/std/str.md:122 msgid "// Note that this is not actually a `&str`\n" msgstr "" #: src/std/str.md:123 msgid "b\"this is a byte string\"" msgstr "" #: src/std/str.md:125 msgid "" "// Byte arrays don't have the `Display` trait, so printing them is a bit " "limited\n" msgstr "" #: src/std/str.md:126 msgid "\"A byte string: {:?}\"" msgstr "" #: src/std/str.md:128 msgid "// Byte strings can have byte escapes...\n" msgstr "" #: src/std/str.md:129 msgid "b\"\\x52\\x75\\x73\\x74 as bytes\"" msgstr "" #: src/std/str.md:130 msgid "" "// ...but no unicode escapes\n" " // let escaped = b\"\\u{211D} is not allowed\";\n" msgstr "" #: src/std/str.md:132 msgid "\"Some escaped bytes: {:?}\"" msgstr "" #: src/std/str.md:135 msgid "// Raw byte strings work just like raw strings\n" msgstr "" #: src/std/str.md:136 msgid "br\"\\u{211D} is not escaped here\"" msgstr "" #: src/std/str.md:139 msgid "// Converting a byte array to `str` can fail\n" msgstr "" #: src/std/str.md:141 msgid "\"And the same as text: '{}'\"" msgstr "" #: src/std/str.md:144 msgid "" "br#\"You can also use \"fancier\" formatting, \\\n" " like with normal raw strings\"#" msgstr "" #: src/std/str.md:147 msgid "// Byte strings don't have to be UTF-8\n" msgstr "" #: src/std/str.md:148 msgid "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" msgstr "" #: src/std/str.md:148 msgid "// \"ようこそ\" in SHIFT-JIS\n" msgstr "" #: src/std/str.md:150 msgid "// But then they can't always be converted to `str`\n" msgstr "" #: src/std/str.md:152 msgid "\"Conversion successful: '{}'\"" msgstr "" #: src/std/str.md:153 msgid "\"Conversion failed: {:?}\"" msgstr "" #: src/std/str.md:158 msgid "" "For conversions between character encodings check out the [encoding](https://" "crates.io/crates/encoding) crate." msgstr "" #: src/std/str.md:160 msgid "" "A more detailed listing of the ways to write string literals and escape " "characters is given in the ['Tokens' chapter](https://doc.rust-lang.org/" "reference/tokens.html) of the Rust Reference." msgstr "" #: src/std/option.md:3 msgid "" "Sometimes it's desirable to catch the failure of some parts of a program " "instead of calling `panic!`; this can be accomplished using the `Option` " "enum." msgstr "" #: src/std/option.md:6 msgid "The `Option` enum has two variants:" msgstr "" #: src/std/option.md:8 msgid "`None`, to indicate failure or lack of value, and" msgstr "" #: src/std/option.md:9 msgid "`Some(value)`, a tuple struct that wraps a `value` with type `T`." msgstr "" #: src/std/option.md:12 msgid "// An integer division that doesn't `panic!`\n" msgstr "" #: src/std/option.md:15 msgid "// Failure is represented as the `None` variant\n" msgstr "" #: src/std/option.md:18 msgid "// Result is wrapped in a `Some` variant\n" msgstr "" #: src/std/option.md:22 msgid "// This function handles a division that may not succeed\n" msgstr "" #: src/std/option.md:25 msgid "// `Option` values can be pattern matched, just like other enums\n" msgstr "" #: src/std/option.md:27 msgid "\"{} / {} failed!\"" msgstr "" #: src/std/option.md:29 msgid "\"{} / {} = {}\"" msgstr "" #: src/std/option.md:38 msgid "// Binding `None` to a variable needs to be type annotated\n" msgstr "" #: src/std/option.md:44 msgid "// Unwrapping a `Some` variant will extract the value wrapped.\n" msgstr "" #: src/std/option.md:45 src/std/option.md:48 msgid "\"{:?} unwraps to {:?}\"" msgstr "" #: src/std/option.md:47 msgid "// Unwrapping a `None` variant will `panic!`\n" msgstr "" #: src/std/result.md:3 msgid "" "We've seen that the `Option` enum can be used as a return value from " "functions that may fail, where `None` can be returned to indicate failure. " "However, sometimes it is important to express _why_ an operation failed. To " "do this we have the `Result` enum." msgstr "" #: src/std/result.md:8 msgid "The `Result` enum has two variants:" msgstr "" #: src/std/result.md:10 msgid "" "`Ok(value)` which indicates that the operation succeeded, and wraps the " "`value` returned by the operation. (`value` has type `T`)" msgstr "" #: src/std/result.md:12 msgid "" "`Err(why)`, which indicates that the operation failed, and wraps `why`, " "which (hopefully) explains the cause of the failure. (`why` has type `E`)" msgstr "" #: src/std/result.md:17 msgid "// Mathematical \"errors\" we want to catch\n" msgstr "" #: src/std/result.md:29 msgid "" "// This operation would `fail`, instead let's return the reason of\n" " // the failure wrapped in `Err`\n" msgstr "" #: src/std/result.md:33 msgid "// This operation is valid, return the result wrapped in `Ok`\n" msgstr "" #: src/std/result.md:54 msgid "// `op(x, y)` === `sqrt(ln(x / y))`\n" msgstr "" #: src/std/result.md:57 msgid "// This is a three level match pyramid!\n" msgstr "" #: src/std/result.md:71 msgid "// Will this fail?\n" msgstr "" #: src/std/result/question_mark.md:3 msgid "" "Chaining results using match can get pretty untidy; luckily, the `?` " "operator can be used to make things pretty again. `?` is used at the end of " "an expression returning a `Result`, and is equivalent to a match expression, " "where the `Err(err)` branch expands to an early `return Err(From::" "from(err))`, and the `Ok(ok)` branch expands to an `ok` expression." msgstr "" #: src/std/result/question_mark.md:44 msgid "// Intermediate function\n" msgstr "" #: src/std/result/question_mark.md:46 msgid "// if `div` \"fails\", then `DivisionByZero` will be `return`ed\n" msgstr "" #: src/std/result/question_mark.md:49 msgid "// if `ln` \"fails\", then `NonPositiveLogarithm` will be `return`ed\n" msgstr "" #: src/std/result/question_mark.md:59 msgid "\"logarithm of non-positive number\"" msgstr "" #: src/std/result/question_mark.md:61 src/std/panic.md:15 msgid "\"division by zero\"" msgstr "" #: src/std/result/question_mark.md:63 msgid "\"square root of negative number\"" msgstr "" #: src/std/result/question_mark.md:75 msgid "" "Be sure to check the [documentation](https://doc.rust-lang.org/std/result/" "index.html), as there are many methods to map/compose `Result`." msgstr "" #: src/std/panic.md:3 msgid "" "The `panic!` macro can be used to generate a panic and start unwinding its " "stack. While unwinding, the runtime will take care of freeing all the " "resources _owned_ by the thread by calling the destructor of all its objects." msgstr "" #: src/std/panic.md:7 msgid "" "Since we are dealing with programs with only one thread, `panic!` will cause " "the program to report the panic message and exit." msgstr "" #: src/std/panic.md:11 msgid "// Re-implementation of integer division (/)\n" msgstr "" #: src/std/panic.md:14 msgid "// Division by zero triggers a panic\n" msgstr "" #: src/std/panic.md:20 msgid "// The `main` task\n" msgstr "" #: src/std/panic.md:23 msgid "// Heap allocated integer\n" msgstr "" #: src/std/panic.md:26 msgid "// This operation will trigger a task failure\n" msgstr "" #: src/std/panic.md:29 msgid "\"This point won't be reached!\"" msgstr "" #: src/std/panic.md:31 msgid "// `_x` should get destroyed at this point\n" msgstr "" #: src/std/panic.md:35 msgid "Let's check that `panic!` doesn't leak memory." msgstr "" #: src/std/hash.md:3 msgid "" "Where vectors store values by an integer index, `HashMap`s store values by " "key. `HashMap` keys can be booleans, integers, strings, or any other type " "that implements the `Eq` and `Hash` traits. More on this in the next section." msgstr "" #: src/std/hash.md:8 msgid "" "Like vectors, `HashMap`s are growable, but HashMaps can also shrink " "themselves when they have excess space. You can create a HashMap with a " "certain starting capacity using `HashMap::with_capacity(uint)`, or use " "`HashMap::new()` to get a HashMap with a default initial capacity " "(recommended)." msgstr "" #: src/std/hash.md:19 src/std/hash.md:30 msgid "\"798-1364\"" msgstr "" #: src/std/hash.md:19 msgid "" "\"We're sorry, the call cannot be completed as dialed. \n" " Please hang up and try again.\"" msgstr "" #: src/std/hash.md:21 src/std/hash.md:31 msgid "\"645-7689\"" msgstr "" #: src/std/hash.md:21 msgid "" "\"Hello, this is Mr. Awesome's Pizza. My name is Fred.\n" " What can I get for you today?\"" msgstr "" #: src/std/hash.md:23 msgid "\"Hi! Who is this again?\"" msgstr "" #: src/std/hash.md:30 src/std/hash.md:36 src/std/hash.md:43 msgid "\"Daniel\"" msgstr "" #: src/std/hash.md:31 src/std/hash.md:45 src/std/hash.md:50 msgid "\"Ashley\"" msgstr "" #: src/std/hash.md:32 msgid "\"Katie\"" msgstr "" #: src/std/hash.md:32 msgid "\"435-8291\"" msgstr "" #: src/std/hash.md:33 msgid "\"Robert\"" msgstr "" #: src/std/hash.md:33 msgid "\"956-1745\"" msgstr "" #: src/std/hash.md:35 msgid "// Takes a reference and returns Option<&V>\n" msgstr "" #: src/std/hash.md:37 msgid "\"Calling Daniel: {}\"" msgstr "" #: src/std/hash.md:38 msgid "\"Don't have Daniel's number.\"" msgstr "" #: src/std/hash.md:41 msgid "" "// `HashMap::insert()` returns `None`\n" " // if the inserted value is new, `Some(value)` otherwise\n" msgstr "" #: src/std/hash.md:43 msgid "\"164-6743\"" msgstr "" #: src/std/hash.md:46 msgid "\"Calling Ashley: {}\"" msgstr "" #: src/std/hash.md:47 msgid "\"Don't have Ashley's number.\"" msgstr "" #: src/std/hash.md:52 msgid "" "// `HashMap::iter()` returns an iterator that yields \n" " // (&'a key, &'a value) pairs in arbitrary order.\n" msgstr "" #: src/std/hash.md:55 msgid "\"Calling {}: {}\"" msgstr "" #: src/std/hash.md:60 msgid "" "For more information on how hashing and hash maps (sometimes called hash " "tables) work, have a look at [Hash Table Wikipedia](https://en.wikipedia.org/" "wiki/Hash_table)" msgstr "" #: src/std/hash/alt_key_types.md:3 msgid "" "Any type that implements the `Eq` and `Hash` traits can be a key in " "`HashMap`. This includes:" msgstr "" #: src/std/hash/alt_key_types.md:6 msgid "`bool` (though not very useful since there are only two possible keys)" msgstr "" #: src/std/hash/alt_key_types.md:7 msgid "`int`, `uint`, and all variations thereof" msgstr "" #: src/std/hash/alt_key_types.md:8 msgid "" "`String` and `&str` (protip: you can have a `HashMap` keyed by `String` and " "call `.get()` with an `&str`)" msgstr "" #: src/std/hash/alt_key_types.md:11 msgid "" "Note that `f32` and `f64` do _not_ implement `Hash`, likely because " "[floating-point precision errors](https://en.wikipedia.org/wiki/" "Floating_point#Accuracy_problems) would make using them as hashmap keys " "horribly error-prone." msgstr "" #: src/std/hash/alt_key_types.md:15 msgid "" "All collection classes implement `Eq` and `Hash` if their contained type " "also respectively implements `Eq` and `Hash`. For example, `Vec` will " "implement `Hash` if `T` implements `Hash`." msgstr "" #: src/std/hash/alt_key_types.md:19 msgid "" "You can easily implement `Eq` and `Hash` for a custom type with just one " "line: `#[derive(PartialEq, Eq, Hash)]`" msgstr "" #: src/std/hash/alt_key_types.md:22 msgid "" "The compiler will do the rest. If you want more control over the details, " "you can implement `Eq` and/or `Hash` yourself. This guide will not cover the " "specifics of implementing `Hash`." msgstr "" #: src/std/hash/alt_key_types.md:26 msgid "" "To play around with using a `struct` in `HashMap`, let's try making a very " "simple user logon system:" msgstr "" #: src/std/hash/alt_key_types.md:31 msgid "// Eq requires that you derive PartialEq on the type.\n" msgstr "" #: src/std/hash/alt_key_types.md:48 msgid "\"Username: {}\"" msgstr "" #: src/std/hash/alt_key_types.md:49 msgid "\"Password: {}\"" msgstr "" #: src/std/hash/alt_key_types.md:50 msgid "\"Attempting logon...\"" msgstr "" #: src/std/hash/alt_key_types.md:59 msgid "\"Successful logon!\"" msgstr "" #: src/std/hash/alt_key_types.md:60 msgid "\"Name: {}\"" msgstr "" #: src/std/hash/alt_key_types.md:61 msgid "\"Email: {}\"" msgstr "" #: src/std/hash/alt_key_types.md:63 msgid "\"Login failed!\"" msgstr "" #: src/std/hash/alt_key_types.md:71 src/std/hash/alt_key_types.md:82 #: src/std/hash/alt_key_types.md:84 msgid "\"j.everyman\"" msgstr "" #: src/std/hash/alt_key_types.md:72 src/std/hash/alt_key_types.md:84 msgid "\"password123\"" msgstr "" #: src/std/hash/alt_key_types.md:76 msgid "\"John Everyman\"" msgstr "" #: src/std/hash/alt_key_types.md:77 msgid "\"j.everyman@email.com\"" msgstr "" #: src/std/hash/alt_key_types.md:82 msgid "\"psasword123\"" msgstr "" #: src/std/hash/hashset.md:3 msgid "" "Consider a `HashSet` as a `HashMap` where we just care about the keys " "( `HashSet` is, in actuality, just a wrapper around `HashMap`)." msgstr "" #: src/std/hash/hashset.md:6 msgid "" "\"What's the point of that?\" you ask. \"I could just store the keys in a " "`Vec`.\"" msgstr "" #: src/std/hash/hashset.md:8 msgid "" "A `HashSet`'s unique feature is that it is guaranteed to not have duplicate " "elements. That's the contract that any set collection fulfills. `HashSet` is " "just one implementation. (see also: [`BTreeSet`](https://doc.rust-lang.org/" "std/collections/struct.BTreeSet.html))" msgstr "" #: src/std/hash/hashset.md:13 msgid "" "If you insert a value that is already present in the `HashSet`, (i.e. the " "new value is equal to the existing and they both have the same hash), then " "the new value will replace the old." msgstr "" #: src/std/hash/hashset.md:17 msgid "" "This is great for when you never want more than one of something, or when " "you want to know if you've already got something." msgstr "" #: src/std/hash/hashset.md:20 msgid "But sets can do more than that." msgstr "" #: src/std/hash/hashset.md:22 msgid "" "Sets have 4 primary operations (all of the following calls return an " "iterator):" msgstr "" #: src/std/hash/hashset.md:24 msgid "`union`: get all the unique elements in both sets." msgstr "" #: src/std/hash/hashset.md:26 msgid "" "`difference`: get all the elements that are in the first set but not the " "second." msgstr "" #: src/std/hash/hashset.md:28 msgid "`intersection`: get all the elements that are only in _both_ sets." msgstr "" #: src/std/hash/hashset.md:30 msgid "" "`symmetric_difference`: get all the elements that are in one set or the " "other, but _not_ both." msgstr "" #: src/std/hash/hashset.md:33 msgid "Try all of these in the following example:" msgstr "" #: src/std/hash/hashset.md:45 msgid "" "// `HashSet::insert()` returns false if\n" " // there was a value already present.\n" msgstr "" #: src/std/hash/hashset.md:47 msgid "\"Value 4 is already in set B!\"" msgstr "" #: src/std/hash/hashset.md:52 msgid "" "// If a collection's element type implements `Debug`,\n" " // then the collection implements `Debug`.\n" " // It usually prints its elements in the format `[elem1, elem2, ...]`\n" msgstr "" #: src/std/hash/hashset.md:55 msgid "\"A: {:?}\"" msgstr "" #: src/std/hash/hashset.md:56 msgid "\"B: {:?}\"" msgstr "" #: src/std/hash/hashset.md:58 msgid "// Print [1, 2, 3, 4, 5] in arbitrary order\n" msgstr "" #: src/std/hash/hashset.md:59 msgid "\"Union: {:?}\"" msgstr "" #: src/std/hash/hashset.md:61 msgid "// This should print [1]\n" msgstr "" #: src/std/hash/hashset.md:62 msgid "\"Difference: {:?}\"" msgstr "" #: src/std/hash/hashset.md:64 msgid "// Print [2, 3, 4] in arbitrary order.\n" msgstr "" #: src/std/hash/hashset.md:65 msgid "\"Intersection: {:?}\"" msgstr "" #: src/std/hash/hashset.md:67 msgid "// Print [1, 5]\n" msgstr "" #: src/std/hash/hashset.md:68 msgid "\"Symmetric Difference: {:?}\"" msgstr "" #: src/std/hash/hashset.md:73 msgid "" "(Examples are adapted from the [documentation.](https://doc.rust-lang.org/" "std/collections/struct.HashSet.html#method.difference))" msgstr "" #: src/std/rc.md:3 msgid "" "When multiple ownership is needed, `Rc`(Reference Counting) can be used. " "`Rc` keeps track of the number of the references which means the number of " "owners of the value wrapped inside an `Rc`." msgstr "" #: src/std/rc.md:7 msgid "" "Reference count of an `Rc` increases by 1 whenever an `Rc` is cloned, and " "decreases by 1 whenever one cloned `Rc` is dropped out of the scope. When an " "`Rc`'s reference count becomes zero (which means there are no remaining " "owners), both the `Rc` and the value are all dropped." msgstr "" #: src/std/rc.md:12 msgid "" "Cloning an `Rc` never performs a deep copy. Cloning creates just another " "pointer to the wrapped value, and increments the count." msgstr "" #: src/std/rc.md:19 msgid "\"Rc examples\"" msgstr "" #: src/std/rc.md:21 msgid "\"--- rc_a is created ---\"" msgstr "" #: src/std/rc.md:24 src/std/rc.md:31 src/std/rc.md:43 msgid "\"Reference Count of rc_a: {}\"" msgstr "" #: src/std/rc.md:27 msgid "\"--- rc_a is cloned to rc_b ---\"" msgstr "" #: src/std/rc.md:30 msgid "\"Reference Count of rc_b: {}\"" msgstr "" #: src/std/rc.md:33 msgid "// Two `Rc`s are equal if their inner values are equal\n" msgstr "" #: src/std/rc.md:34 msgid "\"rc_a and rc_b are equal: {}\"" msgstr "" #: src/std/rc.md:36 msgid "// We can use methods of a value directly\n" msgstr "" #: src/std/rc.md:37 msgid "\"Length of the value inside rc_a: {}\"" msgstr "" #: src/std/rc.md:38 msgid "\"Value of rc_b: {}\"" msgstr "" #: src/std/rc.md:40 msgid "\"--- rc_b is dropped out of scope ---\"" msgstr "" #: src/std/rc.md:45 msgid "\"--- rc_a is dropped out of scope ---\"" msgstr "" #: src/std/rc.md:48 msgid "" "// Error! `rc_examples` already moved into `rc_a`\n" " // And when `rc_a` is dropped, `rc_examples` is dropped together\n" " // println!(\"rc_examples: {}\", rc_examples);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/std/rc.md:57 msgid "" "[std::rc](https://doc.rust-lang.org/std/rc/index.html) and [std::sync::arc]" "(https://doc.rust-lang.org/std/sync/struct.Arc.html)." msgstr "" #: src/std/arc.md:1 msgid "Arc" msgstr "" #: src/std/arc.md:3 msgid "" "When shared ownership between threads is needed, `Arc`(Atomically Reference " "Counted) can be used. This struct, via the `Clone` implementation can create " "a reference pointer for the location of a value in the memory heap while " "increasing the reference counter. As it shares ownership between threads, " "when the last reference pointer to a value is out of scope, the variable is " "dropped." msgstr "" #: src/std/arc.md:15 msgid "// This variable declaration is where its value is specified.\n" msgstr "" #: src/std/arc.md:16 msgid "\"the same apple\"" msgstr "" #: src/std/arc.md:19 msgid "" "// Here there is no value specification as it is a pointer to a\n" " // reference in the memory heap.\n" msgstr "" #: src/std/arc.md:24 msgid "" "// As Arc was used, threads can be spawned using the value allocated\n" " // in the Arc variable pointer's location.\n" msgstr "" #: src/std/arc.md:30 msgid "// Make sure all Arc instances are printed from spawned threads.\n" msgstr "" #: src/std_misc.md:3 msgid "" "Many other types are provided by the std library to support things such as:" msgstr "" #: src/std_misc.md:10 msgid "These expand beyond what the [primitives](primitives.md) provide." msgstr "" #: src/std_misc/threads.md:3 msgid "" "Rust provides a mechanism for spawning native OS threads via the `spawn` " "function, the argument of this function is a moving closure." msgstr "" #: src/std_misc/threads.md:10 src/std_misc/threads/testcase_mapreduce.md:28 msgid "// This is the `main` thread\n" msgstr "" #: src/std_misc/threads.md:13 msgid "// Make a vector to hold the children which are spawned.\n" msgstr "" #: src/std_misc/threads.md:17 msgid "// Spin up another thread\n" msgstr "" #: src/std_misc/threads.md:19 msgid "\"this is thread number {}\"" msgstr "" #: src/std_misc/threads.md:24 msgid "// Wait for the thread to finish. Returns a result.\n" msgstr "" #: src/std_misc/threads.md:30 msgid "These threads will be scheduled by the OS." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:3 msgid "" "Rust makes it very easy to parallelize data processing, without many of the " "headaches traditionally associated with such an attempt." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:5 msgid "" "The standard library provides great threading primitives out of the box. " "These, combined with Rust's concept of Ownership and aliasing rules, " "automatically prevent data races." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:9 msgid "" "The aliasing rules (one writable reference XOR many readable references) " "automatically prevent you from manipulating state that is visible to other " "threads. (Where synchronization is needed, there are synchronization " "primitives like `Mutex`es or `Channel`s.)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:14 msgid "" "In this example, we will calculate the sum of all digits in a block of " "numbers. We will do this by parcelling out chunks of the block into " "different threads. Each thread will sum its tiny block of digits, and " "subsequently we will sum the intermediate sums produced by each thread." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:19 msgid "" "Note that, although we're passing references across thread boundaries, Rust " "understands that we're only passing read-only references, and that thus no " "unsafety or data races can occur. Also because the references we're passing " "have `'static` lifetimes, Rust understands that our data won't be destroyed " "while these threads are still running. (When you need to share non-`static` " "data between threads, you can use a smart pointer like `Arc` to keep the " "data alive and avoid non-`static` lifetimes.)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:32 msgid "" "// This is our data to process.\n" " // We will calculate the sum of all digits via a threaded map-reduce " "algorithm.\n" " // Each whitespace separated chunk will be handled in a different " "thread.\n" " //\n" " // TODO: see what happens to the output if you insert spaces!\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:37 msgid "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:46 msgid "// Make a vector to hold the child-threads which we will spawn.\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:49 msgid "" "/*************************************************************************\n" " * \"Map\" phase\n" " *\n" " * Divide our data into segments, and apply initial processing\n" " ************************************************************************/" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:55 msgid "" "// split our data into segments for individual calculation\n" " // each chunk will be a reference (&str) into the actual data\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:59 msgid "" "// Iterate over the data segments.\n" " // .enumerate() adds the current loop index to whatever is iterated\n" " // the resulting tuple \"(index, element)\" is then immediately\n" " // \"destructured\" into two variables, \"i\" and \"data_segment\" with " "a\n" " // \"destructuring assignment\"\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:65 msgid "\"data segment {} is \\\"{}\\\"\"" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:67 msgid "" "// Process each data segment in a separate thread\n" " //\n" " // spawn() returns a handle to the new thread,\n" " // which we MUST keep to access the returned value\n" " //\n" " // 'move || -> u32' is syntax for a closure that:\n" " // * takes no arguments ('||')\n" " // * takes ownership of its captured variables ('move') and\n" " // * returns an unsigned 32-bit integer ('-> u32')\n" " //\n" " // Rust is smart enough to infer the '-> u32' from\n" " // the closure itself so we could have left that out.\n" " //\n" " // TODO: try removing the 'move' and see what happens\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:82 msgid "// Calculate the intermediate sum of this segment:\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:84 msgid "// iterate over the characters of our segment..\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:86 msgid "// .. convert text-characters to their number value..\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:87 msgid "\"should be a digit\"" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:88 msgid "// .. and sum the resulting iterator of numbers\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:91 msgid "// println! locks stdout, so no text-interleaving occurs\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:92 msgid "\"processed segment {}, result={}\"" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:94 msgid "" "// \"return\" not needed, because Rust is an \"expression language\", the\n" " // last evaluated expression in each block is automatically its " "value.\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:102 msgid "" "/*************************************************************************\n" " * \"Reduce\" phase\n" " *\n" " * Collect our intermediate results, and combine them into a final " "result\n" " ************************************************************************/" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:108 msgid "" "// combine each thread's intermediate results into a single final sum.\n" " //\n" " // we use the \"turbofish\" ::<> to provide sum() with a type hint.\n" " //\n" " // TODO: try without the turbofish, by instead explicitly\n" " // specifying the type of final_result\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:116 msgid "\"Final sum result: {}\"" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:122 msgid "Assignments" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:124 msgid "" "It is not wise to let our number of threads depend on user inputted data. " "What if the user decides to insert a lot of spaces? Do we _really_ want to " "spawn 2,000 threads? Modify the program so that the data is always chunked " "into a limited number of chunks, defined by a static constant at the " "beginning of the program." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:131 msgid "[Threads](../threads.md)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:132 msgid "[vectors](../../std/vec.md) and [iterators](../../trait/iter.md)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:133 msgid "" "[closures](../../fn/closures.md), [move](../../scope/move.md) semantics and " "[`move` closures](https://doc.rust-lang.org/book/ch13-01-closures." "html#closures-can-capture-their-environment)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:134 msgid "" "[destructuring](https://doc.rust-lang.org/book/ch18-03-pattern-syntax." "html#destructuring-to-break-apart-values) assignments" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:135 msgid "" "[turbofish notation](https://doc.rust-lang.org/book/appendix-02-operators." "html?highlight=turbofish) to help type inference" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:136 msgid "[unwrap vs. expect](../../error/option_unwrap.md)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:137 msgid "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" msgstr "" #: src/std_misc/channels.md:3 msgid "" "Rust provides asynchronous `channels` for communication between threads. " "Channels allow a unidirectional flow of information between two end-points: " "the `Sender` and the `Receiver`." msgstr "" #: src/std_misc/channels.md:15 msgid "" "// Channels have two endpoints: the `Sender` and the `Receiver`,\n" " // where `T` is the type of the message to be transferred\n" " // (type annotation is superfluous)\n" msgstr "" #: src/std_misc/channels.md:22 msgid "// The sender endpoint can be copied\n" msgstr "" #: src/std_misc/channels.md:25 msgid "// Each thread will send its id via the channel\n" msgstr "" #: src/std_misc/channels.md:27 msgid "" "// The thread takes ownership over `thread_tx`\n" " // Each thread queues a message in the channel\n" msgstr "" #: src/std_misc/channels.md:31 msgid "" "// Sending is a non-blocking operation, the thread will continue\n" " // immediately after sending its message\n" msgstr "" #: src/std_misc/channels.md:33 msgid "\"thread {} finished\"" msgstr "" #: src/std_misc/channels.md:39 msgid "// Here, all the messages are collected\n" msgstr "" #: src/std_misc/channels.md:42 msgid "" "// The `recv` method picks a message from the channel\n" " // `recv` will block the current thread if there are no messages " "available\n" msgstr "" #: src/std_misc/channels.md:47 msgid "// Wait for the threads to complete any remaining work\n" msgstr "" #: src/std_misc/channels.md:49 msgid "\"oops! the child thread panicked\"" msgstr "" #: src/std_misc/channels.md:52 msgid "// Show the order in which the messages were sent\n" msgstr "" #: src/std_misc/path.md:3 msgid "" "The `Path` struct represents file paths in the underlying filesystem. There " "are two flavors of `Path`: `posix::Path`, for UNIX-like systems, and " "`windows::Path`, for Windows. The prelude exports the appropriate platform-" "specific `Path` variant." msgstr "" #: src/std_misc/path.md:8 msgid "" "A `Path` can be created from an `OsStr`, and provides several methods to get " "information from the file/directory the path points to." msgstr "" #: src/std_misc/path.md:11 msgid "" "A `Path` is immutable. The owned version of `Path` is `PathBuf`. The " "relation between `Path` and `PathBuf` is similar to that of `str` and " "`String`: a `PathBuf` can be mutated in-place, and can be dereferenced to a " "`Path`." msgstr "" #: src/std_misc/path.md:15 msgid "" "Note that a `Path` is _not_ internally represented as an UTF-8 string, but " "instead is stored as an `OsString`. Therefore, converting a `Path` to a " "`&str` is _not_ free and may fail (an `Option` is returned). However, a " "`Path` can be freely converted to an `OsString` or `&OsStr` using " "`into_os_string` and `as_os_str`, respectively." msgstr "" #: src/std_misc/path.md:25 msgid "// Create a `Path` from an `&'static str`\n" msgstr "" #: src/std_misc/path.md:26 msgid "\".\"" msgstr "" #: src/std_misc/path.md:28 msgid "// The `display` method returns a `Display`able structure\n" msgstr "" #: src/std_misc/path.md:31 msgid "" "// `join` merges a path with a byte container using the OS specific\n" " // separator, and returns a `PathBuf`\n" msgstr "" #: src/std_misc/path.md:35 msgid "// `push` extends the `PathBuf` with a `&Path`\n" msgstr "" #: src/std_misc/path.md:37 msgid "\"myfile.tar.gz\"" msgstr "" #: src/std_misc/path.md:39 msgid "// `set_file_name` updates the file name of the `PathBuf`\n" msgstr "" #: src/std_misc/path.md:40 msgid "\"package.tgz\"" msgstr "" #: src/std_misc/path.md:42 msgid "// Convert the `PathBuf` into a string slice\n" msgstr "" #: src/std_misc/path.md:44 msgid "\"new path is not a valid UTF-8 sequence\"" msgstr "" #: src/std_misc/path.md:45 msgid "\"new path is {}\"" msgstr "" #: src/std_misc/path.md:51 msgid "" "Be sure to check at other `Path` methods (`posix::Path` or `windows::Path`) " "and the `Metadata` struct." msgstr "" #: src/std_misc/path.md:56 msgid "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) and [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)." msgstr "" #: src/std_misc/file.md:3 msgid "" "The `File` struct represents a file that has been opened (it wraps a file " "descriptor), and gives read and/or write access to the underlying file." msgstr "" #: src/std_misc/file.md:6 msgid "" "Since many things can go wrong when doing file I/O, all the `File` methods " "return the `io::Result` type, which is an alias for `Result`." msgstr "" #: src/std_misc/file.md:9 msgid "" "This makes the failure of all I/O operations _explicit_. Thanks to this, the " "programmer can see all the failure paths, and is encouraged to handle them " "in a proactive manner." msgstr "" #: src/std_misc/file/open.md:3 msgid "The `open` function can be used to open a file in read-only mode." msgstr "" #: src/std_misc/file/open.md:5 msgid "" "A `File` owns a resource, the file descriptor and takes care of closing the " "file when it is `drop`ed." msgstr "" #: src/std_misc/file/open.md:14 msgid "// Create a path to the desired file\n" msgstr "" #: src/std_misc/file/open.md:15 msgid "\"hello.txt\"" msgstr "" #: src/std_misc/file/open.md:18 msgid "// Open the path in read-only mode, returns `io::Result`\n" msgstr "" #: src/std_misc/file/open.md:20 msgid "\"couldn't open {}: {}\"" msgstr "" #: src/std_misc/file/open.md:24 msgid "// Read the file contents into a string, returns `io::Result`\n" msgstr "" #: src/std_misc/file/open.md:27 msgid "\"couldn't read {}: {}\"" msgstr "" #: src/std_misc/file/open.md:28 msgid "\"{} contains:\\n{}\"" msgstr "" #: src/std_misc/file/open.md:31 msgid "// `file` goes out of scope, and the \"hello.txt\" file gets closed\n" msgstr "" #: src/std_misc/file/open.md:35 src/std_misc/file/create.md:39 #: src/std_misc/fs.md:109 msgid "Here's the expected successful output:" msgstr "" #: src/std_misc/file/open.md:37 msgid "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt contains:\n" "Hello World!\n" "```" msgstr "" #: src/std_misc/file/open.md:44 msgid "" "(You are encouraged to test the previous example under different failure " "conditions: `hello.txt` doesn't exist, or `hello.txt` is not readable, etc.)" msgstr "" #: src/std_misc/file/create.md:3 msgid "" "The `create` function opens a file in write-only mode. If the file already " "existed, the old content is destroyed. Otherwise, a new file is created." msgstr "" #: src/std_misc/file/create.md:9 msgid "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" msgstr "" #: src/std_misc/file/create.md:22 msgid "\"lorem_ipsum.txt\"" msgstr "" #: src/std_misc/file/create.md:25 msgid "// Open a file in write-only mode, returns `io::Result`\n" msgstr "" #: src/std_misc/file/create.md:27 msgid "\"couldn't create {}: {}\"" msgstr "" #: src/std_misc/file/create.md:31 msgid "// Write the `LOREM_IPSUM` string to `file`, returns `io::Result<()>`\n" msgstr "" #: src/std_misc/file/create.md:33 msgid "\"couldn't write to {}: {}\"" msgstr "" #: src/std_misc/file/create.md:34 msgid "\"successfully wrote to {}\"" msgstr "" #: src/std_misc/file/create.md:54 msgid "" "(As in the previous example, you are encouraged to test this example under " "failure conditions.)" msgstr "" #: src/std_misc/file/create.md:57 msgid "" "The [`OpenOptions`](https://doc.rust-lang.org/std/fs/struct.OpenOptions." "html) struct can be used to configure how a file is opened." msgstr "" #: src/std_misc/file/read_lines.md:3 msgid "A naive approach" msgstr "" #: src/std_misc/file/read_lines.md:5 msgid "" "This might be a reasonable first attempt for a beginner's first " "implementation for reading lines from a file." msgstr "" #: src/std_misc/file/read_lines.md:22 msgid "" "Since the method `lines()` returns an iterator over the lines in the file, " "we can also perform a map inline and collect the results, yielding a more " "concise and fluent expression." msgstr "" #: src/std_misc/file/read_lines.md:31 msgid "// panic on possible file-reading errors\n" msgstr "" #: src/std_misc/file/read_lines.md:32 msgid "// split the string into an iterator of string slices\n" msgstr "" #: src/std_misc/file/read_lines.md:33 msgid "// make each slice into a string\n" msgstr "" #: src/std_misc/file/read_lines.md:34 msgid "// gather them together into a vector\n" msgstr "" #: src/std_misc/file/read_lines.md:38 msgid "" "Note that in both examples above, we must convert the `&str` reference " "returned from `lines()` to the owned type `String`, using `.to_string()` and " "`String::from` respectively." msgstr "" #: src/std_misc/file/read_lines.md:42 msgid "A more efficient approach" msgstr "" #: src/std_misc/file/read_lines.md:44 msgid "" "Here we pass ownership of the open `File` to a `BufReader` struct. " "`BufReader` uses an internal buffer to reduce intermediate allocations." msgstr "" #: src/std_misc/file/read_lines.md:47 msgid "" "We also update `read_lines` to return an iterator instead of allocating new " "`String` objects in memory for each line." msgstr "" #: src/std_misc/file/read_lines.md:56 msgid "// File hosts.txt must exist in the current path\n" msgstr "" #: src/std_misc/file/read_lines.md:57 msgid "\"./hosts.txt\"" msgstr "" #: src/std_misc/file/read_lines.md:58 msgid "// Consumes the iterator, returns an (Optional) String\n" msgstr "" #: src/std_misc/file/read_lines.md:64 msgid "" "// The output is wrapped in a Result to allow matching on errors.\n" "// Returns an Iterator to the Reader of the lines of the file.\n" msgstr "" #: src/std_misc/file/read_lines.md:74 msgid "Running this program simply prints the lines individually." msgstr "" #: src/std_misc/file/read_lines.md:76 msgid "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" msgstr "" #: src/std_misc/file/read_lines.md:83 msgid "" "(Note that since `File::open` expects a generic `AsRef` as argument, " "we define our generic `read_lines()` method with the same generic " "constraint, using the `where` keyword.)" msgstr "" #: src/std_misc/file/read_lines.md:86 msgid "" "This process is more efficient than creating a `String` in memory with all " "of the file's contents. This can especially cause performance issues when " "working with larger files." msgstr "" #: src/std_misc/process.md:3 msgid "" "The `process::Output` struct represents the output of a finished child " "process, and the `process::Command` struct is a process builder." msgstr "" #: src/std_misc/process.md:10 msgid "\"rustc\"" msgstr "" #: src/std_misc/process.md:11 msgid "\"--version\"" msgstr "" #: src/std_misc/process.md:13 msgid "\"failed to execute process: {}\"" msgstr "" #: src/std_misc/process.md:19 msgid "\"rustc succeeded and stdout was:\\n{}\"" msgstr "" #: src/std_misc/process.md:23 msgid "\"rustc failed and stderr was:\\n{}\"" msgstr "" #: src/std_misc/process.md:28 msgid "" "(You are encouraged to try the previous example with an incorrect flag " "passed to `rustc`)" msgstr "" #: src/std_misc/process/pipe.md:3 msgid "" "The `std::process::Child` struct represents a child process, and exposes the " "`stdin`, `stdout` and `stderr` handles for interaction with the underlying " "process via pipes." msgstr "" #: src/std_misc/process/pipe.md:11 msgid "\"the quick brown fox jumps over the lazy dog\\n\"" msgstr "" #: src/std_misc/process/pipe.md:15 msgid "// Spawn the `wc` command\n" msgstr "" #: src/std_misc/process/pipe.md:16 src/std_misc/fs.md:12 src/std_misc/fs.md:73 #: src/std_misc/ffi.md:11 msgid "\"windows\"" msgstr "" #: src/std_misc/process/pipe.md:17 msgid "\"powershell\"" msgstr "" #: src/std_misc/process/pipe.md:18 msgid "\"-Command\"" msgstr "" #: src/std_misc/process/pipe.md:18 msgid "\"$input | Measure-Object -Line -Word -Character\"" msgstr "" #: src/std_misc/process/pipe.md:21 msgid "\"wc\"" msgstr "" #: src/std_misc/process/pipe.md:27 msgid "\"couldn't spawn wc: {}\"" msgstr "" #: src/std_misc/process/pipe.md:31 msgid "" "// Write a string to the `stdin` of `wc`.\n" " //\n" " // `stdin` has type `Option`, but since we know this " "instance\n" " // must have one, we can directly `unwrap` it.\n" msgstr "" #: src/std_misc/process/pipe.md:36 msgid "\"couldn't write to wc stdin: {}\"" msgstr "" #: src/std_misc/process/pipe.md:37 msgid "\"sent pangram to wc\"" msgstr "" #: src/std_misc/process/pipe.md:40 msgid "" "// Because `stdin` does not live after the above calls, it is `drop`ed,\n" " // and the pipe is closed.\n" " //\n" " // This is very important, otherwise `wc` wouldn't start processing the\n" " // input we just sent.\n" msgstr "" #: src/std_misc/process/pipe.md:46 msgid "" "// The `stdout` field also has type `Option` so must be " "unwrapped.\n" msgstr "" #: src/std_misc/process/pipe.md:49 msgid "\"couldn't read wc stdout: {}\"" msgstr "" #: src/std_misc/process/pipe.md:50 msgid "\"wc responded with:\\n{}\"" msgstr "" #: src/std_misc/process/wait.md:3 msgid "" "If you'd like to wait for a `process::Child` to finish, you must call " "`Child::wait`, which will return a `process::ExitStatus`." msgstr "" #: src/std_misc/process/wait.md:10 msgid "\"sleep\"" msgstr "" #: src/std_misc/process/wait.md:13 msgid "\"reached end of main\"" msgstr "" #: src/std_misc/process/wait.md:18 msgid "" "# `wait` keeps running for 5 seconds until the `sleep 5` command finishes\n" msgstr "" #: src/std_misc/fs.md:3 msgid "" "The `std::fs` module contains several functions that deal with the " "filesystem." msgstr "" #: src/std_misc/fs.md:10 src/std_misc/fs.md:68 src/std_misc/ffi.md:20 msgid "\"unix\"" msgstr "" #: src/std_misc/fs.md:15 msgid "// A simple implementation of `% cat path`\n" msgstr "" #: src/std_misc/fs.md:25 msgid "// A simple implementation of `% echo s > path`\n" msgstr "" #: src/std_misc/fs.md:32 msgid "// A simple implementation of `% touch path` (ignores existing files)\n" msgstr "" #: src/std_misc/fs.md:42 msgid "\"`mkdir a`\"" msgstr "" #: src/std_misc/fs.md:43 msgid "// Create a directory, returns `io::Result<()>`\n" msgstr "" #: src/std_misc/fs.md:45 src/std_misc/fs.md:52 src/std_misc/fs.md:58 #: src/std_misc/fs.md:63 src/std_misc/fs.md:70 src/std_misc/fs.md:75 #: src/std_misc/fs.md:81 src/std_misc/fs.md:88 src/std_misc/fs.md:97 #: src/std_misc/fs.md:103 msgid "\"! {:?}\"" msgstr "" #: src/std_misc/fs.md:49 msgid "\"`echo hello > a/b.txt`\"" msgstr "" #: src/std_misc/fs.md:50 msgid "" "// The previous match can be simplified using the `unwrap_or_else` method\n" msgstr "" #: src/std_misc/fs.md:51 msgid "\"a/b.txt\"" msgstr "" #: src/std_misc/fs.md:55 msgid "\"`mkdir -p a/c/d`\"" msgstr "" #: src/std_misc/fs.md:56 msgid "// Recursively create a directory, returns `io::Result<()>`\n" msgstr "" #: src/std_misc/fs.md:57 src/std_misc/fs.md:102 msgid "\"a/c/d\"" msgstr "" #: src/std_misc/fs.md:61 msgid "\"`touch a/c/e.txt`\"" msgstr "" #: src/std_misc/fs.md:62 src/std_misc/fs.md:96 msgid "\"a/c/e.txt\"" msgstr "" #: src/std_misc/fs.md:66 msgid "\"`ln -s ../b.txt a/c/b.txt`\"" msgstr "" #: src/std_misc/fs.md:67 msgid "// Create a symbolic link, returns `io::Result<()>`\n" msgstr "" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 msgid "\"../b.txt\"" msgstr "" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 src/std_misc/fs.md:80 msgid "\"a/c/b.txt\"" msgstr "" #: src/std_misc/fs.md:79 msgid "\"`cat a/c/b.txt`\"" msgstr "" #: src/std_misc/fs.md:85 msgid "\"`ls a`\"" msgstr "" #: src/std_misc/fs.md:86 msgid "// Read the contents of a directory, returns `io::Result>`\n" msgstr "" #: src/std_misc/fs.md:94 msgid "\"`rm a/c/e.txt`\"" msgstr "" #: src/std_misc/fs.md:95 msgid "// Remove a file, returns `io::Result<()>`\n" msgstr "" #: src/std_misc/fs.md:100 msgid "\"`rmdir a/c/d`\"" msgstr "" #: src/std_misc/fs.md:101 msgid "// Remove an empty directory, returns `io::Result<()>`\n" msgstr "" #: src/std_misc/fs.md:111 msgid "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" msgstr "" #: src/std_misc/fs.md:127 msgid "And the final state of the `a` directory is:" msgstr "" #: src/std_misc/fs.md:139 msgid "An alternative way to define the function `cat` is with `?` notation:" msgstr "" #: src/std_misc/fs.md:152 msgid "[`cfg!`](../attribute/cfg.md)" msgstr "" #: src/std_misc/arg.md:3 msgid "Standard Library" msgstr "" #: src/std_misc/arg.md:5 msgid "" "The command line arguments can be accessed using `std::env::args`, which " "returns an iterator that yields a `String` for each argument:" msgstr "" #: src/std_misc/arg.md:14 msgid "// The first argument is the path that was used to call the program.\n" msgstr "" #: src/std_misc/arg.md:15 msgid "\"My path is {}.\"" msgstr "" #: src/std_misc/arg.md:17 msgid "" "// The rest of the arguments are the passed command line parameters.\n" " // Call the program like this:\n" " // $ ./args arg1 arg2\n" msgstr "" #: src/std_misc/arg.md:20 msgid "\"I got {:?} arguments: {:?}.\"" msgstr "" #: src/std_misc/arg.md:24 msgid "" "```shell\n" "$ ./args 1 2 3\n" "My path is ./args.\n" "I got 3 arguments: [\"1\", \"2\", \"3\"].\n" "```" msgstr "" #: src/std_misc/arg.md:32 msgid "" "Alternatively, there are numerous crates that can provide extra " "functionality when creating command-line applications. One of the more " "popular command line argument crates being [`clap`](https://rust-cli.github." "io/book/tutorial/cli-args.html#parsing-cli-arguments-with-clap)." msgstr "" #: src/std_misc/arg/matching.md:3 msgid "Matching can be used to parse simple arguments:" msgstr "" #: src/std_misc/arg/matching.md:17 msgid "" "\"usage:\n" "match_args \n" " Check whether given string is the answer.\n" "match_args {{increase|decrease}} \n" " Increase or decrease given integer by one.\"" msgstr "" #: src/std_misc/arg/matching.md:28 msgid "// no arguments passed\n" msgstr "" #: src/std_misc/arg/matching.md:30 msgid "\"My name is 'match_args'. Try passing some arguments!\"" msgstr "" #: src/std_misc/arg/matching.md:32 msgid "// one argument passed\n" msgstr "" #: src/std_misc/arg/matching.md:35 msgid "\"This is the answer!\"" msgstr "" #: src/std_misc/arg/matching.md:36 msgid "\"This is not the answer.\"" msgstr "" #: src/std_misc/arg/matching.md:39 msgid "// one command and one argument passed\n" msgstr "" #: src/std_misc/arg/matching.md:43 msgid "// parse the number\n" msgstr "" #: src/std_misc/arg/matching.md:49 msgid "\"error: second argument not an integer\"" msgstr "" #: src/std_misc/arg/matching.md:54 msgid "// parse the command\n" msgstr "" #: src/std_misc/arg/matching.md:56 msgid "\"increase\"" msgstr "" #: src/std_misc/arg/matching.md:57 msgid "\"decrease\"" msgstr "" #: src/std_misc/arg/matching.md:59 msgid "\"error: invalid command\"" msgstr "" #: src/std_misc/arg/matching.md:64 msgid "// all the other cases\n" msgstr "" #: src/std_misc/arg/matching.md:66 msgid "// show a help message\n" msgstr "" #: src/std_misc/arg/matching.md:73 msgid "" "If you named your program `match_args.rs` and compile it like this `rustc " "match_args.rs`, you can execute it as follows:" msgstr "" #: src/std_misc/ffi.md:3 msgid "" "Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign " "functions must be declared inside an `extern` block annotated with a " "`#[link]` attribute containing the name of the foreign library." msgstr "" #: src/std_misc/ffi.md:9 msgid "// this extern block links to the libm library\n" msgstr "" #: src/std_misc/ffi.md:12 msgid "\"msvcrt\"" msgstr "" #: src/std_misc/ffi.md:14 src/std_misc/ffi.md:23 msgid "" "// this is a foreign function\n" " // that computes the square root of a single precision complex number\n" msgstr "" #: src/std_misc/ffi.md:21 msgid "\"m\"" msgstr "" #: src/std_misc/ffi.md:29 msgid "" "// Since calling foreign functions is considered unsafe,\n" "// it's common to write safe wrappers around them.\n" msgstr "" #: src/std_misc/ffi.md:37 msgid "// z = -1 + 0i\n" msgstr "" #: src/std_misc/ffi.md:40 msgid "// calling a foreign function is an unsafe operation\n" msgstr "" #: src/std_misc/ffi.md:43 msgid "\"the square root of {:?} is {:?}\"" msgstr "" #: src/std_misc/ffi.md:45 msgid "// calling safe API wrapped around unsafe operation\n" msgstr "" #: src/std_misc/ffi.md:46 msgid "\"cos({:?}) = {:?}\"" msgstr "" #: src/std_misc/ffi.md:48 msgid "// Minimal implementation of single precision complex numbers\n" msgstr "" #: src/std_misc/ffi.md:60 msgid "\"{}-{}i\"" msgstr "" #: src/std_misc/ffi.md:62 msgid "\"{}+{}i\"" msgstr "" #: src/testing.md:3 msgid "" "Rust is a programming language that cares a lot about correctness and it " "includes support for writing software tests within the language itself." msgstr "" #: src/testing.md:6 msgid "Testing comes in three styles:" msgstr "" #: src/testing.md:8 msgid "[Unit](testing/unit_testing.md) testing." msgstr "" #: src/testing.md:9 msgid "[Doc](testing/doc_testing.md) testing." msgstr "" #: src/testing.md:10 msgid "[Integration](testing/integration_testing.md) testing." msgstr "" #: src/testing.md:12 msgid "Also Rust has support for specifying additional dependencies for tests:" msgstr "" #: src/testing.md:14 msgid "[Dev-dependencies](testing/dev_dependencies.md)" msgstr "" #: src/testing.md:18 msgid "" "[The Book](https://doc.rust-lang.org/book/ch11-00-testing.html) chapter on " "testing" msgstr "" #: src/testing.md:19 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on doc-testing" msgstr "" #: src/testing/unit_testing.md:3 msgid "" "Tests are Rust functions that verify that the non-test code is functioning " "in the expected manner. The bodies of test functions typically perform some " "setup, run the code we want to test, then assert whether the results are " "what we expect." msgstr "" #: src/testing/unit_testing.md:8 msgid "" "Most unit tests go into a `tests` [mod](../mod.md) with the `#[cfg(test)]` " "[attribute](../attribute.md). Test functions are marked with the `#[test]` " "attribute." msgstr "" #: src/testing/unit_testing.md:11 msgid "" "Tests fail when something in the test function [panics](../std/panic.md). " "There are some helper [macros](../macros.md):" msgstr "" #: src/testing/unit_testing.md:14 msgid "`assert!(expression)` - panics if expression evaluates to `false`." msgstr "" #: src/testing/unit_testing.md:15 msgid "" "`assert_eq!(left, right)` and `assert_ne!(left, right)` - testing left and " "right expressions for equality and inequality respectively." msgstr "" #: src/testing/unit_testing.md:22 msgid "" "// This is a really bad adding function, its purpose is to fail in this\n" "// example.\n" msgstr "" #: src/testing/unit_testing.md:32 msgid "" "// Note this useful idiom: importing names from outer (for mod tests) " "scope.\n" msgstr "" #: src/testing/unit_testing.md:42 msgid "" "// This assert would fire and test will fail.\n" " // Please note, that private functions can be tested too!\n" msgstr "" #: src/testing/unit_testing.md:49 msgid "Tests can be run with `cargo test`." msgstr "" #: src/testing/unit_testing.md:73 msgid "Tests and `?`" msgstr "" #: src/testing/unit_testing.md:75 msgid "" "None of the previous unit test examples had a return type. But in Rust 2018, " "your unit tests can return `Result<()>`, which lets you use `?` in them! " "This can make them much more concise." msgstr "" #: src/testing/unit_testing.md:84 msgid "\"negative floats don't have square roots\"" msgstr "" #: src/testing/unit_testing.md:101 msgid "" "See [\"The Edition Guide\"](https://doc.rust-lang.org/edition-guide/" "rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html) " "for more details." msgstr "" #: src/testing/unit_testing.md:103 msgid "Testing panics" msgstr "" #: src/testing/unit_testing.md:105 msgid "" "To check functions that should panic under certain circumstances, use " "attribute `#[should_panic]`. This attribute accepts optional parameter " "`expected = ` with the text of the panic message. If your function can panic " "in multiple ways, it helps make sure your test is testing the correct panic." msgstr "" #: src/testing/unit_testing.md:113 src/testing/doc_testing.md:45 msgid "\"Divide-by-zero error\"" msgstr "" #: src/testing/unit_testing.md:115 src/testing/unit_testing.md:136 msgid "\"Divide result is zero\"" msgstr "" #: src/testing/unit_testing.md:143 msgid "Running these tests gives us:" msgstr "" #: src/testing/unit_testing.md:162 msgid "Running specific tests" msgstr "" #: src/testing/unit_testing.md:164 msgid "" "To run specific tests one may specify the test name to `cargo test` command." msgstr "" #: src/testing/unit_testing.md:180 msgid "" "To run multiple tests one may specify part of a test name that matches all " "the tests that should be run." msgstr "" #: src/testing/unit_testing.md:198 msgid "Ignoring tests" msgstr "" #: src/testing/unit_testing.md:200 msgid "" "Tests can be marked with the `#[ignore]` attribute to exclude some tests. Or " "to run them with command `cargo test -- --ignored`" msgstr "" #: src/testing/doc_testing.md:3 msgid "" "The primary way of documenting a Rust project is through annotating the " "source code. Documentation comments are written in [CommonMark Markdown " "specification](https://commonmark.org/) and support code blocks in them. " "Rust takes care about correctness, so these code blocks are compiled and " "used as documentation tests." msgstr "" #: src/testing/doc_testing.md:10 msgid "" "/// First line is a short summary describing function.\n" "///\n" "/// The next lines present detailed documentation. Code blocks start with\n" "/// triple backquotes and have implicit `fn main()` inside\n" "/// and `extern crate `. Assume we're testing a `playground` library\n" "/// crate or using the Playground's Test action:\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" msgstr "" #: src/testing/doc_testing.md:23 msgid "" "/// Usually doc comments may include sections \"Examples\", \"Panics\" and " "\"Failures\".\n" "///\n" "/// The next function divides two numbers.\n" "///\n" "/// # Examples\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # Panics\n" "///\n" "/// The function panics if the second argument is zero.\n" "///\n" "/// ```rust,should_panic\n" "/// // panics on division by zero\n" "/// playground::div(10, 0);\n" "/// ```\n" msgstr "" #: src/testing/doc_testing.md:52 msgid "" "Code blocks in documentation are automatically tested when running the " "regular `cargo test` command:" msgstr "" #: src/testing/doc_testing.md:71 msgid "Motivation behind documentation tests" msgstr "" #: src/testing/doc_testing.md:73 msgid "" "The main purpose of documentation tests is to serve as examples that " "exercise the functionality, which is one of the most important [guidelines]" "(https://rust-lang-nursery.github.io/api-guidelines/documentation." "html#examples-use--not-try-not-unwrap-c-question-mark). It allows using " "examples from docs as complete code snippets. But using `?` makes " "compilation fail since `main` returns `unit`. The ability to hide some " "source lines from documentation comes to the rescue: one may write `fn " "try_main() -> Result<(), ErrorType>`, hide it and `unwrap` it in hidden " "`main`. Sounds complicated? Here's an example:" msgstr "" #: src/testing/doc_testing.md:82 msgid "" "/// Using hidden `try_main` in doc tests.\n" "///\n" "/// ```\n" "/// # // hidden lines start with `#` symbol, but they're still compilable!\n" "/// # fn try_main() -> Result<(), String> { // line that wraps the body " "shown in doc\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // returning from try_main\n" "/// # }\n" "/// # fn main() { // starting main that'll unwrap()\n" "/// # try_main().unwrap(); // calling try_main and unwrapping\n" "/// # // so that test will panic in case of error\n" "/// # }\n" "/// ```\n" msgstr "" #: src/testing/doc_testing.md:97 msgid "\"Divide-by-zero\"" msgstr "" #: src/testing/doc_testing.md:106 msgid "" "[RFC505](https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-" "conventions.md) on documentation style" msgstr "" #: src/testing/doc_testing.md:107 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on documentation guidelines" msgstr "" #: src/testing/integration_testing.md:3 msgid "" "[Unit tests](unit_testing.md) are testing one module in isolation at a time: " "they're small and can test private code. Integration tests are external to " "your crate and use only its public interface in the same way any other code " "would. Their purpose is to test that many parts of your library work " "correctly together." msgstr "" #: src/testing/integration_testing.md:8 msgid "Cargo looks for integration tests in `tests` directory next to `src`." msgstr "" #: src/testing/integration_testing.md:10 src/testing/dev_dependencies.md:17 msgid "File `src/lib.rs`:" msgstr "" #: src/testing/integration_testing.md:13 msgid "// Define this in a crate called `adder`.\n" msgstr "" #: src/testing/integration_testing.md:19 msgid "File with test: `tests/integration_test.rs`:" msgstr "" #: src/testing/integration_testing.md:28 msgid "Running tests with `cargo test` command:" msgstr "" #: src/testing/integration_testing.md:50 msgid "" "Each Rust source file in the `tests` directory is compiled as a separate " "crate. In order to share some code between integration tests we can make a " "module with public functions, importing and using it within tests." msgstr "" #: src/testing/integration_testing.md:54 msgid "File `tests/common/mod.rs`:" msgstr "" #: src/testing/integration_testing.md:58 msgid "" "// some setup code, like creating required files/directories, starting\n" " // servers, etc.\n" msgstr "" #: src/testing/integration_testing.md:63 msgid "File with test: `tests/integration_test.rs`" msgstr "" #: src/testing/integration_testing.md:66 msgid "// importing common module.\n" msgstr "" #: src/testing/integration_testing.md:71 msgid "// using common code.\n" msgstr "" #: src/testing/integration_testing.md:77 msgid "" "Creating the module as `tests/common.rs` also works, but is not recommended " "because the test runner will treat the file as a test crate and try to run " "tests inside it." msgstr "" #: src/testing/dev_dependencies.md:1 msgid "Development dependencies" msgstr "" #: src/testing/dev_dependencies.md:3 msgid "" "Sometimes there is a need to have dependencies for tests (or examples, or " "benchmarks) only. Such dependencies are added to `Cargo.toml` in the `[dev-" "dependencies]` section. These dependencies are not propagated to other " "packages which depend on this package." msgstr "" #: src/testing/dev_dependencies.md:8 msgid "" "One such example is [`pretty_assertions`](https://docs.rs/" "pretty_assertions/1.0.0/pretty_assertions/index.html), which extends " "standard `assert_eq!` and `assert_ne!` macros, to provide colorful diff. \n" "File `Cargo.toml`:" msgstr "" #: src/testing/dev_dependencies.md:11 msgid "" "```toml\n" "# standard crate data is left out\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" msgstr "" #: src/testing/dev_dependencies.md:27 msgid "// crate for test-only use. Cannot be used in non-test code.\n" msgstr "" #: src/testing/dev_dependencies.md:38 msgid "" "[Cargo](http://doc.crates.io/specifying-dependencies.html) docs on " "specifying dependencies." msgstr "" #: src/unsafe.md:3 msgid "" "As an introduction to this section, to borrow from [the official docs]" "(https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html), \"one should try " "to minimize the amount of unsafe code in a code base.\" With that in mind, " "let's get started! Unsafe annotations in Rust are used to bypass protections " "put in place by the compiler; specifically, there are four primary things " "that unsafe is used for:" msgstr "" #: src/unsafe.md:9 msgid "dereferencing raw pointers" msgstr "" #: src/unsafe.md:10 msgid "" "calling functions or methods which are `unsafe` (including calling a " "function over FFI, see [a previous chapter](std_misc/ffi.md) of the book)" msgstr "" #: src/unsafe.md:12 msgid "accessing or modifying static mutable variables" msgstr "" #: src/unsafe.md:13 msgid "implementing unsafe traits" msgstr "" #: src/unsafe.md:15 msgid "Raw Pointers" msgstr "" #: src/unsafe.md:17 msgid "" "Raw pointers `*` and references `&T` function similarly, but references are " "always safe because they are guaranteed to point to valid data due to the " "borrow checker. Dereferencing a raw pointer can only be done through an " "unsafe block." msgstr "" #: src/unsafe.md:32 msgid "Calling Unsafe Functions" msgstr "" #: src/unsafe.md:34 msgid "" "Some functions can be declared as `unsafe`, meaning it is the programmer's " "responsibility to ensure correctness instead of the compiler's. One example " "of this is [`std::slice::from_raw_parts`](https://doc.rust-lang.org/std/" "slice/fn.from_raw_parts.html) which will create a slice given a pointer to " "the first element and a length." msgstr "" #: src/unsafe.md:56 msgid "" "For `slice::from_raw_parts`, one of the assumptions which _must_ be upheld " "is that the pointer passed in points to valid memory and that the memory " "pointed to is of the correct type. If these invariants aren't upheld then " "the program's behaviour is undefined and there is no knowing what will " "happen." msgstr "" #: src/unsafe/asm.md:3 msgid "" "Rust provides support for inline assembly via the `asm!` macro. It can be " "used to embed handwritten assembly in the assembly output generated by the " "compiler. Generally this should not be necessary, but might be where the " "required performance or timing cannot be otherwise achieved. Accessing low " "level hardware primitives, e.g. in kernel code, may also demand this " "functionality." msgstr "" #: src/unsafe/asm.md:8 msgid "" "**Note**: the examples here are given in x86/x86-64 assembly, but other " "architectures are also supported." msgstr "" #: src/unsafe/asm.md:10 msgid "Inline assembly is currently supported on the following architectures:" msgstr "" #: src/unsafe/asm.md:12 msgid "x86 and x86-64" msgstr "" #: src/unsafe/asm.md:13 msgid "ARM" msgstr "" #: src/unsafe/asm.md:14 msgid "AArch64" msgstr "" #: src/unsafe/asm.md:15 msgid "RISC-V" msgstr "" #: src/unsafe/asm.md:17 msgid "Basic usage" msgstr "" #: src/unsafe/asm.md:19 msgid "Let us start with the simplest possible example:" msgstr "" #: src/unsafe/asm.md:22 src/unsafe/asm.md:42 src/unsafe/asm.md:69 #: src/unsafe/asm.md:107 src/unsafe/asm.md:124 src/unsafe/asm.md:149 #: src/unsafe/asm.md:183 src/unsafe/asm.md:204 src/unsafe/asm.md:221 #: src/unsafe/asm.md:260 src/unsafe/asm.md:296 src/unsafe/asm.md:312 #: src/unsafe/asm.md:338 src/unsafe/asm.md:376 src/unsafe/asm.md:403 #: src/unsafe/asm.md:427 src/unsafe/asm.md:465 msgid "\"x86_64\"" msgstr "" #: src/unsafe/asm.md:26 msgid "\"nop\"" msgstr "" #: src/unsafe/asm.md:31 msgid "" "This will insert a NOP (no operation) instruction into the assembly " "generated by the compiler. Note that all `asm!` invocations have to be " "inside an `unsafe` block, as they could insert arbitrary instructions and " "break various invariants. The instructions to be inserted are listed in the " "first argument of the `asm!` macro as a string literal." msgstr "" #: src/unsafe/asm.md:36 msgid "Inputs and outputs" msgstr "" #: src/unsafe/asm.md:38 msgid "" "Now inserting an instruction that does nothing is rather boring. Let us do " "something that actually acts on data:" msgstr "" #: src/unsafe/asm.md:47 msgid "\"mov {}, 5\"" msgstr "" #: src/unsafe/asm.md:53 msgid "" "This will write the value `5` into the `u64` variable `x`. You can see that " "the string literal we use to specify instructions is actually a template " "string. It is governed by the same rules as Rust [format strings](https://" "doc.rust-lang.org/std/fmt/#syntax). The arguments that are inserted into the " "template however look a bit different than you may be familiar with. First " "we need to specify if the variable is an input or an output of the inline " "assembly. In this case it is an output. We declared this by writing `out`. " "We also need to specify in what kind of register the assembly expects the " "variable. In this case we put it in an arbitrary general purpose register by " "specifying `reg`. The compiler will choose an appropriate register to insert " "into the template and will read the variable from there after the inline " "assembly finishes executing." msgstr "" #: src/unsafe/asm.md:66 msgid "Let us see another example that also uses an input:" msgstr "" #: src/unsafe/asm.md:76 msgid "\"mov {0}, {1}\"" msgstr "" #: src/unsafe/asm.md:77 src/unsafe/asm.md:112 src/unsafe/asm.md:130 msgid "\"add {0}, 5\"" msgstr "" #: src/unsafe/asm.md:86 msgid "" "This will add `5` to the input in variable `i` and write the result to " "variable `o`. The particular way this assembly does this is first copying " "the value from `i` to the output, and then adding `5` to it." msgstr "" #: src/unsafe/asm.md:90 msgid "The example shows a few things:" msgstr "" #: src/unsafe/asm.md:92 msgid "" "First, we can see that `asm!` allows multiple template string arguments; " "each one is treated as a separate line of assembly code, as if they were all " "joined together with newlines between them. This makes it easy to format " "assembly code." msgstr "" #: src/unsafe/asm.md:97 msgid "" "Second, we can see that inputs are declared by writing `in` instead of `out`." msgstr "" #: src/unsafe/asm.md:99 msgid "" "Third, we can see that we can specify an argument number, or name as in any " "format string. For inline assembly templates this is particularly useful as " "arguments are often used more than once. For more complex inline assembly " "using this facility is generally recommended, as it improves readability, " "and allows reordering instructions without changing the argument order." msgstr "" #: src/unsafe/asm.md:104 msgid "We can further refine the above example to avoid the `mov` instruction:" msgstr "" #: src/unsafe/asm.md:118 msgid "" "We can see that `inout` is used to specify an argument that is both input " "and output. This is different from specifying an input and output separately " "in that it is guaranteed to assign both to the same register." msgstr "" #: src/unsafe/asm.md:121 msgid "" "It is also possible to specify different variables for the input and output " "parts of an `inout` operand:" msgstr "" #: src/unsafe/asm.md:136 msgid "Late output operands" msgstr "" #: src/unsafe/asm.md:138 msgid "" "The Rust compiler is conservative with its allocation of operands. It is " "assumed that an `out` can be written at any time, and can therefore not " "share its location with any other argument. However, to guarantee optimal " "performance it is important to use as few registers as possible, so they " "won't have to be saved and reloaded around the inline assembly block. To " "achieve this Rust provides a `lateout` specifier. This can be used on any " "output that is written only after all inputs have been consumed. There is " "also an `inlateout` variant of this specifier." msgstr "" #: src/unsafe/asm.md:146 msgid "" "Here is an example where `inlateout` _cannot_ be used in `release` mode or " "other optimized cases:" msgstr "" #: src/unsafe/asm.md:157 src/unsafe/asm.md:189 src/unsafe/asm.md:472 msgid "\"add {0}, {1}\"" msgstr "" #: src/unsafe/asm.md:158 msgid "\"add {0}, {2}\"" msgstr "" #: src/unsafe/asm.md:168 msgid "" "In unoptimized cases (e.g. `Debug` mode), replacing `inout(reg) a` with " "`inlateout(reg) a` in the above example can continue to give the expected " "result. However, with `release` mode or other optimized cases, using " "`inlateout(reg) a` can instead lead to the final value `a = 16`, causing the " "assertion to fail." msgstr "" #: src/unsafe/asm.md:173 msgid "" "This is because in optimized cases, the compiler is free to allocate the " "same register for inputs `b` and `c` since it knows that they have the same " "value. Furthermore, when `inlateout` is used, `a` and `c` could be allocated " "to the same register, in which case the first `add` instruction would " "overwrite the initial load from variable `c`. This is in contrast to how " "using `inout(reg) a` ensures a separate register is allocated for `a`." msgstr "" #: src/unsafe/asm.md:179 msgid "" "However, the following example can use `inlateout` since the output is only " "modified after all input registers have been read:" msgstr "" #: src/unsafe/asm.md:195 msgid "" "As you can see, this assembly fragment will still work correctly if `a` and " "`b` are assigned to the same register." msgstr "" #: src/unsafe/asm.md:197 msgid "Explicit register operands" msgstr "" #: src/unsafe/asm.md:199 msgid "" "Some instructions require that the operands be in a specific register. " "Therefore, Rust inline assembly provides some more specific constraint " "specifiers. While `reg` is generally available on any architecture, explicit " "registers are highly architecture specific. E.g. for x86 the general purpose " "registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi` among others " "can be addressed by their name." msgstr "" #: src/unsafe/asm.md:209 msgid "\"out 0x64, eax\"" msgstr "" #: src/unsafe/asm.md:209 src/unsafe/asm.md:285 msgid "\"eax\"" msgstr "" #: src/unsafe/asm.md:214 msgid "" "In this example we call the `out` instruction to output the content of the " "`cmd` variable to port `0x64`. Since the `out` instruction only accepts " "`eax` (and its sub registers) as operand we had to use the `eax` constraint " "specifier." msgstr "" #: src/unsafe/asm.md:216 msgid "" "**Note**: unlike other operand types, explicit register operands cannot be " "used in the template string: you can't use `{}` and should write the " "register name directly instead. Also, they must appear at the end of the " "operand list after all other operand types." msgstr "" #: src/unsafe/asm.md:218 msgid "Consider this example which uses the x86 `mul` instruction:" msgstr "" #: src/unsafe/asm.md:230 msgid "" "// The x86 mul instruction takes rax as an implicit input and writes\n" " // the 128-bit result of the multiplication to rax:rdx.\n" " \"mul {}\"" msgstr "" #: src/unsafe/asm.md:234 src/unsafe/asm.md:356 msgid "\"rax\"" msgstr "" #: src/unsafe/asm.md:235 msgid "\"rdx\"" msgstr "" #: src/unsafe/asm.md:244 msgid "" "This uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit " "result. The only explicit operand is a register, that we fill from the " "variable `a`. The second operand is implicit, and must be the `rax` " "register, which we fill from the variable `b`. The lower 64 bits of the " "result are stored in `rax` from which we fill the variable `lo`. The higher " "64 bits are stored in `rdx` from which we fill the variable `hi`." msgstr "" #: src/unsafe/asm.md:250 msgid "Clobbered registers" msgstr "" #: src/unsafe/asm.md:252 msgid "" "In many cases inline assembly will modify state that is not needed as an " "output. Usually this is either because we have to use a scratch register in " "the assembly or because instructions modify state that we don't need to " "further examine. This state is generally referred to as being \"clobbered\". " "We need to tell the compiler about this since it may need to save and " "restore this state around the inline assembly block." msgstr "" #: src/unsafe/asm.md:262 msgid "// three entries of four bytes each\n" msgstr "" #: src/unsafe/asm.md:264 msgid "" "// String is stored as ascii in ebx, edx, ecx in order\n" " // Because ebx is reserved, the asm needs to preserve the value of it.\n" " // So we push and pop it around the main asm.\n" " // 64 bit mode on 64 bit processors does not allow pushing/popping of\n" " // 32 bit registers (like ebx), so we have to use the extended rbx " "register instead.\n" msgstr "" #: src/unsafe/asm.md:272 msgid "\"push rbx\"" msgstr "" #: src/unsafe/asm.md:273 msgid "\"cpuid\"" msgstr "" #: src/unsafe/asm.md:274 msgid "\"mov [rdi], ebx\"" msgstr "" #: src/unsafe/asm.md:275 msgid "\"mov [rdi + 4], edx\"" msgstr "" #: src/unsafe/asm.md:276 msgid "\"mov [rdi + 8], ecx\"" msgstr "" #: src/unsafe/asm.md:277 msgid "\"pop rbx\"" msgstr "" #: src/unsafe/asm.md:278 msgid "" "// We use a pointer to an array for storing the values to simplify\n" " // the Rust code at the cost of a couple more asm instructions\n" " // This is more explicit with how the asm works however, as " "opposed\n" " // to explicit register outputs such as `out(\"ecx\") val`\n" " // The *pointer itself* is only an input even though it's " "written behind\n" msgstr "" #: src/unsafe/asm.md:283 src/unsafe/asm.md:354 msgid "\"rdi\"" msgstr "" #: src/unsafe/asm.md:284 msgid "// select cpuid 0, also specify eax as clobbered\n" msgstr "" #: src/unsafe/asm.md:286 msgid "// cpuid clobbers these registers too\n" msgstr "" #: src/unsafe/asm.md:287 msgid "\"ecx\"" msgstr "" #: src/unsafe/asm.md:288 msgid "\"edx\"" msgstr "" #: src/unsafe/asm.md:293 msgid "\"CPU Manufacturer ID: {}\"" msgstr "" #: src/unsafe/asm.md:300 msgid "" "In the example above we use the `cpuid` instruction to read the CPU " "manufacturer ID. This instruction writes to `eax` with the maximum supported " "`cpuid` argument and `ebx`, `edx`, and `ecx` with the CPU manufacturer ID as " "ASCII bytes in that order." msgstr "" #: src/unsafe/asm.md:303 msgid "" "Even though `eax` is never read we still need to tell the compiler that the " "register has been modified so that the compiler can save any values that " "were in these registers before the asm. This is done by declaring it as an " "output but with `_` instead of a variable name, which indicates that the " "output value is to be discarded." msgstr "" #: src/unsafe/asm.md:305 msgid "" "This code also works around the limitation that `ebx` is a reserved register " "by LLVM. That means that LLVM assumes that it has full control over the " "register and it must be restored to its original state before exiting the " "asm block, so it cannot be used as an input or output **except** if the " "compiler uses it to fulfill a general register class (e.g. `in(reg)`). This " "makes `reg` operands dangerous when using reserved registers as we could " "unknowingly corrupt our input or output because they share the same register." msgstr "" #: src/unsafe/asm.md:307 msgid "" "To work around this we use `rdi` to store the pointer to the output array, " "save `ebx` via `push`, read from `ebx` inside the asm block into the array " "and then restore `ebx` to its original state via `pop`. The `push` and `pop` " "use the full 64-bit `rbx` version of the register to ensure that the entire " "register is saved. On 32 bit targets the code would instead use `ebx` in the " "`push`/`pop`." msgstr "" #: src/unsafe/asm.md:309 msgid "" "This can also be used with a general register class to obtain a scratch " "register for use inside the asm code:" msgstr "" #: src/unsafe/asm.md:314 msgid "// Multiply x by 6 using shifts and adds\n" msgstr "" #: src/unsafe/asm.md:319 msgid "\"mov {tmp}, {x}\"" msgstr "" #: src/unsafe/asm.md:320 msgid "\"shl {tmp}, 1\"" msgstr "" #: src/unsafe/asm.md:321 msgid "\"shl {x}, 2\"" msgstr "" #: src/unsafe/asm.md:322 msgid "\"add {x}, {tmp}\"" msgstr "" #: src/unsafe/asm.md:331 msgid "Symbol operands and ABI clobbers" msgstr "" #: src/unsafe/asm.md:333 msgid "" "By default, `asm!` assumes that any register not specified as an output will " "have its contents preserved by the assembly code. The [`clobber_abi`]" "(https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-" "clobbers) argument to `asm!` tells the compiler to automatically insert the " "necessary clobber operands according to the given calling convention ABI: " "any register which is not fully preserved in that ABI will be treated as " "clobbered. Multiple `clobber_abi` arguments may be provided and all " "clobbers from all specified ABIs will be inserted." msgstr "" #: src/unsafe/asm.md:341 src/unsafe/asm.md:359 msgid "\"C\"" msgstr "" #: src/unsafe/asm.md:342 msgid "\"arg = {}\"" msgstr "" #: src/unsafe/asm.md:350 msgid "\"call {}\"" msgstr "" #: src/unsafe/asm.md:351 msgid "// Function pointer to call\n" msgstr "" #: src/unsafe/asm.md:353 msgid "// 1st argument in rdi\n" msgstr "" #: src/unsafe/asm.md:355 msgid "// Return value in rax\n" msgstr "" #: src/unsafe/asm.md:357 msgid "" "// Mark all registers which are not preserved by the \"C\" calling\n" " // convention as clobbered.\n" msgstr "" #: src/unsafe/asm.md:367 msgid "Register template modifiers" msgstr "" #: src/unsafe/asm.md:369 msgid "" "In some cases, fine control is needed over the way a register name is " "formatted when inserted into the template string. This is needed when an " "architecture's assembly language has several names for the same register, " "each typically being a \"view\" over a subset of the register (e.g. the low " "32 bits of a 64-bit register)." msgstr "" #: src/unsafe/asm.md:371 msgid "" "By default the compiler will always choose the name that refers to the full " "register size (e.g. `rax` on x86-64, `eax` on x86, etc)." msgstr "" #: src/unsafe/asm.md:373 msgid "" "This default can be overridden by using modifiers on the template string " "operands, just like you would with format strings:" msgstr "" #: src/unsafe/asm.md:382 msgid "\"mov {0:h}, {0:l}\"" msgstr "" #: src/unsafe/asm.md:389 msgid "" "In this example, we use the `reg_abcd` register class to restrict the " "register allocator to the 4 legacy x86 registers (`ax`, `bx`, `cx`, `dx`) of " "which the first two bytes can be addressed independently." msgstr "" #: src/unsafe/asm.md:391 msgid "" "Let us assume that the register allocator has chosen to allocate `x` in the " "`ax` register. The `h` modifier will emit the register name for the high " "byte of that register and the `l` modifier will emit the register name for " "the low byte. The asm code will therefore be expanded as `mov ah, al` which " "copies the low byte of the value into the high byte." msgstr "" #: src/unsafe/asm.md:394 msgid "" "If you use a smaller data type (e.g. `u16`) with an operand and forget to " "use template modifiers, the compiler will emit a warning and suggest the " "correct modifier to use." msgstr "" #: src/unsafe/asm.md:396 msgid "Memory address operands" msgstr "" #: src/unsafe/asm.md:398 msgid "" "Sometimes assembly instructions require operands passed via memory addresses/" "memory locations. You have to manually use the memory address syntax " "specified by the target architecture. For example, on x86/x86_64 using Intel " "assembly syntax, you should wrap inputs/outputs in `[]` to indicate they are " "memory operands:" msgstr "" #: src/unsafe/asm.md:408 msgid "\"fldcw [{}]\"" msgstr "" #: src/unsafe/asm.md:414 msgid "Labels" msgstr "" #: src/unsafe/asm.md:416 msgid "" "Any reuse of a named label, local or otherwise, can result in an assembler " "or linker error or may cause other strange behavior. Reuse of a named label " "can happen in a variety of ways including:" msgstr "" #: src/unsafe/asm.md:418 msgid "" "explicitly: using a label more than once in one `asm!` block, or multiple " "times across blocks." msgstr "" #: src/unsafe/asm.md:419 msgid "" "implicitly via inlining: the compiler is allowed to instantiate multiple " "copies of an `asm!` block, for example when the function containing it is " "inlined in multiple places." msgstr "" #: src/unsafe/asm.md:420 msgid "" "implicitly via LTO: LTO can cause code from _other crates_ to be placed in " "the same codegen unit, and so could bring in arbitrary labels." msgstr "" #: src/unsafe/asm.md:422 msgid "" "As a consequence, you should only use GNU assembler **numeric** [local " "labels](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-" "Labels) inside inline assembly code. Defining symbols in assembly code may " "lead to assembler and/or linker errors due to duplicate symbol definitions." msgstr "" #: src/unsafe/asm.md:424 msgid "" "Moreover, on x86 when using the default Intel syntax, due to [an LLVM bug]" "(https://bugs.llvm.org/show_bug.cgi?id=36144), you shouldn't use labels " "exclusively made of `0` and `1` digits, e.g. `0`, `11` or `101010`, as they " "may end up being interpreted as binary values. Using `options(att_syntax)` " "will avoid any ambiguity, but that affects the syntax of the _entire_ `asm!` " "block. (See [Options](#options), below, for more on `options`.)" msgstr "" #: src/unsafe/asm.md:433 msgid "\"mov {0}, 10\"" msgstr "" #: src/unsafe/asm.md:434 src/unsafe/asm.md:439 msgid "\"2:\"" msgstr "" #: src/unsafe/asm.md:435 msgid "\"sub {0}, 1\"" msgstr "" #: src/unsafe/asm.md:436 msgid "\"cmp {0}, 3\"" msgstr "" #: src/unsafe/asm.md:437 msgid "\"jle 2f\"" msgstr "" #: src/unsafe/asm.md:438 msgid "\"jmp 2b\"" msgstr "" #: src/unsafe/asm.md:440 msgid "\"add {0}, 2\"" msgstr "" #: src/unsafe/asm.md:448 msgid "" "This will decrement the `{0}` register value from 10 to 3, then add 2 and " "store it in `a`." msgstr "" #: src/unsafe/asm.md:450 msgid "This example shows a few things:" msgstr "" #: src/unsafe/asm.md:452 msgid "" "First, that the same number can be used as a label multiple times in the " "same inline block." msgstr "" #: src/unsafe/asm.md:453 msgid "" "Second, that when a numeric label is used as a reference (as an instruction " "operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) " "should be added to the numeric label. It will then refer to the nearest " "label defined by this number in this direction." msgstr "" #: src/unsafe/asm.md:458 msgid "Options" msgstr "" #: src/unsafe/asm.md:460 msgid "" "By default, an inline assembly block is treated the same way as an external " "FFI function call with a custom calling convention: it may read/write " "memory, have observable side effects, etc. However, in many cases it is " "desirable to give the compiler more information about what the assembly code " "is actually doing so that it can optimize better." msgstr "" #: src/unsafe/asm.md:462 msgid "Let's take our previous example of an `add` instruction:" msgstr "" #: src/unsafe/asm.md:481 msgid "" "Options can be provided as an optional final argument to the `asm!` macro. " "We specified three options here:" msgstr "" #: src/unsafe/asm.md:483 msgid "" "`pure` means that the asm code has no observable side effects and that its " "output depends only on its inputs. This allows the compiler optimizer to " "call the inline asm fewer times or even eliminate it entirely." msgstr "" #: src/unsafe/asm.md:484 msgid "" "`nomem` means that the asm code does not read or write to memory. By default " "the compiler will assume that inline assembly can read or write any memory " "address that is accessible to it (e.g. through a pointer passed as an " "operand, or a global)." msgstr "" #: src/unsafe/asm.md:485 msgid "" "`nostack` means that the asm code does not push any data onto the stack. " "This allows the compiler to use optimizations such as the stack red zone on " "x86-64 to avoid stack pointer adjustments." msgstr "" #: src/unsafe/asm.md:487 msgid "" "These allow the compiler to better optimize code using `asm!`, for example " "by eliminating pure `asm!` blocks whose outputs are not needed." msgstr "" #: src/unsafe/asm.md:489 msgid "" "See the [reference](https://doc.rust-lang.org/stable/reference/inline-" "assembly.html) for the full list of available options and their effects." msgstr "" #: src/compatibility.md:3 msgid "" "The Rust language is evolving rapidly, and because of this certain " "compatibility issues can arise, despite efforts to ensure forwards-" "compatibility wherever possible." msgstr "" #: src/compatibility.md:7 msgid "[Raw identifiers](compatibility/raw_identifiers.md)" msgstr "" #: src/compatibility/raw_identifiers.md:3 msgid "" "Rust, like many programming languages, has the concept of \"keywords\". " "These identifiers mean something to the language, and so you cannot use them " "in places like variable names, function names, and other places. Raw " "identifiers let you use keywords where they would not normally be allowed. " "This is particularly useful when Rust introduces new keywords, and a library " "using an older edition of Rust has a variable or function with the same name " "as a keyword introduced in a newer edition." msgstr "" #: src/compatibility/raw_identifiers.md:11 msgid "" "For example, consider a crate `foo` compiled with the 2015 edition of Rust " "that exports a function named `try`. This keyword is reserved for a new " "feature in the 2018 edition, so without raw identifiers, we would have no " "way to name the function." msgstr "" #: src/compatibility/raw_identifiers.md:24 msgid "You'll get this error:" msgstr "" #: src/compatibility/raw_identifiers.md:34 msgid "You can write this with a raw identifier:" msgstr "" #: src/meta.md:3 msgid "" "Some topics aren't exactly relevant to how you program runs but provide you " "tooling or infrastructure support which just makes things better for " "everyone. These topics include:" msgstr "" #: src/meta.md:7 msgid "" "[Documentation](meta/doc.md): Generate library documentation for users via " "the included `rustdoc`." msgstr "" #: src/meta.md:9 msgid "" "[Playground](meta/playground.md): Integrate the Rust Playground in your " "documentation." msgstr "" #: src/meta/doc.md:3 msgid "" "Use `cargo doc` to build documentation in `target/doc`, `cargo doc --open` " "will automatically open it in your web browser." msgstr "" #: src/meta/doc.md:6 msgid "" "Use `cargo test` to run all tests (including documentation tests), and " "`cargo test --doc` to only run documentation tests." msgstr "" #: src/meta/doc.md:9 msgid "" "These commands will appropriately invoke `rustdoc` (and `rustc`) as required." msgstr "" #: src/meta/doc.md:11 msgid "Doc comments" msgstr "" #: src/meta/doc.md:13 msgid "" "Doc comments are very useful for big projects that require documentation. " "When running `rustdoc`, these are the comments that get compiled into " "documentation. They are denoted by a `///`, and support [Markdown](https://" "en.wikipedia.org/wiki/Markdown)." msgstr "" #: src/meta/doc.md:18 msgid "\"doc\"" msgstr "" #: src/meta/doc.md:19 msgid "/// A human being is represented here\n" msgstr "" #: src/meta/doc.md:22 msgid "/// A person must have a name, no matter how much Juliet may hate it\n" msgstr "" #: src/meta/doc.md:27 msgid "" "/// Creates a person with the given name.\n" " ///\n" " /// # Examples\n" " ///\n" " /// ```\n" " /// // You can have rust code between fences inside the comments\n" " /// // If you pass --test to `rustdoc`, it will even test it for you!\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" msgstr "" #: src/meta/doc.md:43 msgid "" "/// Gives a friendly hello!\n" " ///\n" " /// Says \"Hello, [name](Person::name)\" to the `Person` it is called " "on.\n" msgstr "" #: src/meta/doc.md:47 msgid "\"Hello, {}!\"" msgstr "" #: src/meta/doc.md:52 msgid "\"John\"" msgstr "" #: src/meta/doc.md:58 msgid "" "To run the tests, first build the code as a library, then tell `rustdoc` " "where to find the library so it can link it into each doctest program:" msgstr "" #: src/meta/doc.md:61 msgid "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" msgstr "" #: src/meta/doc.md:66 msgid "Doc attributes" msgstr "" #: src/meta/doc.md:68 msgid "" "Below are a few examples of the most common `#[doc]` attributes used with " "`rustdoc`." msgstr "" #: src/meta/doc.md:71 msgid "`inline`" msgstr "" #: src/meta/doc.md:73 msgid "Used to inline docs, instead of linking out to separate page." msgstr "" #: src/meta/doc.md:78 msgid "/// bar docs\n" msgstr "" #: src/meta/doc.md:81 msgid "/// the docs for Bar\n" msgstr "" #: src/meta/doc.md:86 msgid "`no_inline`" msgstr "" #: src/meta/doc.md:88 msgid "Used to prevent linking out to separate page or anywhere." msgstr "" #: src/meta/doc.md:91 msgid "// Example from libcore/prelude\n" msgstr "" #: src/meta/doc.md:96 msgid "`hidden`" msgstr "" #: src/meta/doc.md:98 msgid "Using this tells `rustdoc` not to include this in documentation:" msgstr "" #: src/meta/doc.md:101 msgid "// Example from the futures-rs library\n" msgstr "" #: src/meta/doc.md:106 msgid "" "For documentation, `rustdoc` is widely used by the community. It's what is " "used to generate the [std library docs](https://doc.rust-lang.org/std/)." msgstr "" #: src/meta/doc.md:111 msgid "" "[The Rust Book: Making Useful Documentation Comments](https://doc.rust-lang." "org/book/ch14-02-publishing-to-crates-io.html#making-useful-documentation-" "comments)" msgstr "" #: src/meta/doc.md:112 msgid "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/index.html)" msgstr "" #: src/meta/doc.md:113 msgid "" "[The Reference: Doc comments](https://doc.rust-lang.org/stable/reference/" "comments.html#doc-comments)" msgstr "" #: src/meta/doc.md:114 msgid "" "[RFC 1574: API Documentation Conventions](https://rust-lang.github.io/" "rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-" "conventions-text)" msgstr "" #: src/meta/doc.md:115 msgid "" "[RFC 1946: Relative links to other items from doc comments (intra-rustdoc " "links)](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)" msgstr "" #: src/meta/doc.md:116 msgid "" "[Is there any documentation style guide for comments? (reddit)](https://www." "reddit.com/r/rust/comments/ahb50s/" "is_there_any_documentation_style_guide_for/)" msgstr "" #: src/meta/playground.md:3 msgid "" "The [Rust Playground](https://play.rust-lang.org/) is a way to experiment " "with Rust code through a web interface." msgstr "" #: src/meta/playground.md:6 msgid "Using it with `mdbook`" msgstr "" #: src/meta/playground.md:8 msgid "" "In [`mdbook`](https://github.com/rust-lang/mdBook), you can make code " "examples playable and editable." msgstr "" #: src/meta/playground.md:16 msgid "" "This allows the reader to both run your code sample, but also modify and " "tweak it. The key here is the adding of the word `editable` to your " "codefence block separated by a comma." msgstr "" #: src/meta/playground.md:26 msgid "" "Additionally, you can add `ignore` if you want `mdbook` to skip your code " "when it builds and tests." msgstr "" #: src/meta/playground.md:35 msgid "Using it with docs" msgstr "" #: src/meta/playground.md:37 msgid "" "You may have noticed in some of the [official Rust docs](https://doc.rust-" "lang.org/core/) a button that says \"Run\", which opens the code sample up " "in a new tab in Rust Playground. This feature is enabled if you use the " "`#[doc]` attribute called [`html_playground_url`](https://doc.rust-lang.org/" "rustdoc/write-documentation/the-doc-attribute.html#html_playground_url)." msgstr "" #: src/meta/playground.md:42 msgid "" "````text\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" msgstr "" #: src/meta/playground.md:51 msgid "[The Rust Playground](https://play.rust-lang.org/)" msgstr "" #: src/meta/playground.md:52 msgid "" "[The Rust Playground On Github](https://github.com/integer32llc/rust-" "playground/)" msgstr "" #: src/meta/playground.md:53 msgid "" "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)" msgstr "" ================================================ FILE: po/ja.po ================================================ msgid "" msgstr "" "Project-Id-Version: Rust By Example\n" "POT-Creation-Date: 2024-06-14T21:07:36+09:00\n" "PO-Revision-Date: 2023-12-19 09:55+0900\n" "Last-Translator: Naoya Hatta \n" "Language-Team: Japanese https://github.com/rust-lang-ja/rust-by-example\n" "Language: ja\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" #: src/SUMMARY.md:1 msgid "Summary" msgstr "Summary" #: src/SUMMARY.md:3 msgid "Introduction" msgstr "はじめに" #: src/SUMMARY.md:5 src/hello.md:1 msgid "Hello World" msgstr "Hello World" #: src/SUMMARY.md:6 src/hello/comment.md:1 msgid "Comments" msgstr "コメント" #: src/SUMMARY.md:7 src/hello/print.md:1 msgid "Formatted print" msgstr "フォーマットして出力" #: src/SUMMARY.md:8 src/hello/print/print_debug.md:1 msgid "Debug" msgstr "Debug" #: src/SUMMARY.md:9 src/hello/print/print_display.md:1 msgid "Display" msgstr "Display" #: src/SUMMARY.md:10 src/hello/print/print_display/testcase_list.md:1 msgid "Testcase: List" msgstr "テストケース：リスト" #: src/SUMMARY.md:11 src/hello/print/fmt.md:1 msgid "Formatting" msgstr "フォーマット" #: src/SUMMARY.md:13 src/primitives.md:1 msgid "Primitives" msgstr "基本データ型" #: src/SUMMARY.md:14 src/primitives/literals.md:1 msgid "Literals and operators" msgstr "リテラルと演算子" #: src/SUMMARY.md:15 src/primitives/tuples.md:1 msgid "Tuples" msgstr "タプル" #: src/SUMMARY.md:16 src/primitives/array.md:1 msgid "Arrays and Slices" msgstr "配列とスライス" #: src/SUMMARY.md:18 src/custom_types.md:1 msgid "Custom Types" msgstr "カスタム型" #: src/SUMMARY.md:19 src/custom_types/structs.md:1 msgid "Structures" msgstr "構造体" #: src/SUMMARY.md:20 src/custom_types/enum.md:1 msgid "Enums" msgstr "列挙型" #: src/SUMMARY.md:21 src/custom_types/enum/enum_use.md:1 msgid "use" msgstr "use" #: src/SUMMARY.md:22 src/custom_types/enum/c_like.md:1 msgid "C-like" msgstr "C言語ライクな列挙型" #: src/SUMMARY.md:23 src/custom_types/enum/testcase_linked_list.md:1 msgid "Testcase: linked-list" msgstr "テストケース：連結リスト" #: src/SUMMARY.md:24 src/custom_types/constants.md:1 msgid "constants" msgstr "定数" #: src/SUMMARY.md:26 src/variable_bindings.md:1 msgid "Variable Bindings" msgstr "変数束縛" #: src/SUMMARY.md:27 src/SUMMARY.md:120 src/SUMMARY.md:123 #: src/variable_bindings/mut.md:1 src/scope/move/mut.md:1 #: src/scope/borrow/mut.md:1 msgid "Mutability" msgstr "ミュータビリティ" #: src/SUMMARY.md:28 src/variable_bindings/scope.md:1 msgid "Scope and Shadowing" msgstr "スコープとシャドーイング" #: src/SUMMARY.md:29 src/variable_bindings/declare.md:1 msgid "Declare first" msgstr "前方宣言" #: src/SUMMARY.md:30 src/variable_bindings/freeze.md:1 msgid "Freezing" msgstr "値の凍結" #: src/SUMMARY.md:32 src/types.md:1 msgid "Types" msgstr "型" #: src/SUMMARY.md:33 src/types/cast.md:1 msgid "Casting" msgstr "型キャスト" #: src/SUMMARY.md:34 src/types/literals.md:1 msgid "Literals" msgstr "リテラル" #: src/SUMMARY.md:35 src/types/inference.md:1 msgid "Inference" msgstr "型推論" #: src/SUMMARY.md:36 src/SUMMARY.md:124 src/types/alias.md:1 #: src/scope/borrow/alias.md:1 msgid "Aliasing" msgstr "エイリアス" #: src/SUMMARY.md:38 src/conversion.md:1 msgid "Conversion" msgstr "型変換" #: src/SUMMARY.md:39 src/conversion/from_into.md:1 msgid "`From` and `Into`" msgstr "`From`と`Into`" #: src/SUMMARY.md:40 src/conversion/try_from_try_into.md:1 msgid "`TryFrom` and `TryInto`" msgstr "`TryFrom`と`TryInto`" #: src/SUMMARY.md:41 msgid "To and from `String`s" msgstr "`String`との型変換" #: src/SUMMARY.md:43 src/expression.md:1 msgid "Expressions" msgstr "式" #: src/SUMMARY.md:45 src/flow_control.md:1 msgid "Flow of Control" msgstr "制御フロー" #: src/SUMMARY.md:46 src/flow_control/if_else.md:1 msgid "if/else" msgstr "if/else" #: src/SUMMARY.md:47 src/flow_control/loop.md:1 msgid "loop" msgstr "loop" #: src/SUMMARY.md:48 src/flow_control/loop/nested.md:1 msgid "Nesting and labels" msgstr "ネストとラベル" #: src/SUMMARY.md:49 src/flow_control/loop/return.md:1 msgid "Returning from loops" msgstr "loopが返す値" #: src/SUMMARY.md:50 src/flow_control/while.md:1 msgid "while" msgstr "while" #: src/SUMMARY.md:51 src/flow_control/for.md:3 msgid "for and range" msgstr "for と range" #: src/SUMMARY.md:52 src/flow_control/match.md:1 msgid "match" msgstr "match" #: src/SUMMARY.md:53 src/flow_control/match/destructuring.md:1 msgid "Destructuring" msgstr "デストラクト" #: src/SUMMARY.md:54 #: src/flow_control/match/destructuring/destructure_tuple.md:1 msgid "tuples" msgstr "タプル" #: src/SUMMARY.md:55 #: src/flow_control/match/destructuring/destructure_slice.md:1 msgid "arrays/slices" msgstr "配列とスライス" #: src/SUMMARY.md:56 src/flow_control/match/destructuring/destructure_enum.md:1 msgid "enums" msgstr "列挙型" #: src/SUMMARY.md:57 #: src/flow_control/match/destructuring/destructure_pointers.md:1 msgid "pointers/ref" msgstr "ポインタとref" #: src/SUMMARY.md:58 #: src/flow_control/match/destructuring/destructure_structures.md:1 msgid "structs" msgstr "構造体" #: src/SUMMARY.md:59 src/flow_control/match/guard.md:1 msgid "Guards" msgstr "ガード" #: src/SUMMARY.md:60 src/flow_control/match/binding.md:1 msgid "Binding" msgstr "束縛" #: src/SUMMARY.md:61 src/flow_control/if_let.md:1 msgid "if let" msgstr "if let" #: src/SUMMARY.md:62 src/flow_control/let_else.md:1 msgid "let-else" msgstr "let-else" #: src/SUMMARY.md:63 src/flow_control/while_let.md:1 msgid "while let" msgstr "while let" #: src/SUMMARY.md:65 src/SUMMARY.md:103 src/SUMMARY.md:128 src/fn.md:1 #: src/generics/gen_fn.md:1 src/scope/lifetime/fn.md:1 msgid "Functions" msgstr "関数" #: src/SUMMARY.md:66 src/SUMMARY.md:129 src/scope/lifetime/methods.md:1 msgid "Methods" msgstr "メソッド" #: src/SUMMARY.md:67 src/fn/closures.md:1 msgid "Closures" msgstr "クロージャ" #: src/SUMMARY.md:68 src/fn/closures/capture.md:1 msgid "Capturing" msgstr "要素の捕捉" #: src/SUMMARY.md:69 src/fn/closures/input_parameters.md:1 msgid "As input parameters" msgstr "捕捉時の型推論" #: src/SUMMARY.md:70 src/fn/closures/anonymity.md:1 msgid "Type anonymity" msgstr "匿名型" #: src/SUMMARY.md:71 src/fn/closures/input_functions.md:1 msgid "Input functions" msgstr "関数を受け取る関数" #: src/SUMMARY.md:72 src/fn/closures/output_parameters.md:1 msgid "As output parameters" msgstr "クロージャを返す関数" #: src/SUMMARY.md:73 src/fn/closures/closure_examples.md:1 msgid "Examples in `std`" msgstr "`std`における使用例" #: src/SUMMARY.md:74 src/fn/closures/closure_examples/iter_any.md:1 msgid "Iterator::any" msgstr "Iterator::any" #: src/SUMMARY.md:75 src/fn/closures/closure_examples/iter_find.md:1 msgid "Searching through iterators" msgstr "イテレータによる検索" #: src/SUMMARY.md:76 src/fn/hof.md:1 msgid "Higher Order Functions" msgstr "高階関数" #: src/SUMMARY.md:77 src/fn/diverging.md:1 msgid "Diverging functions" msgstr "発散する関数" #: src/SUMMARY.md:79 src/mod.md:1 msgid "Modules" msgstr "モジュール" #: src/SUMMARY.md:80 src/mod/visibility.md:1 msgid "Visibility" msgstr "可視性" #: src/SUMMARY.md:81 src/mod/struct_visibility.md:1 msgid "Struct visibility" msgstr "構造体の場合" #: src/SUMMARY.md:82 src/mod/use.md:1 msgid "The `use` declaration" msgstr "`use`宣言" #: src/SUMMARY.md:83 src/mod/super.md:1 msgid "`super` and `self`" msgstr "`super`と`self`" #: src/SUMMARY.md:84 src/mod/split.md:1 msgid "File hierarchy" msgstr "ファイルの階層構造" #: src/SUMMARY.md:86 src/SUMMARY.md:98 src/crates.md:1 src/attribute/crate.md:1 #: src/std_misc/arg.md:30 msgid "Crates" msgstr "クレート" #: src/SUMMARY.md:87 src/crates/lib.md:1 msgid "Creating a Library" msgstr "ライブラリの作成" #: src/SUMMARY.md:88 src/crates/using_lib.md:1 msgid "Using a Library" msgstr "ライブラリの利用" #: src/SUMMARY.md:90 src/cargo.md:1 msgid "Cargo" msgstr "Cargo" #: src/SUMMARY.md:91 src/cargo/deps.md:1 msgid "Dependencies" msgstr "依存関係" #: src/SUMMARY.md:92 src/cargo/conventions.md:1 msgid "Conventions" msgstr "規約" #: src/SUMMARY.md:93 msgid "Tests" msgstr "テスト" #: src/SUMMARY.md:94 src/cargo/build_scripts.md:1 msgid "Build Scripts" msgstr "ビルドスクリプト" #: src/SUMMARY.md:96 src/attribute.md:1 msgid "Attributes" msgstr "アトリビュート" #: src/SUMMARY.md:97 src/attribute/unused.md:1 msgid "`dead_code`" msgstr "`dead_code`" #: src/SUMMARY.md:99 src/attribute/cfg.md:1 msgid "`cfg`" msgstr "`cfg`" #: src/SUMMARY.md:100 src/attribute/cfg/custom.md:1 msgid "Custom" msgstr "条件の追加" #: src/SUMMARY.md:102 src/generics.md:1 msgid "Generics" msgstr "ジェネリクス" #: src/SUMMARY.md:104 src/generics/impl.md:1 msgid "Implementation" msgstr "実装" #: src/SUMMARY.md:105 src/SUMMARY.md:131 src/SUMMARY.md:137 #: src/generics/gen_trait.md:1 src/scope/lifetime/trait.md:1 src/trait.md:1 msgid "Traits" msgstr "トレイト" #: src/SUMMARY.md:106 src/SUMMARY.md:132 src/generics/bounds.md:1 #: src/scope/lifetime/lifetime_bounds.md:1 msgid "Bounds" msgstr "境界" #: src/SUMMARY.md:107 src/generics/bounds/testcase_empty.md:1 msgid "Testcase: empty bounds" msgstr "テストケース：空トレイト" #: src/SUMMARY.md:108 src/generics/multi_bounds.md:1 msgid "Multiple bounds" msgstr "複数の境界" #: src/SUMMARY.md:109 src/generics/where.md:1 msgid "Where clauses" msgstr "Where句" #: src/SUMMARY.md:110 src/generics/new_types.md:1 msgid "New Type Idiom" msgstr "ニュータイプイディオム" #: src/SUMMARY.md:111 src/generics/assoc_items.md:1 msgid "Associated items" msgstr "関連要素" #: src/SUMMARY.md:112 src/generics/assoc_items/the_problem.md:1 msgid "The Problem" msgstr "関連要素が必要になる状況" #: src/SUMMARY.md:113 src/generics/assoc_items/types.md:1 msgid "Associated types" msgstr "関連型" #: src/SUMMARY.md:114 src/generics/phantom.md:1 msgid "Phantom type parameters" msgstr "幽霊型パラメータ" #: src/SUMMARY.md:115 src/generics/phantom/testcase_units.md:1 msgid "Testcase: unit clarification" msgstr "テストケース：単位を扱う" #: src/SUMMARY.md:117 src/scope.md:1 msgid "Scoping rules" msgstr "スコープの規則" #: src/SUMMARY.md:118 src/scope/raii.md:1 msgid "RAII" msgstr "RAII" #: src/SUMMARY.md:119 src/scope/move.md:1 msgid "Ownership and moves" msgstr "所有権とムーブ" #: src/SUMMARY.md:121 src/scope/move/partial_move.md:1 msgid "Partial moves" msgstr "部分的ムーブ" #: src/SUMMARY.md:122 src/scope/borrow.md:1 msgid "Borrowing" msgstr "借用" #: src/SUMMARY.md:125 src/scope/borrow/ref.md:1 msgid "The ref pattern" msgstr "refパターン" #: src/SUMMARY.md:126 src/scope/lifetime.md:1 msgid "Lifetimes" msgstr "ライフタイム" #: src/SUMMARY.md:127 src/scope/lifetime/explicit.md:1 msgid "Explicit annotation" msgstr "明示的アノテーション" #: src/SUMMARY.md:130 src/scope/lifetime/struct.md:1 msgid "Structs" msgstr "構造体" #: src/SUMMARY.md:133 src/scope/lifetime/lifetime_coercion.md:1 msgid "Coercion" msgstr "強制" #: src/SUMMARY.md:134 src/scope/lifetime/static_lifetime.md:1 msgid "Static" msgstr "スタティックライフタイム" #: src/SUMMARY.md:135 src/scope/lifetime/elision.md:1 msgid "Elision" msgstr "省略" #: src/SUMMARY.md:138 src/trait/derive.md:1 msgid "Derive" msgstr "導出(Derive)" #: src/SUMMARY.md:139 src/trait/dyn.md:1 msgid "Returning Traits with `dyn`" msgstr "`dyn`を利用してトレイトを返す" #: src/SUMMARY.md:140 src/trait/ops.md:1 msgid "Operator Overloading" msgstr "演算子のオーバーロード" #: src/SUMMARY.md:141 src/trait/drop.md:1 msgid "Drop" msgstr "ドロップ" #: src/SUMMARY.md:142 src/trait/iter.md:1 msgid "Iterators" msgstr "イテレータ" #: src/SUMMARY.md:143 src/trait/impl_trait.md:1 msgid "`impl Trait`" msgstr "`impl Trait`" #: src/SUMMARY.md:144 src/trait/clone.md:1 msgid "Clone" msgstr "クローン" #: src/SUMMARY.md:145 src/trait/supertraits.md:1 msgid "Supertraits" msgstr "スーパートレイト" #: src/SUMMARY.md:146 src/trait/disambiguating.md:1 msgid "Disambiguating overlapping traits" msgstr "トレイトの曖昧性解決" #: src/SUMMARY.md:148 src/macros.md:1 msgid "macro_rules!" msgstr "macro_rules!" #: src/SUMMARY.md:149 src/macros/syntax.md:1 msgid "Syntax" msgstr "構文" #: src/SUMMARY.md:150 src/macros/designators.md:1 msgid "Designators" msgstr "識別子" #: src/SUMMARY.md:151 src/macros/overload.md:1 msgid "Overload" msgstr "オーバーロード" #: src/SUMMARY.md:152 src/macros/repeat.md:1 msgid "Repeat" msgstr "繰り返し" #: src/SUMMARY.md:153 src/macros/dry.md:1 msgid "DRY (Don't Repeat Yourself)" msgstr "DRY (Don't Repeat Yourself)" #: src/SUMMARY.md:154 msgid "DSL (Domain Specific Languages)" msgstr "Domain Specific Languages (ドメイン特化言語、DSLs)" #: src/SUMMARY.md:155 msgid "Variadics" msgstr "可変個引数" #: src/SUMMARY.md:157 src/error.md:1 msgid "Error handling" msgstr "エラーハンドリング" #: src/SUMMARY.md:158 src/error/panic.md:1 msgid "`panic`" msgstr "`panic`" #: src/SUMMARY.md:159 msgid "`abort` & `unwind`" msgstr "`abort`と`unwind`" #: src/SUMMARY.md:160 src/error/option_unwrap.md:1 msgid "`Option` & `unwrap`" msgstr "`Option`と`unwrap`" #: src/SUMMARY.md:161 src/error/option_unwrap/question_mark.md:1 msgid "Unpacking options with `?`" msgstr "`?`による`Option`のアンパック" #: src/SUMMARY.md:162 src/error/option_unwrap/map.md:1 msgid "Combinators: `map`" msgstr "コンビネータ：`map`" #: src/SUMMARY.md:163 src/error/option_unwrap/and_then.md:1 msgid "Combinators: `and_then`" msgstr "コンビネータ：`and_then`" #: src/SUMMARY.md:164 msgid "Defaults: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`" msgstr "" #: src/SUMMARY.md:165 src/SUMMARY.md:183 src/error/result.md:1 #: src/std/result.md:1 msgid "`Result`" msgstr "`Result`" #: src/SUMMARY.md:166 src/error/result/result_map.md:1 msgid "`map` for `Result`" msgstr "`Result`の`map`" #: src/SUMMARY.md:167 src/error/result/result_alias.md:1 msgid "aliases for `Result`" msgstr "`Result`に対するエイリアス" #: src/SUMMARY.md:168 src/error/result/early_returns.md:1 msgid "Early returns" msgstr "早期リターン" #: src/SUMMARY.md:169 src/error/result/enter_question_mark.md:1 msgid "Introducing `?`" msgstr "`?`の導入" #: src/SUMMARY.md:170 src/error/multiple_error_types.md:1 msgid "Multiple error types" msgstr "複数のエラー型" #: src/SUMMARY.md:171 src/error/multiple_error_types/option_result.md:1 msgid "Pulling `Result`s out of `Option`s" msgstr "`Option`から`Result`を取り出す" #: src/SUMMARY.md:172 src/error/multiple_error_types/define_error_type.md:1 msgid "Defining an error type" msgstr "エラー型を定義する" #: src/SUMMARY.md:173 src/error/multiple_error_types/boxing_errors.md:1 msgid "`Box`ing errors" msgstr "エラーを`Box`する" #: src/SUMMARY.md:174 src/error/multiple_error_types/reenter_question_mark.md:1 msgid "Other uses of `?`" msgstr "`?`の他の活用法" #: src/SUMMARY.md:175 src/error/multiple_error_types/wrap_error.md:1 msgid "Wrapping errors" msgstr "エラーをラップする" #: src/SUMMARY.md:176 src/error/iter_result.md:1 msgid "Iterating over `Result`s" msgstr "`Result`をイテレートする" #: src/SUMMARY.md:178 src/std.md:1 msgid "Std library types" msgstr "標準ライブラリの型" #: src/SUMMARY.md:179 src/std/box.md:1 msgid "Box, stack and heap" msgstr "Box、スタックとヒープ" #: src/SUMMARY.md:180 src/std/vec.md:1 msgid "Vectors" msgstr "ベクタ型" #: src/SUMMARY.md:181 src/std/str.md:1 msgid "Strings" msgstr "文字列" #: src/SUMMARY.md:182 src/std/option.md:1 msgid "`Option`" msgstr "`Option`" #: src/SUMMARY.md:184 src/std/result/question_mark.md:1 msgid "`?`" msgstr "`?`" #: src/SUMMARY.md:185 src/std/panic.md:1 msgid "`panic!`" msgstr "`panic!`" #: src/SUMMARY.md:186 src/std/hash.md:1 msgid "HashMap" msgstr "ハッシュマップ" #: src/SUMMARY.md:187 src/std/hash/alt_key_types.md:1 msgid "Alternate/custom key types" msgstr "キー型の変種" #: src/SUMMARY.md:188 src/std/hash/hashset.md:1 msgid "HashSet" msgstr "ハッシュ集合" #: src/SUMMARY.md:189 src/std/rc.md:1 msgid "`Rc`" msgstr "`Rc`" #: src/SUMMARY.md:190 msgid "`Arc`" msgstr "`Arc`" #: src/SUMMARY.md:192 src/std_misc.md:1 msgid "Std misc" msgstr "標準ライブラリのその他" #: src/SUMMARY.md:193 src/std_misc.md:6 src/std_misc/threads.md:1 msgid "Threads" msgstr "スレッド" #: src/SUMMARY.md:194 src/std_misc/threads/testcase_mapreduce.md:1 msgid "Testcase: map-reduce" msgstr "テストケース：map-reduce" #: src/SUMMARY.md:195 src/std_misc.md:7 src/std_misc/channels.md:1 msgid "Channels" msgstr "チャネル" #: src/SUMMARY.md:196 src/std_misc/path.md:1 msgid "Path" msgstr "ファイルパス" #: src/SUMMARY.md:197 src/std_misc.md:8 src/std_misc/file.md:1 msgid "File I/O" msgstr "ファイル I/O" #: src/SUMMARY.md:198 src/std_misc/file/open.md:1 msgid "`open`" msgstr "`open`" #: src/SUMMARY.md:199 src/std_misc/file/create.md:1 msgid "`create`" msgstr "`create`" #: src/SUMMARY.md:200 src/std_misc/file/read_lines.md:1 msgid "`read_lines`" msgstr "`read lines`" #: src/SUMMARY.md:201 src/std_misc/process.md:1 msgid "Child processes" msgstr "子プロセス" #: src/SUMMARY.md:202 src/std_misc/process/pipe.md:1 msgid "Pipes" msgstr "パイプ" #: src/SUMMARY.md:203 src/std_misc/process/wait.md:1 msgid "Wait" msgstr "ドロップの延期" #: src/SUMMARY.md:204 src/std_misc/fs.md:1 msgid "Filesystem Operations" msgstr "ファイルシステムとのやり取り" #: src/SUMMARY.md:205 src/std_misc/arg.md:1 msgid "Program arguments" msgstr "引数処理" #: src/SUMMARY.md:206 src/std_misc/arg/matching.md:1 msgid "Argument parsing" msgstr "引数のパース" #: src/SUMMARY.md:207 src/std_misc/ffi.md:1 msgid "Foreign Function Interface" msgstr "他言語関数インターフェイス" #: src/SUMMARY.md:209 src/cargo/test.md:1 src/testing.md:1 msgid "Testing" msgstr "テスト" #: src/SUMMARY.md:210 src/testing/unit_testing.md:1 msgid "Unit testing" msgstr "ユニットテスト" #: src/SUMMARY.md:211 src/testing/doc_testing.md:1 msgid "Documentation testing" msgstr "ドキュメンテーションテスト" #: src/SUMMARY.md:212 src/testing/integration_testing.md:1 msgid "Integration testing" msgstr "統合テスト" #: src/SUMMARY.md:213 msgid "Dev-dependencies" msgstr "開発中の依存関係" #: src/SUMMARY.md:215 src/unsafe.md:1 msgid "Unsafe Operations" msgstr "安全でない操作" #: src/SUMMARY.md:216 src/unsafe/asm.md:1 msgid "Inline assembly" msgstr "インラインアセンブリ" #: src/SUMMARY.md:218 src/compatibility.md:1 msgid "Compatibility" msgstr "互換性" #: src/SUMMARY.md:219 src/compatibility/raw_identifiers.md:1 msgid "Raw identifiers" msgstr "生識別子" #: src/SUMMARY.md:221 src/meta.md:1 msgid "Meta" msgstr "周辺情報" #: src/SUMMARY.md:222 src/meta/doc.md:1 msgid "Documentation" msgstr "ドキュメンテーション" #: src/SUMMARY.md:223 src/meta/playground.md:1 msgid "Playground" msgstr "プレイグラウンド" #: src/index.md:1 msgid "Rust by Example" msgstr "Rust by Example" #: src/index.md:3 msgid "" "[Rust](https://www.rust-lang.org/) is a modern systems programming language " "focusing on safety, speed, and concurrency. It accomplishes these goals by " "being memory safe without using garbage collection." msgstr "" "[Rust](https://www.rust-lang.org/) は安全性、速度、並列性にフォーカスした現代" "的なシステムプログラミング用のプログラミング言語です。ガベージコレクション無" "しでメモリ安全であることが、これを可能にしています。" #: src/index.md:7 msgid "" "Rust by Example (RBE) is a collection of runnable examples that illustrate " "various Rust concepts and standard libraries. To get even more out of these " "examples, don't forget to [install Rust locally](https://www.rust-lang.org/" "tools/install) and check out the [official docs](https://doc.rust-lang.org/" "std/). Additionally for the curious, you can also [check out the source code " "for this site](https://github.com/rust-lang/rust-by-example)." msgstr "" "Rust by Example(RBE)はRustの実行可能なサンプルスクリプト集で、ここではRustの" "様々なコンセプトと標準ライブラリを紹介していきます。この例をより活用するため" "には[Rustをローカルにインストール](https://www.rust-lang.org/tools/install)" "し、[公式ドキュメント](https://doc.rust-lang.org/std/)をチェックすることをお" "すすめします。興味がある方は[このサイト自体のソース](https://github.com/rust-" "lang/rust-by-example)のチェックもどうぞ。" #: src/index.md:12 msgid "Now let's begin!" msgstr "それでははじめましょう!" #: src/index.md:14 msgid "[Hello World](hello.md) - Start with a traditional Hello World program." msgstr "" "[Hello World](hello.md) - お決まりのHello Worldプログラムから始めましょう。" #: src/index.md:16 msgid "" "[Primitives](primitives.md) - Learn about signed integers, unsigned integers " "and other primitives." msgstr "" "[基本データ型](primitives.md) - 符号付き整数や符号無し整数、その他の基本デー" "タ型について学びましょう。" #: src/index.md:18 msgid "[Custom Types](custom_types.md) - `struct` and `enum`." msgstr "[カスタム型](custom_types.md) - `struct`と`enum`について。" #: src/index.md:20 msgid "" "[Variable Bindings](variable_bindings.md) - mutable bindings, scope, " "shadowing." msgstr "" "[変数の束縛](variable_bindings.md) - ミュータブルな束縛、スコープ、シャドーイ" "ングについて。" #: src/index.md:22 msgid "[Types](types.md) - Learn about changing and defining types." msgstr "[型](types.md) - 型を変更したり定義したりすることを学びましょう。" #: src/index.md:24 msgid "" "[Conversion](conversion.md) - Convert between different types, such as " "strings, integers, and floats." msgstr "" "[型変換](conversion.md) - 文字列や整数、浮動小数点数など様々な型から型への変" "換について。" #: src/index.md:26 msgid "" "[Expressions](expression.md) - Learn about Expressions & how to use them." msgstr "[式](expression.md) - 式とその使い方について学びましょう。" #: src/index.md:28 msgid "[Flow of Control](flow_control.md) - `if`/`else`, `for`, and others." msgstr "[制御フロー](flow_control.md) - `if`や`else`、`for`など。" #: src/index.md:30 msgid "" "[Functions](fn.md) - Learn about Methods, Closures and Higher Order " "Functions." msgstr "[関数](fn.md) - メソッド、クロージャ、高階関数について。" #: src/index.md:32 msgid "[Modules](mod.md) - Organize code using modules" msgstr "[モジュール](mod.md) - プログラムをモジュールを使って整理しましょう。" #: src/index.md:34 msgid "" "[Crates](crates.md) - A crate is a compilation unit in Rust. Learn to create " "a library." msgstr "" "[クレート](crates.md) - クレートは、Rustにおいてコンパイルされる単位です。ラ" "イブラリの作り方について学びます。" #: src/index.md:36 msgid "" "[Cargo](cargo.md) - Go through some basic features of the official Rust " "package management tool." msgstr "" "[Cargo](cargo.md) - Rustの公式パッケージマネージャの基本的な機能を学びます。" #: src/index.md:38 msgid "" "[Attributes](attribute.md) - An attribute is metadata applied to some " "module, crate or item." msgstr "" "[アトリビュート](attribute.md) - アトリビュートは、モジュールやクレート、要素" "に適用されるメタデータです。" #: src/index.md:40 msgid "" "[Generics](generics.md) - Learn about writing a function or data type which " "can work for multiple types of arguments." msgstr "" "[ジェネリクス](generics.md) - 様々な型の引数を取れる関数やデータ型を書く方法" "を学びましょう。" #: src/index.md:42 msgid "" "[Scoping rules](scope.md) - Scopes play an important part in ownership, " "borrowing, and lifetimes." msgstr "" "[スコープの規則](scope.md) - スコープは所有権、借用、ライフタイムにおいて重要" "な役割を果たします。" #: src/index.md:44 msgid "" "[Traits](trait.md) - A trait is a collection of methods defined for an " "unknown type: `Self`" msgstr "" "[トレイト](trait.md) - トレイトとは、未知の型`Self`に対して定義された一連のメ" "ソッドです。" #: src/index.md:46 msgid "" "[Macros](macros.md) - Macros are a way of writing code that writes other " "code, which is known as metaprogramming." msgstr "" "[マクロ](macros.md) - マクロはコードを書くためのコードです。メタプログラミン" "グとしても知られています。" #: src/index.md:48 msgid "[Error handling](error.md) - Learn Rust way of handling failures." msgstr "" "[エラーハンドリング](error.md) - 失敗に対処するRust流のやり方を学びましょう。" #: src/index.md:50 msgid "" "[Std library types](std.md) - Learn about some custom types provided by " "`std` library." msgstr "" "[標準ライブラリの型](std.md) - `std`ライブラリによって提供されるいくつかのカ" "スタム型について学びます。" #: src/index.md:52 msgid "[Std misc](std_misc.md) - More custom types for file handling, threads." msgstr "" "[標準ライブラリのその他](std_misc.md) - ファイルハンドリングとスレッドのため" "のカスタム型について。" #: src/index.md:54 msgid "[Testing](testing.md) - All sorts of testing in Rust." msgstr "[テスト](testing.md) - Rustにおけるテストのすべて。" #: src/index.md:56 msgid "" "[Unsafe Operations](unsafe.md) - Learn about entering a block of unsafe " "operations." msgstr "[安全でない操作](unsafe.md) - 安全でない操作について学びましょう。" #: src/index.md:58 msgid "" "[Compatibility](compatibility.md) - Handling Rust's evolution and potential " "compatibility issues." msgstr "[互換性](compatibility.md) - Rustの進化と互換性について。" #: src/index.md:60 msgid "[Meta](meta.md) - Documentation, Benchmarking." msgstr "[周辺情報](meta.md) - ドキュメント、ベンチマークの方法。" #: src/hello.md:3 msgid "This is the source code of the traditional Hello World program." msgstr "ここでは伝統的な \"Hello World!\" プログラムのソースを紹介します。" #: src/hello.md:6 msgid "" "// This is a comment, and is ignored by the compiler.\n" "// You can test this code by clicking the \"Run\" button over there ->\n" "// or if you prefer to use your keyboard, you can use the \"Ctrl + Enter\"\n" "// shortcut.\n" msgstr "" "// これはコメントです。コンパイラによって無視されます。\n" "// 右にある「Run」ボタンからこのコードをテストできます。\n" "// キーボードを使いたければ「Ctrl + Enter」もOKです。\n" #: src/hello.md:10 msgid "" "// This code is editable, feel free to hack it!\n" "// You can always return to the original code by clicking the \"Reset\" " "button ->\n" msgstr "" "// このコードは編集可能です。ぜひハックしてみましょう！\n" "// 「Reset」ボタンでいつでも元のコードに戻すことができます ->\n" #: src/hello.md:13 msgid "// This is the main function.\n" msgstr "// main関数です。\n" #: src/hello.md:16 msgid "// Statements here are executed when the compiled binary is called.\n" msgstr "// コンパイルされたバイナリが実行されるとこの関数が呼び出されます。\n" #: src/hello.md:18 msgid "// Print text to the console.\n" msgstr "// コンソールに文字列を出力します。\n" #: src/hello.md:19 src/error/result.md:55 src/meta/playground.md:12 msgid "\"Hello World!\"" msgstr "\"Hello World!\"" #: src/hello.md:23 msgid "`println!` is a [_macro_](macros.md) that prints text to the console." msgstr "" "`println!`は文字列をコンソールに出力するための[ *マクロ* ](macros.md)です。" #: src/hello.md:26 msgid "A binary can be generated using the Rust compiler: `rustc`." msgstr "" "バイナリファイルは`rustc`と呼ばれるRustコンパイラを用いて生成することができま" "す。" #: src/hello.md:32 msgid "`rustc` will produce a `hello` binary that can be executed." msgstr "すると`hello`という名前の実行可能なバイナリファイルができます。" #: src/hello.md:39 src/hello/print/print_display.md:107 #: src/hello/print/print_display/testcase_list.md:53 src/hello/print/fmt.md:70 #: src/primitives/tuples.md:64 src/custom_types/structs.md:89 msgid "Activity" msgstr "演習" #: src/hello.md:41 msgid "" "Click 'Run' above to see the expected output. Next, add a new line with a " "second `println!` macro so that the output shows:" msgstr "" "上に書いている 'Run' をクリックしてアウトプットを見てみましょう。次に、" "`println!`マクロをもう一行追加してアウトプットがどうなるか見てみましょう。" #: src/hello/comment.md:3 msgid "" "Any program requires comments, and Rust supports a few different varieties:" msgstr "" "あらゆるプログラムにはコメントが必要です。Rustには何種類かのコメントがありま" "す" #: src/hello/comment.md:6 msgid "_Regular comments_ which are ignored by the compiler:" msgstr "*通常のコメント* これはコンパイラによって完全に無視されます。" #: src/hello/comment.md:7 msgid "`// Line comments which go to the end of the line.`" msgstr "`// 行末までコメントアウト`" #: src/hello/comment.md:8 msgid "`/* Block comments which go to the closing delimiter. */`" msgstr "`/* ブロックによって囲まれた部分をコメントアウト */`" #: src/hello/comment.md:9 msgid "" "_Doc comments_ which are parsed into HTML library [documentation](../meta/" "doc.md):" msgstr "" "*ドキュメンテーションコメント* ライブラリの[ドキュメンテーション](../meta/" "doc.md)としてHTMLにパースされます。" #: src/hello/comment.md:10 msgid "`/// Generate library docs for the following item.`" msgstr "`/// このコメントの下の内容に関するドキュメントとなります。`" #: src/hello/comment.md:11 msgid "`//! Generate library docs for the enclosing item.`" msgstr "`//! このコメントを含むソースのドキュメントになります。`" #: src/hello/comment.md:15 msgid "" "// This is an example of a line comment.\n" " // There are two slashes at the beginning of the line.\n" " // And nothing written after these will be read by the compiler.\n" msgstr "" "// こちらはラインコメントです。\n" " // 一番左にスラッシュが2つある行と、何も書かれていない行は\n" " // どちらもコンパイラによって無視されます。\n" #: src/hello/comment.md:19 msgid "// println!(\"Hello, world!\");\n" msgstr "// println!(\"Hello, world!\");\n" #: src/hello/comment.md:21 msgid "// Run it. See? Now try deleting the two slashes, and run it again.\n" msgstr "// でしょ？では次に、左のスラッシュを消去してから実行してください。\n" #: src/hello/comment.md:23 msgid "" "/*\n" " * This is another type of comment, a block comment. In general,\n" " * line comments are the recommended comment style. But block comments\n" " * are extremely useful for temporarily disabling chunks of code.\n" " * /* Block comments can be /* nested, */ */ so it takes only a few\n" " * keystrokes to comment out everything in this main() function.\n" " * /*/*/* Try it yourself! */*/*/\n" " */" msgstr "" "/*\n" " * こちらはもう一つのタイプのコメントでブロックコメントと呼ばれます。\n" " * 普通はラインコメントの方が優れているのですが、こちらはコード片を\n" " * 一時的に無効にするときに役立つかもしれません。\n" " * /* ブロックコメントは /* ネストすることができるので */ */\n" " * わずかなキー入力でこのmain関数全体をコメントアウトできます。\n" " * /*/*/* 試してみてください！ */*/*/\n" " */" #: src/hello/comment.md:32 msgid "" "/*\n" " Note: The previous column of `*` was entirely for style. There's\n" " no actual need for it.\n" " */" msgstr "" "/*\n" " 注: 上のコメントにおける`*`列は見栄えのためでした。実際には必要ありませ" "ん。\n" " */" #: src/hello/comment.md:37 msgid "" "// You can manipulate expressions more easily with block comments\n" " // than with line comments. Try deleting the comment delimiters\n" " // to change the result:\n" msgstr "" "// ではブロックコメントがどのようにデバッグに役立つか見てみましょう。\n" " // 例えば下の例の場合、ブロックコメントがなくなれば結果が変わります。\n" #: src/hello/comment.md:40 msgid "/* 90 + */" msgstr "/* 90 + */" #: src/hello/comment.md:41 msgid "\"Is `x` 10 or 100? x = {}\"" msgstr "\"Is `x` 10 or 100? x = {}\"" #: src/hello/comment.md:45 src/hello/print.md:103 #: src/hello/print/print_debug.md:75 src/hello/print/print_display.md:118 #: src/hello/print/print_display/testcase_list.md:62 src/hello/print/fmt.md:89 #: src/primitives.md:55 src/custom_types/enum.md:100 #: src/custom_types/enum/enum_use.md:45 src/custom_types/enum/c_like.md:33 #: src/custom_types/enum/testcase_linked_list.md:77 #: src/custom_types/constants.md:35 src/types/alias.md:30 #: src/flow_control/for.md:121 #: src/flow_control/match/destructuring/destructure_tuple.md:25 #: src/flow_control/match/destructuring/destructure_slice.md:46 #: src/flow_control/match/destructuring/destructure_enum.md:48 #: src/flow_control/match/destructuring/destructure_pointers.md:63 #: src/flow_control/match/destructuring/destructure_structures.md:45 #: src/flow_control/match/guard.md:43 src/flow_control/match/binding.md:49 #: src/flow_control/if_let.md:122 src/flow_control/let_else.md:57 #: src/flow_control/while_let.md:56 src/fn/closures/capture.md:110 #: src/fn/closures/input_parameters.md:84 src/fn/closures/anonymity.md:47 #: src/fn/closures/input_functions.md:32 #: src/fn/closures/output_parameters.md:49 #: src/fn/closures/closure_examples/iter_any.md:50 #: src/fn/closures/closure_examples/iter_find.md:68 #: src/mod/struct_visibility.md:53 src/attribute/cfg.md:39 src/generics.md:59 #: src/generics/gen_fn.md:54 src/generics/impl.md:48 #: src/generics/gen_trait.md:39 src/generics/bounds.md:73 #: src/generics/bounds/testcase_empty.md:37 src/generics/multi_bounds.md:32 #: src/generics/where.md:49 src/generics/new_types.md:54 #: src/generics/assoc_items.md:10 src/generics/assoc_items/the_problem.md:62 #: src/generics/phantom.md:56 src/generics/phantom/testcase_units.md:75 #: src/scope/raii.md:92 src/scope/move/partial_move.md:45 #: src/scope/borrow/mut.md:56 src/scope/lifetime/explicit.md:68 #: src/scope/lifetime/fn.md:58 src/scope/lifetime/methods.md:24 #: src/scope/lifetime/struct.md:41 src/scope/lifetime/trait.md:28 #: src/scope/lifetime/lifetime_bounds.md:46 #: src/scope/lifetime/static_lifetime.md:131 src/scope/lifetime/elision.md:39 #: src/trait/derive.md:64 src/trait/supertraits.md:40 #: src/trait/disambiguating.md:60 src/error/option_unwrap/map.md:79 #: src/error/option_unwrap/and_then.md:73 #: src/error/option_unwrap/defaults.md:113 src/error/result/result_alias.md:41 #: src/error/multiple_error_types/boxing_errors.md:57 #: src/error/multiple_error_types/reenter_question_mark.md:74 #: src/error/multiple_error_types/wrap_error.md:91 src/std.md:12 #: src/std/rc.md:49 src/std_misc.md:12 #: src/std_misc/threads/testcase_mapreduce.md:128 src/std_misc/path.md:54 #: src/std_misc/fs.md:150 src/meta/doc.md:109 src/meta/playground.md:49 msgid "See also:" msgstr "参照" #: src/hello/comment.md:47 msgid "[Library documentation](../meta/doc.md)" msgstr "[ライブラリドキュメンテーション](../meta/doc.md)" #: src/hello/print.md:3 msgid "" "Printing is handled by a series of [`macros`](../macros.md) defined in " "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) some of which include:" msgstr "" "出力関係の機能は[`std::fmt`](https://doc.rust-lang.org/std/fmt/)で定義される" "幾つかの[マクロ](../macros.md)で扱うことができます。このマクロには以下が含ま" "れます。" #: src/hello/print.md:6 msgid "`format!`: write formatted text to [`String`](../std/str.md)" msgstr "" "`format!`：フォーマットされたテキストを[`String`](../std/str.md)に書き込みま" "す。" #: src/hello/print.md:7 msgid "" "`print!`: same as `format!` but the text is printed to the console (io::" "stdout)." msgstr "" "`print!`：`format!`と同様ですが、コンソール (io::stdout) にそのテキストを出力" "します。" #: src/hello/print.md:9 msgid "`println!`: same as `print!` but a newline is appended." msgstr "`println!`：`print!`と同じですが改行が付け加えられます。" #: src/hello/print.md:10 msgid "" "`eprint!`: same as `print!` but the text is printed to the standard error " "(io::stderr)." msgstr "" "`eprint!`：`format!`と同様ですが、標準エラー出力 (io::stderr) にそのテキスト" "を出力します。" #: src/hello/print.md:12 msgid "`eprintln!`: same as `eprint!` but a newline is appended." msgstr "`eprintln!`：`eprint!`と同じですが改行が付け加えられます。" #: src/hello/print.md:14 msgid "" "All parse text in the same fashion. As a plus, Rust checks formatting " "correctness at compile time." msgstr "" "すべて同じやり方でテキストをパースし、正しくフォーマットできるかコンパイル時" "にチェックします。" #: src/hello/print.md:19 msgid "" "// In general, the `{}` will be automatically replaced with any\n" " // arguments. These will be stringified.\n" msgstr "" "// 一般的に`{}`はどんな引数であろうと自動的に置き換えられます。\n" " // 例えば以下は文字列に変換されます。\n" #: src/hello/print.md:21 msgid "\"{} days\"" msgstr "\"{} days\"" #: src/hello/print.md:23 msgid "" "// Positional arguments can be used. Specifying an integer inside `{}`\n" " // determines which additional argument will be replaced. Arguments " "start\n" " // at 0 immediately after the format string.\n" msgstr "" "// 位置引数を利用できます。\n" " // `{}`の内側に整数を指定することで、どの引数で置換されるかが決まりま" "す。\n" " // 引数は0から始まります。\n" #: src/hello/print.md:26 msgid "\"{0}, this is {1}. {1}, this is {0}\"" msgstr "\"{0}, this is {1}. {1}, this is {0}\"" #: src/hello/print.md:26 src/scope/move/partial_move.md:20 msgid "\"Alice\"" msgstr "\"Alice\"" #: src/hello/print.md:26 src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Bob\"" msgstr "\"Bob\"" #: src/hello/print.md:28 msgid "// As can named arguments.\n" msgstr "// 名前での指定も可能です。\n" #: src/hello/print.md:29 msgid "\"{subject} {verb} {object}\"" msgstr "\"{subject} {verb} {object}\"" #: src/hello/print.md:30 msgid "\"the lazy dog\"" msgstr "\"the lazy dog\"" #: src/hello/print.md:31 msgid "\"the quick brown fox\"" msgstr "\"the quick brown fox\"" #: src/hello/print.md:32 msgid "\"jumps over\"" msgstr "\"jumps over\"" #: src/hello/print.md:34 msgid "" "// Different formatting can be invoked by specifying the format character\n" " // after a `:`.\n" msgstr "" "// `:`のあとにフォーマット文字を指定して\n" " // 異なるフォーマットにすることも可能です。\n" #: src/hello/print.md:36 msgid "\"Base 10: {}\"" msgstr "\"Base 10: {}\"" #: src/hello/print.md:36 msgid "// 69420\n" msgstr "// 69420\n" #: src/hello/print.md:37 msgid "\"Base 2 (binary): {:b}\"" msgstr "\"Base 2 (binary): {:b}\"" #: src/hello/print.md:37 msgid "// 10000111100101100\n" msgstr "// 10000111100101100\n" #: src/hello/print.md:38 msgid "\"Base 8 (octal): {:o}\"" msgstr "\"Base 8 (octal): {:o}\"" #: src/hello/print.md:38 msgid "// 207454\n" msgstr "// 207454\n" #: src/hello/print.md:39 msgid "\"Base 16 (hexadecimal): {:x}\"" msgstr "\"Base 16 (hexadecimal): {:x}\"" #: src/hello/print.md:39 msgid "// 10f2c\n" msgstr "// 10f2c\n" #: src/hello/print.md:41 msgid "" "// You can right-justify text with a specified width. This will\n" " // output \" 1\". (Four white spaces and a \"1\", for a total width " "of 5.)\n" msgstr "" "// 特定の幅に右詰めすることもできます。この出力は \" 1\" になります。\n" " // （4つの空白と\"1\"で合計幅は5です）\n" #: src/hello/print.md:43 msgid "\"{number:>5}\"" msgstr "\"{number:>5}\"" #: src/hello/print.md:45 msgid "// You can pad numbers with extra zeroes,\n" msgstr "// 数字を0埋めすることもできます。\n" #: src/hello/print.md:46 msgid "\"{number:0>5}\"" msgstr "\"{number:0>5}\"" #: src/hello/print.md:46 msgid "" "// 00001\n" " // and left-adjust by flipping the sign. This will output \"10000\".\n" msgstr "" "// 00001\n" " // 記号を反対にすると左寄せになり、\"10000\"が出力されます。\n" #: src/hello/print.md:48 msgid "\"{number:0<5}\"" msgstr "\"{number:0<5}\"" #: src/hello/print.md:48 msgid "// 10000\n" msgstr "// 10000\n" #: src/hello/print.md:50 msgid "" "// You can use named arguments in the format specifier by appending a `$`.\n" msgstr "" "// フォーマット指定子の中に`$`をつけることで名前付き引数を利用できます。\n" #: src/hello/print.md:51 msgid "\"{number:0>width$}\"" msgstr "\"{number:0>width$}\"" #: src/hello/print.md:53 msgid "" "// Rust even checks to make sure the correct number of arguments are used.\n" msgstr "// 引数の数が正しいかのチェックも行ってくれます。\n" #: src/hello/print.md:54 msgid "\"My name is {0}, {1} {0}\"" msgstr "\"My name is {0}, {1} {0}\"" #: src/hello/print.md:54 msgid "\"Bond\"" msgstr "\"Bond\"" #: src/hello/print.md:55 msgid "// FIXME ^ Add the missing argument: \"James\"\n" msgstr "// FIXME ^ 不足している引数 \"James\" を追加しましょう。\n" #: src/hello/print.md:57 msgid "" "// Only types that implement fmt::Display can be formatted with `{}`. User-\n" " // defined types do not implement fmt::Display by default.\n" msgstr "" "// `{}`でフォーマットできるのは、fmt::Displayを実装している型のみです。\n" " // ユーザーが定義した型はデフォルトではfmt::Displayを実装していません。\n" #: src/hello/print.md:60 msgid "// disable `dead_code` which warn against unused module\n" msgstr "// 未使用モジュールを警告する`dead_code`を無効化。\n" #: src/hello/print.md:63 msgid "" "// This will not compile because `Structure` does not implement\n" " // fmt::Display.\n" " // println!(\"This struct `{}` won't print...\", Structure(3));\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// `Structure`はfmt::Displayを実装していないので、\n" " // 以下はコンパイルできません。\n" " // println!(\"This struct `{}` won't print...\", Structure(3));\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/hello/print.md:68 msgid "" "// For Rust 1.58 and above, you can directly capture the argument from a\n" " // surrounding variable. Just like the above, this will output\n" " // \" 1\", 4 white spaces and a \"1\".\n" msgstr "" "// Rust 1.58以上では、周囲の変数から直接引数に取ることができます。\n" " // 上で見たように、以下のコードは4つのスペースと1を、\" 1\" と出力しま" "す。\n" #: src/hello/print.md:73 msgid "\"{number:>width$}\"" msgstr "\"{number:>width$}\"" #: src/hello/print.md:77 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) contains many [`traits`]" "(https://doc.rust-lang.org/std/fmt/#formatting-traits) which govern the " "display of text. The base form of two important ones are listed below:" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)はいくつもの[トレイト]" "(https://doc.rust-lang.org/std/fmt/#formatting-traits)を持ち、それによってど" "のようにディスプレイに表示されるかが決まります。特に大事な形式は以下の2つで" "す。" #: src/hello/print.md:80 msgid "" "`fmt::Debug`: Uses the `{:?}` marker. Format text for debugging purposes." msgstr "`fmt::Debug`：`{:?}`というマーカーを使用し、デバッグ目的に使われます。" #: src/hello/print.md:81 msgid "" "`fmt::Display`: Uses the `{}` marker. Format text in a more elegant, user " "friendly fashion." msgstr "" "`fmt::Display`：`{}`というマーカーを使用し、より美しく、ユーザフレンドリーに" "表示します。" #: src/hello/print.md:84 msgid "" "Here, we used `fmt::Display` because the std library provides " "implementations for these types. To print text for custom types, more steps " "are required." msgstr "" "この例で用いられている型は、標準ライブラリに含まれているため、ここでは`fmt::" "Display`を使用しています。カスタム型をテキストとして表示する場合は、さらに手" "順が必要です。" #: src/hello/print.md:87 msgid "" "Implementing the `fmt::Display` trait automatically implements the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "which allows us to [convert](../conversion/string.md) the type to [`String`]" "(../std/str.md)." msgstr "" "`fmt::Display`トレイトを実装すると、自動的に[`ToString`](https://doc.rust-" "lang.org/std/string/trait.ToString.html)トレイトが実装されます。これにより" "[`String`](../std/str.md)型への[型変換](../conversion/string.md)ができるよう" "になります。" #: src/hello/print.md:90 msgid "" "In _line 43_, `#[allow(dead_code)]` is an [attribute](../attribute.md) which " "only applies to the module after it." msgstr "" "*43行目* の`#[allow(dead_code)]`は、直後のモジュールにのみ適用される[アトリ" "ビュート](../attribute.md)です。" #: src/hello/print.md:92 msgid "Activities" msgstr "演習" #: src/hello/print.md:94 msgid "" "Fix the issue in the above code (see FIXME) so that it runs without error." msgstr "上の例（FIXME を参照）を実行した際に生じるエラーを修復しましょう。" #: src/hello/print.md:96 msgid "" "Try uncommenting the line that attempts to format the `Structure` struct " "(see TODO)" msgstr "" "`Structure`構造体をフォーマットする行をアンコメントしてみましょう。（TODO を" "参照）" #: src/hello/print.md:98 msgid "" "Add a `println!` macro call that prints: `Pi is roughly 3.142` by " "controlling the number of decimal places shown. For the purposes of this " "exercise, use `let pi = 3.141592` as an estimate for pi. (Hint: you may need " "to check the [`std::fmt`](https://doc.rust-lang.org/std/fmt/) documentation " "for setting the number of decimals to display)" msgstr "" "`println!`マクロを追加し、表示される小数部の桁数を調整して`Pi is roughly " "3.142`という文字列を出力しましょう。ただし、円周率の値は`let pi = 3.141592`を" "使ってください。（ヒント：小数部の桁数を調整する方法については、[`std::fmt`]" "(https://doc.rust-lang.org/std/fmt/)をチェックする必要があるかもしれませ" "ん。）" #: src/hello/print.md:105 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`macros`](../macros.md), " "[`struct`](../custom_types/structs.md), [`traits`](https://doc.rust-lang.org/" "std/fmt/#formatting-traits), and [`dead_code`](../attribute/unused.md)" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [マクロ](../macros.md), [構" "造体](../custom_types/structs.md), [トレイト](https://doc.rust-lang.org/std/" "fmt/#formatting-traits), [`dead_code`](../attribute/unused.md)" #: src/hello/print/print_debug.md:3 msgid "" "All types which want to use `std::fmt` formatting `traits` require an " "implementation to be printable. Automatic implementations are only provided " "for types such as in the `std` library. All others _must_ be manually " "implemented somehow." msgstr "" "`std::fmt`のフォーマット用`トレイト`を使用したい型は、出力できるように実装さ" "れている必要があります。`std`ライブラリの型のように自動で出力可能なものもあり" "ますが、他はすべて *手動で実装する必要があります。*" #: src/hello/print/print_debug.md:8 msgid "" "The `fmt::Debug` `trait` makes this very straightforward. _All_ types can " "`derive` (automatically create) the `fmt::Debug` implementation. This is not " "true for `fmt::Display` which must be manually implemented." msgstr "" "`fmt::Debug`という`トレイト`はこれを簡略化します。 *すべての* 型は`fmt::" "Debug`の実装を`導出(derive)`、（すなわち自動で作成）することができるためで" "す。`fmt::Display`の場合はやはり手動で実装しなくてはなりません。" #: src/hello/print/print_debug.md:13 msgid "" "// This structure cannot be printed either with `fmt::Display` or\n" "// with `fmt::Debug`.\n" msgstr "" "// この構造体は`fmt::Display`、`fmt::Debug`のいずれによっても\n" "// 出力することができません。\n" #: src/hello/print/print_debug.md:16 msgid "" "// The `derive` attribute automatically creates the implementation\n" "// required to make this `struct` printable with `fmt::Debug`.\n" msgstr "" "// `derive`アトリビュートは、\n" "// この構造体を`fmt::Debug`で出力するための実装を自動で提供します。\n" #: src/hello/print/print_debug.md:23 msgid "All `std` library types are automatically printable with `{:?}` too:" msgstr "" "`std`ライブラリの型の場合は、自動的に`{:?}`により出力可能になっています。" #: src/hello/print/print_debug.md:26 msgid "" "// Derive the `fmt::Debug` implementation for `Structure`. `Structure`\n" "// is a structure which contains a single `i32`.\n" msgstr "" "// `Structure`という構造体のための`fmt::Debug`を導出しています。\n" "// `Structure`は単一の`i32`をメンバに持っています。\n" #: src/hello/print/print_debug.md:30 msgid "" "// Put a `Structure` inside of the structure `Deep`. Make it printable\n" "// also.\n" msgstr "" "// `Deep`という構造体の中に`Structure`を入れ、これを出力可能にしています。\n" #: src/hello/print/print_debug.md:37 msgid "// Printing with `{:?}` is similar to with `{}`.\n" msgstr "// `{:?}`による出力は`{}`に似ています。\n" #: src/hello/print/print_debug.md:38 msgid "\"{:?} months in a year.\"" msgstr "\"{:?} months in a year.\"" #: src/hello/print/print_debug.md:39 msgid "\"{1:?} {0:?} is the {actor:?} name.\"" msgstr "\"{1:?} {0:?} is the {actor:?} name.\"" #: src/hello/print/print_debug.md:40 msgid "\"Slater\"" msgstr "\"Slater\"" #: src/hello/print/print_debug.md:41 msgid "\"Christian\"" msgstr "\"Christian\"" #: src/hello/print/print_debug.md:42 msgid "\"actor's\"" msgstr "\"actor's\"" #: src/hello/print/print_debug.md:44 msgid "// `Structure` is printable!\n" msgstr "// `Structure`は出力可能です！\n" #: src/hello/print/print_debug.md:45 src/hello/print/print_debug.md:49 msgid "\"Now {:?} will print!\"" msgstr "\"Now {:?} will print!\"" #: src/hello/print/print_debug.md:47 msgid "" "// The problem with `derive` is there is no control over how\n" " // the results look. What if I want this to just show a `7`?\n" msgstr "" "// `derive`を用いることの問題は、結果がどのように見えるか\n" " // コントロールする方法がないことです。\n" " // 出力を`7`だけにするためにはどうしたらよいでしょう？\n" #: src/hello/print/print_debug.md:53 msgid "" "So `fmt::Debug` definitely makes this printable but sacrifices some " "elegance. Rust also provides \"pretty printing\" with `{:#?}`." msgstr "" "`fmt::Debug`は確実に出力可能にしてくれるのですが、一方である種の美しさを犠牲" "にしています。Rustは`{:#?}`による「見栄えの良い出力」も提供します。" #: src/hello/print/print_debug.md:64 src/custom_types/structs.md:42 msgid "\"Peter\"" msgstr "\"Peter\"" #: src/hello/print/print_debug.md:68 msgid "// Pretty print\n" msgstr "// 見栄えのよい出力\n" #: src/hello/print/print_debug.md:69 msgid "\"{:#?}\"" msgstr "\"{:#?}\"" #: src/hello/print/print_debug.md:73 msgid "One can manually implement `fmt::Display` to control the display." msgstr "手動で`fmt::Display`を実装することで出力結果を思い通りにできます。" #: src/hello/print/print_debug.md:77 msgid "" "[`attributes`](https://doc.rust-lang.org/reference/attributes.html), " "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), and [`struct`](../../custom_types/structs.md)" msgstr "" "[アトリビュート](https://doc.rust-lang.org/reference/attributes.html), " "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [構造体](../../custom_types/structs.md)" #: src/hello/print/print_display.md:3 msgid "" "`fmt::Debug` hardly looks compact and clean, so it is often advantageous to " "customize the output appearance. This is done by manually implementing " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/), which uses the `{}` " "print marker. Implementing it looks like this:" msgstr "" "`fmt::Debug`はコンパクトでクリーンであるようには見えませんね。大抵の場合は、" "アウトプットの見た目をカスタマイズしたほうが好ましいでしょう。これは`{}`を使" "用する[`fmt::Display`](https://doc.rust-lang.org/std/fmt/)を手動で実装するこ" "とで可能です。実装はこのようになります。" #: src/hello/print/print_display.md:9 msgid "// Import (via `use`) the `fmt` module to make it available.\n" msgstr "// （`use`を使用し、）`fmt`モジュールをインポートします。\n" #: src/hello/print/print_display.md:11 msgid "" "// Define a structure for which `fmt::Display` will be implemented. This is\n" "// a tuple struct named `Structure` that contains an `i32`.\n" msgstr "" "// `fmt::Display`を実装するための構造体を定義します。\n" "// これは`Structure`と名付けられた、`i32`を含むタプル構造体です。\n" #: src/hello/print/print_display.md:15 msgid "" "// To use the `{}` marker, the trait `fmt::Display` must be implemented\n" "// manually for the type.\n" msgstr "" "// `{}` というマーカーを使用するためには、\n" "// この型専用の`fmt::Display`というトレイトが実装されていなくてはなりませ" "ん。\n" #: src/hello/print/print_display.md:19 msgid "// This trait requires `fmt` with this exact signature.\n" msgstr "" "// このトレイトは`fmt`が正確にこの通りのシグネチャであることを要求します。\n" #: src/hello/print/print_display.md:21 msgid "" "// Write strictly the first element into the supplied output\n" " // stream: `f`. Returns `fmt::Result` which indicates whether the\n" " // operation succeeded or failed. Note that `write!` uses syntax " "which\n" " // is very similar to `println!`.\n" msgstr "" "// 最初の要素だけを、与えられた出力ストリーム`f`に書き込みます。\n" " // 操作が成功したかどうかを表す`fmt::Result`を返します。\n" " // `write!`は`println!`に非常によく似た文法を使用していることに注" "目。\n" #: src/hello/print/print_display.md:25 #: src/hello/print/print_display/testcase_list.md:13 #: src/hello/print/print_display/testcase_list.md:39 #: src/hello/print/print_display/testcase_list.md:49 src/hello/print/fmt.md:53 #: src/custom_types/enum/testcase_linked_list.md:73 src/conversion/string.md:25 #: src/flow_control/loop.md:26 src/flow_control/while.md:21 #: src/flow_control/for.md:23 src/flow_control/for.md:43 src/fn.md:40 #: src/fn/closures/capture.md:96 src/fn/closures/capture.md:97 #: src/fn/closures/anonymity.md:41 src/generics/bounds.md:12 #: src/macros/repeat.md:24 src/macros/repeat.md:25 src/macros/repeat.md:26 #: src/error/result.md:73 src/std/str.md:92 src/std/str.md:102 #: src/std/str.md:106 src/std/str.md:111 src/std/result.md:72 #: src/std/result/question_mark.md:57 src/std/result/question_mark.md:65 #: src/std_misc/file/read_lines.md:60 src/std_misc/arg/matching.md:9 #: src/std_misc/arg/matching.md:13 msgid "\"{}\"" msgstr "\"{}\"" #: src/hello/print/print_display.md:30 msgid "" "`fmt::Display` may be cleaner than `fmt::Debug` but this presents a problem " "for the `std` library. How should ambiguous types be displayed? For example, " "if the `std` library implemented a single style for all `Vec`, what style " "should it be? Would it be either of these two?" msgstr "" "`fmt::Display`は`fmt::Debug`より綺麗かもしれませんが、`std`ライブラリの場合は" "問題が生じます。曖昧な型はどのように表示すれば良いでしょう？例えば、`std`ライ" "ブラリがあらゆる`Vec`に対して単一のスタイルを提供していた場合、どのような" "スタイルに整形すればよいでしょう？以下の2つのどちらかを選ぶべきでしょうか？" #: src/hello/print/print_display.md:35 msgid "`Vec`: `/:/etc:/home/username:/bin` (split on `:`)" msgstr "`Vec`: `/:/etc:/home/username:/bin` （`:`で分割）" #: src/hello/print/print_display.md:36 msgid "`Vec`: `1,2,3` (split on `,`)" msgstr "`Vec`: `1,2,3` （`,`で分割）" #: src/hello/print/print_display.md:38 msgid "" "No, because there is no ideal style for all types and the `std` library " "doesn't presume to dictate one. `fmt::Display` is not implemented for " "`Vec` or for any other generic containers. `fmt::Debug` must then be used " "for these generic cases." msgstr "" "答えはNOです。あらゆる型に対して理想的なスタイルなどというものはありません" "し、`std`ライブラリによってそれが提供されているわけでもありません。`fmt::" "Display`は`Vec`のようなジェネリックなコンテナ用に定義されているわけではあ" "りませんので、このような場合は`fmt::Debug`を使用するべきです。" #: src/hello/print/print_display.md:43 msgid "" "This is not a problem though because for any new _container_ type which is " "_not_ generic, `fmt::Display` can be implemented." msgstr "" "ジェネリック *でない* コンテナ型の場合は、このような問題は生じませんので問題" "なく`fmt::Display`を実装することができます。" #: src/hello/print/print_display.md:47 msgid "// Import `fmt`\n" msgstr "// `fmt`のインポート\n" #: src/hello/print/print_display.md:48 msgid "" "// A structure holding two numbers. `Debug` will be derived so the results " "can\n" "// be contrasted with `Display`.\n" msgstr "" "// 2つの数字を扱うための構造体です。出力を`Display`と比較するため`Debug`\n" "// を導出しています。\n" #: src/hello/print/print_display.md:53 msgid "// Implement `Display` for `MinMax`.\n" msgstr "// `MinMax`用の`Display`を実装しています。\n" #: src/hello/print/print_display.md:57 msgid "// Use `self.number` to refer to each positional data point.\n" msgstr "// `self.number`でそれぞれのデータポイントを参照できます。\n" #: src/hello/print/print_display.md:58 msgid "\"({}, {})\"" msgstr "\"({}, {})\"" #: src/hello/print/print_display.md:61 msgid "// Define a structure where the fields are nameable for comparison.\n" msgstr "" "// 比較のため、フィールドに名前をつけられる様な構造体を定義しましょう。\n" #: src/hello/print/print_display.md:68 msgid "// Similarly, implement `Display` for `Point2D`.\n" msgstr "// 先程と同様にして、`Point2D`用の`Display`を実装しています。\n" #: src/hello/print/print_display.md:72 msgid "// Customize so only `x` and `y` are denoted.\n" msgstr "// `x`と`y`のみが明示的になるようにカスタマイズ。\n" #: src/hello/print/print_display.md:73 msgid "\"x: {}, y: {}\"" msgstr "\"x: {}, y: {}\"" #: src/hello/print/print_display.md:80 msgid "\"Compare structures:\"" msgstr "\"Compare structures:\"" #: src/hello/print/print_display.md:81 src/hello/print/print_display.md:94 msgid "\"Display: {}\"" msgstr "\"Display: {}\"" #: src/hello/print/print_display.md:82 src/hello/print/print_display.md:95 msgid "\"Debug: {:?}\"" msgstr "\"Debug: {:?}\"" #: src/hello/print/print_display.md:87 msgid "\"The big range is {big} and the small is {small}\"" msgstr "\"The big range is {big} and the small is {small}\"" #: src/hello/print/print_display.md:93 msgid "\"Compare points:\"" msgstr "\"Compare points:\"" #: src/hello/print/print_display.md:97 msgid "" "// Error. Both `Debug` and `Display` were implemented, but `{:b}`\n" " // requires `fmt::Binary` to be implemented. This will not work.\n" " // println!(\"What does Point2D look like in binary: {:b}?\", point);\n" msgstr "" "// `Debug`と`Display`は実装されていますが、`fmt::Binary`はされていないため\n" " // `{:b}`使用している以下の例はエラーになります。\n" " // println!(\"What does Point2D look like in binary: {:b}?\", point);\n" #: src/hello/print/print_display.md:103 msgid "" "So, `fmt::Display` has been implemented but `fmt::Binary` has not, and " "therefore cannot be used. `std::fmt` has many such [`traits`](https://doc." "rust-lang.org/std/fmt/#formatting-traits) and each requires its own " "implementation. This is detailed further in [`std::fmt`](https://doc.rust-" "lang.org/std/fmt/)." msgstr "" "`fmt::Display`は実装されていますが、`fmt::Binary`はされていないので使用できま" "せん。`std::fmt`にはそのような[トレイト](https://doc.rust-lang.org/std/fmt/" "#formatting-traits)が数多くあり、それぞれに独自の実装が必要です。詳しくは" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)を参照してください。" #: src/hello/print/print_display.md:109 msgid "" "After checking the output of the above example, use the `Point2D` struct as " "a guide to add a `Complex` struct to the example. When printed in the same " "way, the output should be:" msgstr "" "上記の例のアウトプットを確認し、`Point2D`構造体を参考として、複素数を格納する" "ための`Complex`構造体を定義しましょう。うまく行けば以下のように出力されるはず" "です。" #: src/hello/print/print_display.md:120 msgid "" "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [`macros`](../../macros.md), [`struct`](../../custom_types/" "structs.md), [`trait`](https://doc.rust-lang.org/std/fmt/#formatting-" "traits), and [`use`](../../mod/use.md)" msgstr "" "[導出](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/std/" "fmt/), [マクロ](../../macros.md), [構造体](../../custom_types/structs.md), " "[トレイト](https://doc.rust-lang.org/std/fmt/#formatting-traits), [`use`]" "(../../mod/use.md)" #: src/hello/print/print_display/testcase_list.md:3 msgid "" "Implementing `fmt::Display` for a structure where the elements must each be " "handled sequentially is tricky. The problem is that each `write!` generates " "a `fmt::Result`. Proper handling of this requires dealing with _all_ the " "results. Rust provides the `?` operator for exactly this purpose." msgstr "" "構造体のそれぞれの要素を別々に扱う`fmt::Display`を実装するのはトリッキーで" "す。というのも、それぞれの`write!`が別々の`fmt::Result`を生成するためです。適" "切に処理するためには *すべての* 結果に対して処理を書かなくてはなりません。こ" "のような場合は`?`演算子が使えます。" #: src/hello/print/print_display/testcase_list.md:8 msgid "Using `?` on `write!` looks like this:" msgstr "以下のように`?`を`write!`に対して使用します。" #: src/hello/print/print_display/testcase_list.md:11 msgid "" "// Try `write!` to see if it errors. If it errors, return\n" "// the error. Otherwise continue.\n" msgstr "" "// `write!`を実行し、エラーが生じた場合はエラーを返します。そうでなければ実行" "を継続します。\n" #: src/hello/print/print_display/testcase_list.md:16 msgid "" "With `?` available, implementing `fmt::Display` for a `Vec` is " "straightforward:" msgstr "`?`を使用すれば、`Vec`用の`fmt::Display`はより簡単に実装できます。" #: src/hello/print/print_display/testcase_list.md:20 msgid "// Import the `fmt` module.\n" msgstr "// `fmt`モジュールのインポート\n" #: src/hello/print/print_display/testcase_list.md:21 msgid "// Define a structure named `List` containing a `Vec`.\n" msgstr "// `Vec`を含む`List`という名の構造体を定義。\n" #: src/hello/print/print_display/testcase_list.md:27 msgid "" "// Extract the value using tuple indexing,\n" " // and create a reference to `vec`.\n" msgstr "" "// タプルインデックスを使って値を取り出し、それへの参照`vec`を作ります。\n" #: src/hello/print/print_display/testcase_list.md:31 msgid "\"[\"" msgstr "\"[\"" #: src/hello/print/print_display/testcase_list.md:33 msgid "" "// Iterate over `v` in `vec` while enumerating the iteration\n" " // count in `count`.\n" msgstr "" "// `v`を介して`vec`をイテレートし、同時にカウントを\n" " // `enumerate`で取得します。\n" #: src/hello/print/print_display/testcase_list.md:36 msgid "" "// For every element except the first, add a comma.\n" " // Use the ? operator to return on errors.\n" msgstr "" "// 先頭以外の全要素にカンマを付けます。\n" " // ?演算子を使ってエラーを返します。\n" #: src/hello/print/print_display/testcase_list.md:38 src/std/str.md:36 msgid "\", \"" msgstr "\", \"" #: src/hello/print/print_display/testcase_list.md:42 msgid "// Close the opened bracket and return a fmt::Result value.\n" msgstr "// 開きっぱなしのブラケットを閉じて、`fmt::Result`の値を返します。\n" #: src/hello/print/print_display/testcase_list.md:43 msgid "\"]\"" msgstr "\"]\"" #: src/hello/print/print_display/testcase_list.md:55 msgid "" "Try changing the program so that the index of each element in the vector is " "also printed. The new output should look like this:" msgstr "" "上記のプログラムを変更して、ベクタの各要素のインデックスも表示するようにして" "みましょう。変更後の出力は次のようになります。" #: src/hello/print/print_display/testcase_list.md:64 msgid "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/ref." "md), [`Result`](../../../std/result.md), [`struct`](../../../custom_types/" "structs.md), [`?`](../../../std/result/question_mark.md), and [`vec!`]" "(../../../std/vec.md)" msgstr "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/ref." "md), [`Result`](../../../std/result.md), [構造体](../../../custom_types/" "structs.md), [`?`](../../../std/result/question_mark.md), [`vec!`](../../../" "std/vec.md)" #: src/hello/print/fmt.md:3 msgid "We've seen that formatting is specified via a _format string_:" msgstr "" "これまで、文字列がどのようにフォーマットされるかは *フォーマット文字列* に" "よって決まるということを見てきました 。" #: src/hello/print/fmt.md:5 msgid "`format!(\"{}\", foo)` -> `\"3735928559\"`" msgstr "`format!(\"{}\", foo)` -> `\"3735928559\"`" #: src/hello/print/fmt.md:6 msgid "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" msgstr "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" #: src/hello/print/fmt.md:7 msgid "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" msgstr "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" #: src/hello/print/fmt.md:9 msgid "" "The same variable (`foo`) can be formatted differently depending on which " "_argument type_ is used: `X` vs `o` vs _unspecified_." msgstr "" "ここでは（`foo`）という単一の変数が`X`、`o`、 *指定なし* 、という様々な *引数" "タイプ* に応じてフォーマットされています。" #: src/hello/print/fmt.md:12 msgid "" "This formatting functionality is implemented via traits, and there is one " "trait for each argument type. The most common formatting trait is `Display`, " "which handles cases where the argument type is left unspecified: `{}` for " "instance." msgstr "" "フォーマットの機能はそれぞれの引数タイプごとに個別のトレイトを用いて実装され" "ています。最も一般的なトレイトは`Display`で、これは引数タイプが未指定（たとえ" "ば`{}`）の時に呼び出されます。" #: src/hello/print/fmt.md:21 msgid "// Latitude\n" msgstr "// 緯度\n" #: src/hello/print/fmt.md:23 msgid "// Longitude\n" msgstr "// 経度\n" #: src/hello/print/fmt.md:28 msgid "" "// `f` is a buffer, and this method must write the formatted string into " "it.\n" msgstr "" "// `f`はバッファです。このメソッドは\n" " // ここにフォーマットされた文字列を書き込みます。\n" #: src/hello/print/fmt.md:30 msgid "'N'" msgstr "'N'" #: src/hello/print/fmt.md:30 msgid "'S'" msgstr "'S'" #: src/hello/print/fmt.md:31 msgid "'E'" msgstr "'E'" #: src/hello/print/fmt.md:31 msgid "'W'" msgstr "'W'" #: src/hello/print/fmt.md:33 msgid "" "// `write!` is like `format!`, but it will write the formatted string\n" " // into a buffer (the first argument).\n" msgstr "" "// `write!`は`format!`に似ていますが、フォーマットされた文字列を\n" " // バッファ（第一引数）に書き込みます。\n" #: src/hello/print/fmt.md:35 msgid "\"{}: {:.3}°{} {:.3}°{}\"" msgstr "\"{}: {:.3}°{} {:.3}°{}\"" #: src/hello/print/fmt.md:49 msgid "\"Dublin\"" msgstr "\"Dublin\"" #: src/hello/print/fmt.md:50 msgid "\"Oslo\"" msgstr "\"Oslo\"" #: src/hello/print/fmt.md:51 msgid "\"Vancouver\"" msgstr "\"Vancouver\"" #: src/hello/print/fmt.md:60 msgid "" "// Switch this to use {} once you've added an implementation\n" " // for fmt::Display.\n" msgstr "" "// fmt::Displayに実装を追加したら、 {} を使用するように変更してください。\n" #: src/hello/print/fmt.md:62 src/primitives/tuples.md:60 #: src/custom_types/structs.md:47 src/types/inference.md:23 #: src/generics/bounds.md:49 src/generics/where.md:38 src/std/str.md:137 #: src/std/result.md:59 src/std/result.md:61 src/std/result.md:63 #: src/std/arc.md:26 src/std_misc/channels.md:53 msgid "\"{:?}\"" msgstr "\"{:?}\"" #: src/hello/print/fmt.md:67 msgid "" "You can view a [full list of formatting traits](https://doc.rust-lang.org/" "std/fmt/#formatting-traits) and their argument types in the [`std::fmt`]" "(https://doc.rust-lang.org/std/fmt/) documentation." msgstr "" "フォーマット用トレイトの全リストは[こちら](https://doc.rust-lang.org/std/fmt/" "#formatting-traits)から、引数タイプについては[`std::fmt`のドキュメンテーショ" "ン](https://doc.rust-lang.org/std/fmt/)から参照できます。" #: src/hello/print/fmt.md:72 msgid "" "Add an implementation of the `fmt::Display` trait for the `Color` struct " "above so that the output displays as:" msgstr "" "上にあるソースコード中の`Color`という構造体のための`fmt::Display`トレイトの実" "装を追加しましょう。出力は以下のようになるはずです。" #: src/hello/print/fmt.md:81 msgid "Three hints if you get stuck:" msgstr "詰まったら以下の3つがヒントになります。" #: src/hello/print/fmt.md:83 msgid "" "The formula for calculating a color in the RGB color space is: `RGB = " "(R*65536)+(G*256)+B , (when R is RED, G is GREEN and B is BLUE)`. For more " "see [RGB color format & calculation](https://www.rapidtables.com/web/color/" "RGB_Color.html#rgb-format)." msgstr "" "RGB色空間で色を計算する式は`RGB = (R*65536)+(G*256)+B （R は RED, G は GREEN " "and B は BLUE）`です。詳細は[RGB color format & calculation](https://www." "rapidtables.com/web/color/RGB_Color.html#rgb-format)を参照。" #: src/hello/print/fmt.md:86 msgid "" "You [may need to list each color more than once](https://doc.rust-lang.org/" "std/fmt/#named-parameters)." msgstr "" "[それぞれの色を2回以上記述する必要があるかもしれません。](https://doc.rust-" "lang.org/std/fmt/#named-parameters)" #: src/hello/print/fmt.md:87 msgid "" "You can [pad with zeros to a width of 2](https://doc.rust-lang.org/std/fmt/" "#width) with `:0>2`." msgstr "" "`:0>2`で、[幅を2に指定し、空白を0で埋める事ができます。](https://doc.rust-" "lang.org/std/fmt/#width)" #: src/hello/print/fmt.md:91 msgid "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" msgstr "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" #: src/primitives.md:3 msgid "" "Rust provides access to a wide variety of `primitives`. A sample includes:" msgstr "Rustは様々な基本データ型の使用をサポートしています。以下がその例です。" #: src/primitives.md:5 msgid "Scalar Types" msgstr "スカラー型" #: src/primitives.md:7 msgid "" "Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size)" msgstr "" "符号付き整数：`i8`, `i16`, `i32`, `i64`, `i128`, `isize`（ポインタのサイズ）" #: src/primitives.md:8 msgid "" "Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer " "size)" msgstr "" "符号無し整数：`u8`, `u16`, `u32`, `u64`, `u128`, `usize`（ポインタのサイズ）" #: src/primitives.md:10 msgid "Floating point: `f32`, `f64`" msgstr "浮動小数点数：`f32`, `f64`" #: src/primitives.md:11 msgid "`char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each)" msgstr "" "`char`：`'a'`, `'α'`, `'∞'`などのUnicodeのスカラー値（それぞれ4バイト）" #: src/primitives.md:12 msgid "`bool` either `true` or `false`" msgstr "`bool`：`true`または`false`" #: src/primitives.md:13 msgid "The unit type `()`, whose only possible value is an empty tuple: `()`" msgstr "ユニット型 `()`：唯一の値として空のタプル`()`を持つ" #: src/primitives.md:15 msgid "" "Despite the value of a unit type being a tuple, it is not considered a " "compound type because it does not contain multiple values." msgstr "" "ユニット型はその値がタプルですが、複合型とはみなされません。内部に複数の値を" "含んでいるわけではないからです。" #: src/primitives.md:18 msgid "Compound Types" msgstr "複合型" #: src/primitives.md:20 msgid "Arrays like `[1, 2, 3]`" msgstr "配列： 例えば`[1, 2, 3]`" #: src/primitives.md:21 msgid "Tuples like `(1, true)`" msgstr "タプル：例えば`(1, true)`" #: src/primitives.md:23 msgid "" "Variables can always be _type annotated_. Numbers may additionally be " "annotated via a _suffix_ or _by default_. Integers default to `i32` and " "floats to `f64`. Note that Rust can also infer types from context." msgstr "" "変数は常に *型指定* できます。数値型の場合はさらにサフィックスでの指定も可能" "です。指定しない場合デフォルトになります。整数は`i32`が、浮動小数点は`f64`が" "デフォルトです。また、Rustは文脈から型を推論することもできます。" #: src/primitives.md:29 msgid "// Variables can be type annotated.\n" msgstr "// 変数に型を指定。\n" #: src/primitives.md:32 msgid "// Regular annotation\n" msgstr "// 通常の型指定\n" #: src/primitives.md:33 msgid "// Suffix annotation\n" msgstr "// サフィックスによる型指定\n" #: src/primitives.md:35 msgid "// Or a default will be used.\n" msgstr "// サフィックスを指定しない場合、デフォルトを選択。\n" #: src/primitives.md:36 msgid "// `f64`\n" msgstr "// `f64`\n" #: src/primitives.md:37 msgid "// `i32`\n" msgstr "// `i32`\n" #: src/primitives.md:39 msgid "// A type can also be inferred from context.\n" msgstr "// 型を文脈から推論することも可能。\n" #: src/primitives.md:40 msgid "// Type i64 is inferred from another line.\n" msgstr "// 型 i64 は次行の内容に基づいて推論。\n" #: src/primitives.md:43 msgid "// A mutable variable's value can be changed.\n" msgstr "// ミュータブルな変数は値を変更できます。\n" #: src/primitives.md:44 msgid "// Mutable `i32`\n" msgstr "// ミュータブルな`i32`\n" #: src/primitives.md:47 msgid "// Error! The type of a variable can't be changed.\n" msgstr "// エラー！ミュータブルな変数でも型は不変。\n" #: src/primitives.md:50 msgid "// Variables can be overwritten with shadowing.\n" msgstr "// 変数はシャドーイングによって上書きできます。\n" #: src/primitives.md:57 msgid "" "[the `std` library](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [`inference`](types/inference.md), and " "[`shadowing`](variable_bindings/scope.md)" msgstr "" "[`std` ライブラリ](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [型推論](types/inference.md), [シャドーイング]" "(variable_bindings/scope.md)" #: src/primitives/literals.md:3 msgid "" "Integers `1`, floats `1.2`, characters `'a'`, strings `\"abc\"`, booleans " "`true` and the unit type `()` can be expressed using literals." msgstr "" "整数`1`、浮動小数点数`1.2`、文字`'a'`、文字列`\"abc\"`、ブーリアン`true`、ユ" "ニット`()`は、リテラルを使って表すことが可能です。" #: src/primitives/literals.md:6 msgid "" "Integers can, alternatively, be expressed using hexadecimal, octal or binary " "notation using these prefixes respectively: `0x`, `0o` or `0b`." msgstr "" "また整数型の場合、プレフィックスに`0x`、`0o`、`0b`を指定することでそれぞれ16" "進数、8進数、2進数を使って表すことができます。" #: src/primitives/literals.md:9 msgid "" "Underscores can be inserted in numeric literals to improve readability, e.g. " "`1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`." msgstr "" "可読性のため、`_`（アンダースコア）を数値リテラルの間に挿入することができま" "す。例えば`1_000`は`1000`と、`0.000_001`は`0.000001`とそれぞれ同一です。" #: src/primitives/literals.md:12 msgid "" "Rust also supports scientific [E-notation](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. The associated type " "is `f64`." msgstr "" "また、Rustは`1e6`や`7.6e-4`などの科学的な[E表記](https://en.wikipedia.org/" "wiki/Scientific_notation#E_notation)をサポートしています。この表記は`f64`にな" "ります。" #: src/primitives/literals.md:15 msgid "" "We need to tell the compiler the type of the literals we use. For now, we'll " "use the `u32` suffix to indicate that the literal is an unsigned 32-bit " "integer, and the `i32` suffix to indicate that it's a signed 32-bit integer." msgstr "" "コンパイラに、リテラルの型を伝えたい場合があります。現在の仕様では、リテラル" "が32ビット符号無し整数であることを伝える場合、`u32`サフィックスを、符号付き32" "ビット整数であれば`i32`サフィックスを使用します。" #: src/primitives/literals.md:19 msgid "" "The operators available and their precedence [in Rust](https://doc.rust-lang." "org/reference/expressions.html#expression-precedence) are similar to other " "[C-like languages](https://en.wikipedia.org/wiki/" "Operator_precedence#Programming_languages)." msgstr "" "Rustで使用可能な[演算子とその優先順位](https://doc.rust-lang.org/reference/" "expressions.html#expression-precedence)は、[Cなどの言語のもの](https://en." "wikipedia.org/wiki/Operator_precedence#Programming_languages)とほぼ同じです。" #: src/primitives/literals.md:24 msgid "// Integer addition\n" msgstr "// 整数の足し算\n" #: src/primitives/literals.md:25 msgid "\"1 + 2 = {}\"" msgstr "\"1 + 2 = {}\"" #: src/primitives/literals.md:27 msgid "// Integer subtraction\n" msgstr "// 整数の引き算\n" #: src/primitives/literals.md:28 msgid "\"1 - 2 = {}\"" msgstr "\"1 - 2 = {}\"" #: src/primitives/literals.md:29 msgid "" "// TODO ^ Try changing `1i32` to `1u32` to see why the type is important\n" msgstr "" "// TODO ^ 型が重要であることを実感するため`1i32`を`1u32`に変更してみましょ" "う。\n" #: src/primitives/literals.md:31 msgid "// Scientific notation\n" msgstr "// 科学的表記\n" #: src/primitives/literals.md:32 msgid "\"1e4 is {}, -2.5e-3 is {}\"" msgstr "\"1e4 is {}, -2.5e-3 is {}\"" #: src/primitives/literals.md:34 msgid "// Short-circuiting boolean logic\n" msgstr "// 短絡評価できる論理演算子\n" #: src/primitives/literals.md:35 msgid "\"true AND false is {}\"" msgstr "\"true AND false is {}\"" #: src/primitives/literals.md:36 msgid "\"true OR false is {}\"" msgstr "\"true OR false is {}\"" #: src/primitives/literals.md:37 msgid "\"NOT true is {}\"" msgstr "\"NOT true is {}\"" #: src/primitives/literals.md:39 msgid "// Bitwise operations\n" msgstr "// ビットワイズ演算\n" #: src/primitives/literals.md:40 msgid "\"0011 AND 0101 is {:04b}\"" msgstr "\"0011 AND 0101 is {:04b}\"" #: src/primitives/literals.md:41 msgid "\"0011 OR 0101 is {:04b}\"" msgstr "\"0011 OR 0101 is {:04b}\"" #: src/primitives/literals.md:42 msgid "\"0011 XOR 0101 is {:04b}\"" msgstr "\"0011 XOR 0101 is {:04b}\"" #: src/primitives/literals.md:43 msgid "\"1 << 5 is {}\"" msgstr "\"1 << 5 is {}\"" #: src/primitives/literals.md:44 msgid "\"0x80 >> 2 is 0x{:x}\"" msgstr "\"0x80 >> 2 is 0x{:x}\"" #: src/primitives/literals.md:46 msgid "// Use underscores to improve readability!\n" msgstr "// 可読性のための`_`（アンダースコア）の使用\n" #: src/primitives/literals.md:47 msgid "\"One million is written as {}\"" msgstr "\"One million is written as {}\"" #: src/primitives/tuples.md:3 msgid "" "A tuple is a collection of values of different types. Tuples are constructed " "using parentheses `()`, and each tuple itself is a value with type signature " "`(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions " "can use tuples to return multiple values, as tuples can hold any number of " "values." msgstr "" "タプルは異なる型の値の集合です。括弧`()`を用いて生成します。タプル自体がその" "メンバに対する型シグネチャを保持していますので、明示すると`(T1, T2, ...)`のよ" "うになります。タプルは大きさに制限がありませんので、関数が複数の値を返したい" "時に使われます。" #: src/primitives/tuples.md:9 msgid "// Tuples can be used as function arguments and as return values.\n" msgstr "// タプルを関数の引数と返り値として使用しています。\n" #: src/primitives/tuples.md:11 msgid "// `let` can be used to bind the members of a tuple to variables.\n" msgstr "// `let`でタプルの中の値を別の変数に束縛することができます。\n" #: src/primitives/tuples.md:16 msgid "// The following struct is for the activity.\n" msgstr "// 以下の構造体は後ほど「演習」で用います。\n" #: src/primitives/tuples.md:22 msgid "// A tuple with a bunch of different types.\n" msgstr "// 様々な型を値に持つタプル\n" #: src/primitives/tuples.md:26 src/generics.md:50 src/generics.md:55 #: src/generics/gen_fn.md:47 msgid "'a'" msgstr "'a'" #: src/primitives/tuples.md:28 msgid "// Values can be extracted from the tuple using tuple indexing.\n" msgstr "// インデックスを用いて、タプル内の要素を参照できます。\n" #: src/primitives/tuples.md:29 msgid "\"Long tuple first value: {}\"" msgstr "\"Long tuple first value: {}\"" #: src/primitives/tuples.md:30 msgid "\"Long tuple second value: {}\"" msgstr "\"Long tuple second value: {}\"" #: src/primitives/tuples.md:32 msgid "// Tuples can be tuple members.\n" msgstr "// タプルはタプルのメンバになれます。\n" #: src/primitives/tuples.md:35 msgid "// Tuples are printable.\n" msgstr "// タプルは出力できます。\n" #: src/primitives/tuples.md:36 msgid "\"tuple of tuples: {:?}\"" msgstr "\"tuple of tuples: {:?}\"" #: src/primitives/tuples.md:38 msgid "" "// But long Tuples (more than 12 elements) cannot be printed.\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"Too long tuple: {:?}\", too_long_tuple);\n" " // TODO ^ Uncomment the above 2 lines to see the compiler error\n" msgstr "" "// しかし長すぎるタプル（12要素より多いもの）は出力できません。\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"Too long tuple: {:?}\", too_long_tuple);\n" " // TODO ^ 上記2行のコメントを外して、コンパイルエラーを確認しましょう。\n" #: src/primitives/tuples.md:44 msgid "\"Pair is {:?}\"" msgstr "\"Pair is {:?}\"" #: src/primitives/tuples.md:46 msgid "\"The reversed pair is {:?}\"" msgstr "\"The reversed pair is {:?}\"" #: src/primitives/tuples.md:48 msgid "" "// To create one element tuples, the comma is required to tell them apart\n" " // from a literal surrounded by parentheses.\n" msgstr "" "// 要素を1つしか持たないタプルを作成する場合、括弧で囲まれたただのリテラル\n" " // と区別するため、カンマが必要になります。\n" #: src/primitives/tuples.md:50 msgid "\"One element tuple: {:?}\"" msgstr "\"One element tuple: {:?}\"" #: src/primitives/tuples.md:51 msgid "\"Just an integer: {:?}\"" msgstr "\"Just an integer: {:?}\"" #: src/primitives/tuples.md:53 msgid "// Tuples can be destructured to create bindings.\n" msgstr "// タプルを分解して別の変数にそれぞれの値を代入。\n" #: src/primitives/tuples.md:54 src/conversion/from_into.md:17 #: src/fn/closures/input_parameters.md:52 src/std_misc/fs.md:51 msgid "\"hello\"" msgstr "\"hello\"" #: src/primitives/tuples.md:57 msgid "\"{:?}, {:?}, {:?}, {:?}\"" msgstr "\"{:?}, {:?}, {:?}, {:?}\"" #: src/primitives/tuples.md:66 msgid "" "_Recap_: Add the `fmt::Display` trait to the `Matrix` struct in the above " "example, so that if you switch from printing the debug format `{:?}` to the " "display format `{}`, you see the following output:" msgstr "" "*復習* ：上にある`Matrix`という構造体に、`fmt::Display`トレイトを追加しましょ" "う。デバッグフォーマット`{:?}`ではなくディスプレイフォーマット`{}`で出力すれ" "ば次のようになるはずです。" #: src/primitives/tuples.md:75 msgid "" "You may want to refer back to the example for [print display](../hello/print/" "print_display.md)." msgstr "" "必要に応じて[ディスプレイのページ](../hello/print/print_display.md)に戻りま" "しょう。" #: src/primitives/tuples.md:76 msgid "" "Add a `transpose` function using the `reverse` function as a template, which " "accepts a matrix as an argument, and returns a matrix in which two elements " "have been swapped. For example:" msgstr "" "`reverse`関数を雛形にした`transpose`関数を実装してください。この関数は" "`Matrix`を引数として受け取り、要素のうち2つを入れ替えたものを返します。つまり" #: src/primitives/tuples.md:81 msgid "\"Matrix:\\n{}\"" msgstr "\"Matrix:\\n{}\"" #: src/primitives/tuples.md:82 msgid "\"Transpose:\\n{}\"" msgstr "\"Transpose:\\n{}\"" #: src/primitives/tuples.md:85 msgid "Results in the output:" msgstr "は以下の様な出力になります。" #: src/primitives/array.md:3 msgid "" "An array is a collection of objects of the same type `T`, stored in " "contiguous memory. Arrays are created using brackets `[]`, and their length, " "which is known at compile time, is part of their type signature `[T; " "length]`." msgstr "" "配列は`T`という単一の型のオブジェクトの集合です。それらのオブジェクトはメモリ" "上の連続した領域に保存されます。配列は`[]`を用いて生成されます。長さはコンパ" "イル時には決定されていて、`[T; length]`という形で指定できます。" #: src/primitives/array.md:7 msgid "" "Slices are similar to arrays, but their length is not known at compile time. " "Instead, a slice is a two-word object; the first word is a pointer to the " "data, the second word is the length of the slice. The word size is the same " "as usize, determined by the processor architecture, e.g. 64 bits on an " "x86-64. Slices can be used to borrow a section of an array and have the type " "signature `&[T]`." msgstr "" "スライスは配列に似ていますが、コンパイル時に長さが決定されていません。スライ" "スは2ワードからなるオブジェクトであり、最初のワードがデータへのポインタ、2番" "目のワードがスライスの長さです。ワード長は`usize`と同一で、プロセッサのアーキ" "テクチャによって決まります。例えばx86-64では64ビットです。スライスは配列の一" "部を借用するのに使用され、`&[T]`という型シグネチャを持ちます。" #: src/primitives/array.md:15 msgid "// This function borrows a slice.\n" msgstr "// この関数はスライスを借用します。\n" #: src/primitives/array.md:18 msgid "\"First element of the slice: {}\"" msgstr "\"First element of the slice: {}\"" #: src/primitives/array.md:19 msgid "\"The slice has {} elements\"" msgstr "\"The slice has {} elements\"" #: src/primitives/array.md:23 msgid "// Fixed-size array (type signature is superfluous).\n" msgstr "// 固定長の配列（型シグネチャは冗長なので、なくても可）\n" #: src/primitives/array.md:26 msgid "// All elements can be initialized to the same value.\n" msgstr "// すべての要素を同じ値で初期化する場合\n" #: src/primitives/array.md:29 msgid "// Indexing starts at 0.\n" msgstr "// インデックスは0から。\n" #: src/primitives/array.md:30 msgid "\"First element of the array: {}\"" msgstr "\"First element of the array: {}\"" #: src/primitives/array.md:31 msgid "\"Second element of the array: {}\"" msgstr "\"Second element of the array: {}\"" #: src/primitives/array.md:33 msgid "// `len` returns the count of elements in the array.\n" msgstr "// `len`は配列の要素数を返します。\n" #: src/primitives/array.md:34 msgid "\"Number of elements in array: {}\"" msgstr "\"Number of elements in array: {}\"" #: src/primitives/array.md:36 msgid "// Arrays are stack allocated.\n" msgstr "// 配列はスタック上に置かれます。\n" #: src/primitives/array.md:37 msgid "\"Array occupies {} bytes\"" msgstr "\"Array occupies {} bytes\"" #: src/primitives/array.md:39 msgid "// Arrays can be automatically borrowed as slices.\n" msgstr "// 配列は自動的にスライスとして借用されます。\n" #: src/primitives/array.md:40 msgid "\"Borrow the whole array as a slice.\"" msgstr "\"Borrow the whole array as a slice.\"" #: src/primitives/array.md:43 msgid "" "// Slices can point to a section of an array.\n" " // They are of the form [starting_index..ending_index].\n" " // `starting_index` is the first position in the slice.\n" " // `ending_index` is one more than the last position in the slice.\n" msgstr "" "// スライスは配列の一部を指すことができます。\n" " // [starting_index..ending_index] の形をとり、\n" " // `starting_index`はスライスの先頭の位置を表し、\n" " // `ending_index`はスライスの末尾の1つ先の位置を表します。\n" #: src/primitives/array.md:47 msgid "\"Borrow a section of the array as a slice.\"" msgstr "\"Borrow a section of the array as a slice.\"" #: src/primitives/array.md:50 msgid "// Example of empty slice `&[]`:\n" msgstr "// 空のスライス`&[]`の例：\n" #: src/primitives/array.md:53 msgid "// Same but more verbose\n" msgstr "// 同じ意味だがより冗長な書き方\n" #: src/primitives/array.md:55 msgid "" "// Arrays can be safely accessed using `.get`, which returns an\n" " // `Option`. This can be matched as shown below, or used with\n" " // `.expect()` if you would like the program to exit with a nice\n" " // message instead of happily continue.\n" msgstr "" "// 配列は、`Option`を返す`.get`で安全にアクセスできます。\n" " // `Option`は以下のようにマッチさせることもできるし、\n" " // 運よく処理を続ける代わりに、`.expect()`で素敵なメッセージとともに\n" " // プログラムを終了することもできます。\n" #: src/primitives/array.md:59 msgid "// Oops, one element too far!\n" msgstr "// おっと、1要素余分！\n" #: src/primitives/array.md:61 msgid "\"{}: {}\"" msgstr "\"{}: {}\"" #: src/primitives/array.md:62 msgid "\"Slow down! {} is too far!\"" msgstr "\"Slow down! {} is too far!\"" #: src/primitives/array.md:66 msgid "" "// Out of bound indexing on array causes compile time error.\n" " //println!(\"{}\", xs[5]);\n" " // Out of bound indexing on slice causes runtime error.\n" " //println!(\"{}\", xs[..][5]);\n" msgstr "" "// 配列のインデックスが範囲外のときはコンパイルエラー。\n" " //println!(\"{}\", xs[5]);\n" " // スライスのインデックスが範囲外のときはランタイムエラー。\n" " //println!(\"{}\", xs[..][5]);\n" #: src/custom_types.md:3 msgid "Rust custom data types are formed mainly through the two keywords:" msgstr "" "Rustでのカスタムデータ型の作成は主に以下の2つのキーワードを介して行われます。" #: src/custom_types.md:5 msgid "`struct`: define a structure" msgstr "`struct`：構造体を定義する" #: src/custom_types.md:6 msgid "`enum`: define an enumeration" msgstr "`enum`：列挙型を定義する" #: src/custom_types.md:8 msgid "Constants can also be created via the `const` and `static` keywords." msgstr "" "`const`、あるいは`static`というキーワードによって定数を定義することもできま" "す。" #: src/custom_types/structs.md:3 msgid "" "There are three types of structures (\"structs\") that can be created using " "the `struct` keyword:" msgstr "`struct`というキーワードを用いて作成できる構造体には3種類あります。" #: src/custom_types/structs.md:6 msgid "Tuple structs, which are, basically, named tuples." msgstr "タプル構造体。（すなわちタプルに名前が付いたようなもの）" #: src/custom_types/structs.md:7 msgid "" "The classic [C structs](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" msgstr "" "クラシックな[C言語スタイルの構造体。](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" #: src/custom_types/structs.md:8 msgid "Unit structs, which are field-less, are useful for generics." msgstr "" "ユニット構造体。これはフィールドを持たず、ジェネリック型を扱う際に有効です。" #: src/custom_types/structs.md:11 src/custom_types/enum/enum_use.md:6 #: src/custom_types/enum/c_like.md:6 msgid "// An attribute to hide warnings for unused code.\n" msgstr "// 使用されていないコードよる警告を隠すアトリビュート\n" #: src/custom_types/structs.md:19 msgid "// A unit struct\n" msgstr "// ユニット構造体\n" #: src/custom_types/structs.md:22 msgid "// A tuple struct\n" msgstr "// タプル構造体\n" #: src/custom_types/structs.md:25 msgid "// A struct with two fields\n" msgstr "// 2つのフィールドを持つ（クラシックな）構造体\n" #: src/custom_types/structs.md:31 msgid "// Structs can be reused as fields of another struct\n" msgstr "// 構造体は他の構造体のフィールドになることができます。\n" #: src/custom_types/structs.md:34 msgid "" "// A rectangle can be specified by where the top left and bottom right\n" " // corners are in space.\n" msgstr "" "// 長方形は座標空間上における左上隅と右下隅の位置によって指定できます。\n" #: src/custom_types/structs.md:41 msgid "// Create struct with field init shorthand\n" msgstr "// 構造体をフィールド初期化の簡略記法で生成。\n" #: src/custom_types/structs.md:46 msgid "// Print debug struct\n" msgstr "// 構造体のデバッグ表示\n" #: src/custom_types/structs.md:49 msgid "// Instantiate a `Point`\n" msgstr "// `Point`のインスタンス化\n" #: src/custom_types/structs.md:53 msgid "// Access the fields of the point\n" msgstr "// pointのフィールドにアクセスします。\n" #: src/custom_types/structs.md:54 msgid "\"point coordinates: ({}, {})\"" msgstr "\"point coordinates: ({}, {})\"" #: src/custom_types/structs.md:56 msgid "" "// Make a new point by using struct update syntax to use the fields of our\n" " // other one\n" msgstr "" "// 構造体の更新記法を用いて、別の構造体のフィールドの値を基に\n" " // 新たなpointを生成。\n" #: src/custom_types/structs.md:60 msgid "" "// `bottom_right.y` will be the same as `another_point.y` because we used " "that field\n" " // from `another_point`\n" msgstr "" "// `bottom_right.y`の値は`another_point.y`と同一ですが、\n" " // これは`another_point`のフィールドの値を用いて生成したためです。\n" #: src/custom_types/structs.md:62 msgid "\"second point: ({}, {})\"" msgstr "\"second point: ({}, {})\"" #: src/custom_types/structs.md:64 msgid "// Destructure the point using a `let` binding\n" msgstr "// `let`を使用してpointをデストラクトします。\n" #: src/custom_types/structs.md:68 msgid "// struct instantiation is an expression too\n" msgstr "// 構造体の定義とインスタンスの作成を同時に行います。\n" #: src/custom_types/structs.md:73 msgid "// Instantiate a unit struct\n" msgstr "// ユニット構造体のインスタンス化\n" #: src/custom_types/structs.md:76 msgid "// Instantiate a tuple struct\n" msgstr "// タプル構造体のインスタンス化\n" #: src/custom_types/structs.md:79 msgid "// Access the fields of a tuple struct\n" msgstr "// タプル構造体のフィールドにアクセス\n" #: src/custom_types/structs.md:80 src/custom_types/structs.md:85 msgid "\"pair contains {:?} and {:?}\"" msgstr "\"pair contains {:?} and {:?}\"" #: src/custom_types/structs.md:82 msgid "// Destructure a tuple struct\n" msgstr "// タプル構造体のデストラクト\n" #: src/custom_types/structs.md:91 msgid "" "Add a function `rect_area` which calculates the area of a `Rectangle` (try " "using nested destructuring)." msgstr "" "`Rectangle`の面積を計算する`rect_area`関数を追加してください。ネストしたデス" "トラクトを使ってみましょう。" #: src/custom_types/structs.md:93 msgid "" "Add a function `square` which takes a `Point` and a `f32` as arguments, and " "returns a `Rectangle` with its top left corner on the point, and a width and " "height corresponding to the `f32`." msgstr "" "`Point`と`f32`を引数とし、`Rectangle`を返す`square`関数を追加してください。" "`Rectangle`の左上の点が`Point`になり、`f32`が`Rectangle`の幅と高さになりま" "す。" #: src/custom_types/structs.md:97 msgid "See also" msgstr "参照" #: src/custom_types/structs.md:99 msgid "" "[`attributes`](../attribute.md), [raw identifiers](../compatibility/" "raw_identifiers.md) and [destructuring](../flow_control/match/destructuring." "md)" msgstr "" "[アトリビュート](../attribute.md), [生識別子](../compatibility/" "raw_identifiers.md), [デストラクト](../flow_control/match/destructuring.md)" #: src/custom_types/enum.md:3 msgid "" "The `enum` keyword allows the creation of a type which may be one of a few " "different variants. Any variant which is valid as a `struct` is also valid " "in an `enum`." msgstr "" "列挙型（`enum`）はいくつかの異なる要素型の中から1つを選ぶような場合に使用しま" "す。構造体（`struct`）の定義を満たすものならば何でも`enum` の要素型として使用" "できます。" #: src/custom_types/enum.md:8 msgid "" "// Create an `enum` to classify a web event. Note how both\n" "// names and type information together specify the variant:\n" "// `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.\n" "// Each is different and independent.\n" msgstr "" "// `enum`を作成してwebイベントを分類します。\n" "// 名前と型情報を併せたものが要素型になっていることに注意。\n" "// `PageLoad != PageUnload`、\n" "// `KeyPress(char) != Paste(String)`です。\n" "// 要素型は互いに異なり、互いに非依存です。\n" #: src/custom_types/enum.md:13 msgid "// An `enum` variant may either be `unit-like`,\n" msgstr "// `enum`要素型はユニット風でも構いません。\n" #: src/custom_types/enum.md:16 msgid "// like tuple structs,\n" msgstr "// タプル構造体風\n" #: src/custom_types/enum.md:19 msgid "// or c-like structures.\n" msgstr "// C言語スタイルの構造体風\n" #: src/custom_types/enum.md:22 msgid "" "// A function which takes a `WebEvent` enum as an argument and\n" "// returns nothing.\n" msgstr "// 引数として`WebEvent`列挙型をとり、何も返さない関数\n" #: src/custom_types/enum.md:27 msgid "\"page loaded\"" msgstr "\"page loaded\"" #: src/custom_types/enum.md:28 msgid "\"page unloaded\"" msgstr "\"page unloaded\"" #: src/custom_types/enum.md:29 msgid "// Destructure `c` from inside the `enum` variant.\n" msgstr "// `enum`の要素型から`c`をデストラクトします。\n" #: src/custom_types/enum.md:30 msgid "\"pressed '{}'.\"" msgstr "\"pressed '{}'.\"" #: src/custom_types/enum.md:31 msgid "\"pasted \\\"{}\\\".\"" msgstr "\"pasted \\\"{}\\\".\"" #: src/custom_types/enum.md:32 msgid "// Destructure `Click` into `x` and `y`.\n" msgstr "// `Click`を`x`と`y`にデストラクトします。\n" #: src/custom_types/enum.md:34 msgid "\"clicked at x={}, y={}.\"" msgstr "\"clicked at x={}, y={}.\"" #: src/custom_types/enum.md:40 msgid "'x'" msgstr "'x'" #: src/custom_types/enum.md:41 msgid "// `to_owned()` creates an owned `String` from a string slice.\n" msgstr "" "// `to_owned()`は文字列スライスから所有権のある`String`を作成します。\n" #: src/custom_types/enum.md:42 msgid "\"my text\"" msgstr "\"my text\"" #: src/custom_types/enum.md:56 msgid "Type aliases" msgstr "型エイリアス" #: src/custom_types/enum.md:58 msgid "" "If you use a type alias, you can refer to each enum variant via its alias. " "This might be useful if the enum's name is too long or too generic, and you " "want to rename it." msgstr "" "型エイリアスを用いると、列挙型の要素型を別名で参照できます。これは列挙型の名" "前があまりに長かったり、あまりに一般的だったりで改名したい場合に役立ちます。" #: src/custom_types/enum.md:67 msgid "// Creates a type alias\n" msgstr "// 型エイリアスを作成します。\n" #: src/custom_types/enum.md:72 msgid "" "// We can refer to each variant via its alias, not its long and " "inconvenient\n" " // name.\n" msgstr "" "// 長くて不便な列挙型の名前ではなく、別名を使って要素型を参照できます。\n" #: src/custom_types/enum.md:78 msgid "" "The most common place you'll see this is in `impl` blocks using the `Self` " "alias." msgstr "" "このやり方がもっともよく見られるのは、`impl`ブロックで`Self`という別名を使用" "する場合です。" #: src/custom_types/enum.md:96 msgid "" "To learn more about enums and type aliases, you can read the [stabilization " "report](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847) from when this feature was stabilized into Rust." msgstr "" "列挙型や型エイリアスについて詳しく学びたい人は、この機能が安定してRustに取り" "込まれたときの[stabilization report](https://github.com/rust-lang/rust/" "pull/61682/#issuecomment-502472847)を読んでください。" #: src/custom_types/enum.md:102 msgid "" "[`match`](../flow_control/match.md), [`fn`](../fn.md), and [`String`](../std/" "str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/" "rfcs/2338-type-alias-enum-variants.html)" msgstr "" "[`match`](../flow_control/match.md), [関数](../fn.md), [文字列](../std/str." "md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/" "rfcs/2338-type-alias-enum-variants.html)" #: src/custom_types/enum/enum_use.md:3 msgid "The `use` declaration can be used so manual scoping isn't needed:" msgstr "`use`を使用すれば変数のスコープを絶対名で指定する必要がなくなります。" #: src/custom_types/enum/enum_use.md:20 msgid "" "// Explicitly `use` each name so they are available without\n" " // manual scoping.\n" msgstr "// `use`することで絶対名でなくとも使用可能になります。\n" #: src/custom_types/enum/enum_use.md:23 msgid "// Automatically `use` each name inside `Role`.\n" msgstr "// `Role`の中の名前をすべて`use`します。\n" #: src/custom_types/enum/enum_use.md:26 msgid "// Equivalent to `Stage::Beginner`.\n" msgstr "// `use`しているため、`Stage::Beginner`と同じです。\n" #: src/custom_types/enum/enum_use.md:28 msgid "// Equivalent to `Role::Student`.\n" msgstr "// `Role::Student`と同じ\n" #: src/custom_types/enum/enum_use.md:32 msgid "// Note the lack of scoping because of the explicit `use` above.\n" msgstr "// `use`しているのでスコープを明示していません。\n" #: src/custom_types/enum/enum_use.md:33 msgid "\"Beginners are starting their learning journey!\"" msgstr "" #: src/custom_types/enum/enum_use.md:34 msgid "\"Advanced learners are mastering their subjects...\"" msgstr "" #: src/custom_types/enum/enum_use.md:38 msgid "// Note again the lack of scoping.\n" msgstr "// こちらも同じ\n" #: src/custom_types/enum/enum_use.md:39 msgid "\"Students are acquiring knowledge!\"" msgstr "" #: src/custom_types/enum/enum_use.md:40 msgid "\"Teachers are spreading knowledge!\"" msgstr "" #: src/custom_types/enum/enum_use.md:47 msgid "[`match`](../../flow_control/match.md) and [`use`](../../mod/use.md)" msgstr "[`match`](../../flow_control/match.md), [`use`](../../mod/use.md)" #: src/custom_types/enum/c_like.md:3 msgid "`enum` can also be used as C-like enums." msgstr "列挙型はC言語の列挙型のような使い方をする事もできます。" #: src/custom_types/enum/c_like.md:8 msgid "// enum with implicit discriminator (starts at 0)\n" msgstr "// 値を明示しない場合、0から整数が順に入ります。\n" #: src/custom_types/enum/c_like.md:15 msgid "// enum with explicit discriminator\n" msgstr "// 値を明示する場合\n" #: src/custom_types/enum/c_like.md:24 msgid "// `enums` can be cast as integers.\n" msgstr "// 列挙型の中身は整数としてキャストできます。\n" #: src/custom_types/enum/c_like.md:25 msgid "\"zero is {}\"" msgstr "\"zero is {}\"" #: src/custom_types/enum/c_like.md:26 msgid "\"one is {}\"" msgstr "\"one is {}\"" #: src/custom_types/enum/c_like.md:28 msgid "\"roses are #{:06x}\"" msgstr "\"roses are #{:06x}\"" #: src/custom_types/enum/c_like.md:29 msgid "\"violets are #{:06x}\"" msgstr "\"violets are #{:06x}\"" #: src/custom_types/enum/c_like.md:35 msgid "[casting](../../types/cast.md)" msgstr "[キャスト](../../types/cast.md)" #: src/custom_types/enum/testcase_linked_list.md:3 msgid "A common way to implement a linked-list is via `enums`:" msgstr "" "`enum`の使用が適切なパターンのひとつに、連結リストを作成する場合があります。" #: src/custom_types/enum/testcase_linked_list.md:9 msgid "" "// Cons: Tuple struct that wraps an element and a pointer to the next node\n" msgstr "// Cons：要素をラップし、次の要素へのポインタを保持するタプル構造体\n" #: src/custom_types/enum/testcase_linked_list.md:11 msgid "// Nil: A node that signifies the end of the linked list\n" msgstr "// Nil：連結リストの終端であることを示すノード\n" #: src/custom_types/enum/testcase_linked_list.md:14 msgid "// Methods can be attached to an enum\n" msgstr "// 列挙型にはメソッドを付与することができます。\n" #: src/custom_types/enum/testcase_linked_list.md:17 msgid "// Create an empty list\n" msgstr "// 空リストの作成\n" #: src/custom_types/enum/testcase_linked_list.md:19 msgid "// `Nil` has type `List`\n" msgstr "// `Nil`は`List`型を持ちます。\n" #: src/custom_types/enum/testcase_linked_list.md:23 msgid "" "// Consume a list, and return the same list with a new element at its front\n" msgstr "// リストを受け取り、その始端に新しい要素を付加したものを返す関数\n" #: src/custom_types/enum/testcase_linked_list.md:25 msgid "// `Cons` also has type List\n" msgstr "// この`Cons`自体も、その第2要素もどちらもList型です。\n" #: src/custom_types/enum/testcase_linked_list.md:29 msgid "// Return the length of the list\n" msgstr "// リストの長さを返すメソッド\n" #: src/custom_types/enum/testcase_linked_list.md:31 msgid "" "// `self` has to be matched, because the behavior of this method\n" " // depends on the variant of `self`\n" " // `self` has type `&List`, and `*self` has type `List`, matching on " "a\n" " // concrete type `T` is preferred over a match on a reference `&T`\n" " // after Rust 2018 you can use self here and tail (with no ref) " "below as well,\n" " // rust will infer &s and ref tail. \n" " // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" msgstr "" "// このメソッドは、`self`の状態によって振る舞いが\n" " // 変化するため、matchをする必要があります。\n" " // `self`の型は`&List`なので、`*self`は`List`になります。マッチング" "は\n" " // 参照（`&T`）ではなく実体（`T`）に対して行うのが好ましいです。\n" " // Rust 2018以降ではここでselfと（refのない）tailを使うことができ、\n" " // &selfとref tailが推論されます。\n" " // 参照 https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" #: src/custom_types/enum/testcase_linked_list.md:39 msgid "" "// Can't take ownership of the tail, because `self` is borrowed;\n" " // instead take a reference to the tail\n" msgstr "" "// `self`をすでに借用しているので、tailの所有権を取ることができません。\n" " // 代わりに参照を使用します。\n" #: src/custom_types/enum/testcase_linked_list.md:42 msgid "// Base Case: An empty list has zero length\n" msgstr "// 空リストならば長さは0\n" #: src/custom_types/enum/testcase_linked_list.md:47 msgid "// Return representation of the list as a (heap allocated) string\n" msgstr "// リストをヒープ上の文字列として表したものを返すメソッド\n" #: src/custom_types/enum/testcase_linked_list.md:51 msgid "" "// `format!` is similar to `print!`, but returns a heap\n" " // allocated string instead of printing to the console\n" msgstr "" "// `format!`は`print!`に似ていますが、コンソール上に出力\n" " // する代わりに、ヒープ上の文字列を返します。\n" #: src/custom_types/enum/testcase_linked_list.md:53 src/generics/impl.md:44 msgid "\"{}, {}\"" msgstr "\"{}, {}\"" #: src/custom_types/enum/testcase_linked_list.md:56 msgid "\"Nil\"" msgstr "\"Nil\"" #: src/custom_types/enum/testcase_linked_list.md:63 msgid "// Create an empty linked list\n" msgstr "// 空の連結リストを作成。\n" #: src/custom_types/enum/testcase_linked_list.md:66 msgid "// Prepend some elements\n" msgstr "// 要素を追加。\n" #: src/custom_types/enum/testcase_linked_list.md:71 msgid "// Show the final state of the list\n" msgstr "// 追加後の状態を表示。\n" #: src/custom_types/enum/testcase_linked_list.md:72 msgid "\"linked list has length: {}\"" msgstr "\"linked list has length: {}\"" #: src/custom_types/enum/testcase_linked_list.md:79 msgid "[`Box`](../../std/box.md) and [methods](../../fn/methods.md)" msgstr "[`Box`](../../std/box.md), [メソッド](../../fn/methods.md)" #: src/custom_types/constants.md:3 msgid "" "Rust has two different types of constants which can be declared in any scope " "including global. Both require explicit type annotation:" msgstr "" "Rustには2種類の定数があり、いずれもグローバルスコープを含む任意のスコープで宣" "言することができます。また、いずれも型を明示しなくてはなりません。" #: src/custom_types/constants.md:6 msgid "`const`: An unchangeable value (the common case)." msgstr "`const`：不変の値（通常はこちらを使用します）" #: src/custom_types/constants.md:7 msgid "" "`static`: A possibly mutable variable with [`'static`](../scope/lifetime/" "static_lifetime.md) lifetime. The static lifetime is inferred and does not " "have to be specified. Accessing or modifying a mutable static variable is " "[`unsafe`](../unsafe.md)." msgstr "" "`static`：[`'static`](../scope/lifetime/static_lifetime.md)ライフタイムを持つ" "変更可能な値。スタティックライフタイムは推論され、明示する必要はありません。" "可変なスタティック値へのアクセスや変更は[安全ではありません](../unsafe.md)。" #: src/custom_types/constants.md:12 msgid "// Globals are declared outside all other scopes.\n" msgstr "// グローバル変数はあらゆるスコープの外で宣言します。\n" #: src/custom_types/constants.md:13 msgid "\"Rust\"" msgstr "\"Rust\"" #: src/custom_types/constants.md:17 msgid "// Access constant in some function\n" msgstr "// 関数内から定数を参照。\n" #: src/custom_types/constants.md:24 msgid "// Access constant in the main thread\n" msgstr "// main 関数の中から定数を参照。\n" #: src/custom_types/constants.md:25 msgid "\"This is {}\"" msgstr "\"This is {}\"" #: src/custom_types/constants.md:26 msgid "\"The threshold is {}\"" msgstr "\"The threshold is {}\"" #: src/custom_types/constants.md:27 msgid "\"{} is {}\"" msgstr "\"{} is {}\"" #: src/custom_types/constants.md:27 msgid "\"big\"" msgstr "\"big\"" #: src/custom_types/constants.md:27 msgid "\"small\"" msgstr "\"small\"" #: src/custom_types/constants.md:29 msgid "// Error! Cannot modify a `const`.\n" msgstr "// エラー！const`は変更できません。\n" #: src/custom_types/constants.md:31 src/variable_bindings/scope.md:21 #: src/variable_bindings/declare.md:25 src/variable_bindings/freeze.md:16 #: src/types/cast.md:19 src/types/cast.md:28 src/flow_control/for.md:95 #: src/scope/borrow.md:41 src/scope/borrow/mut.md:52 src/std/vec.md:31 #: src/std/vec.md:44 src/std/hash/hashset.md:48 msgid "// FIXME ^ Comment out this line\n" msgstr "// FIXME ^ この行をコメントアウトしましょう\n" #: src/custom_types/constants.md:37 msgid "" "[The `const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/" "text/0246-const-vs-static.md), [`'static` lifetime](../scope/lifetime/" "static_lifetime.md)" msgstr "" "[`const`/`static` のRFC](https://github.com/rust-lang/rfcs/blob/master/" "text/0246-const-vs-static.md), [`'static` ライフタイム](../scope/lifetime/" "static_lifetime.md)" #: src/variable_bindings.md:3 msgid "" "Rust provides type safety via static typing. Variable bindings can be type " "annotated when declared. However, in most cases, the compiler will be able " "to infer the type of the variable from the context, heavily reducing the " "annotation burden." msgstr "" "Rustは静的な型付けによる型安全性を提供します。変数束縛は宣言時に型を指定でき" "ます。とはいえたいていの場合は、コンパイラは変数の型をコンテキストから推測す" "ることができますので、型指定の負担を大幅に軽減できます。" #: src/variable_bindings.md:8 msgid "" "Values (like literals) can be bound to variables, using the `let` binding." msgstr "値（リテラルなど）は`let`を用いて変数に束縛することができます。" #: src/variable_bindings.md:16 msgid "// copy `an_integer` into `copied_integer`\n" msgstr "// `an_integer`を`copied_integer`へとコピー。\n" #: src/variable_bindings.md:19 msgid "\"An integer: {:?}\"" msgstr "\"An integer: {:?}\"" #: src/variable_bindings.md:20 msgid "\"A boolean: {:?}\"" msgstr "\"A boolean: {:?}\"" #: src/variable_bindings.md:21 msgid "\"Meet the unit value: {:?}\"" msgstr "\"Meet the unit value: {:?}\"" #: src/variable_bindings.md:23 msgid "" "// The compiler warns about unused variable bindings; these warnings can\n" " // be silenced by prefixing the variable name with an underscore\n" msgstr "" "// 使用されていない変数があると、コンパイラは警告を出します。\n" " // 変数名の頭に`_`（アンダーバー）を付けると警告を消すことができます。\n" #: src/variable_bindings.md:28 msgid "" "// FIXME ^ Prefix with an underscore to suppress the warning\n" " // Please note that warnings may not be shown in a browser\n" msgstr "" "// FIXME ^ 頭にアンダーバーを付けて、警告を抑えましょう。\n" " // 警告はブラウザ上では表示されないかもしれません。\n" #: src/variable_bindings/mut.md:3 msgid "" "Variable bindings are immutable by default, but this can be overridden using " "the `mut` modifier." msgstr "" "変数はデフォルトでイミュータブル（変更不可能）ですが`mut`構文を使用することで" "変更可能になります。" #: src/variable_bindings/mut.md:11 msgid "\"Before mutation: {}\"" msgstr "\"Before mutation: {}\"" #: src/variable_bindings/mut.md:13 msgid "// Ok\n" msgstr "// 問題ありません。\n" #: src/variable_bindings/mut.md:16 msgid "\"After mutation: {}\"" msgstr "\"After mutation: {}\"" #: src/variable_bindings/mut.md:18 msgid "// Error! Cannot assign a new value to an immutable variable\n" msgstr "" "// エラー！イミュータブルな変数に新しい値を代入することはできません。\n" #: src/variable_bindings/mut.md:23 msgid "The compiler will throw a detailed diagnostic about mutability errors." msgstr "コンパイラはミュータビリティに関するエラーの詳細を出してくれます。" #: src/variable_bindings/scope.md:3 msgid "" "Variable bindings have a scope, and are constrained to live in a _block_. A " "block is a collection of statements enclosed by braces `{}`." msgstr "" "変数はスコープを持つため、 **ブロック** の中に閉じ込められています。ブロック" "とは`{}`で囲まれた領域のことです。" #: src/variable_bindings/scope.md:7 msgid "// This binding lives in the main function\n" msgstr "// この変数はmain関数の間、生存しています。\n" #: src/variable_bindings/scope.md:10 msgid "// This is a block, and has a smaller scope than the main function\n" msgstr "// ここから下がmain関数より小さいスコープを持つブロックとなります。\n" #: src/variable_bindings/scope.md:12 msgid "// This binding only exists in this block\n" msgstr "// この変数はこのブロック内のみに存在します。\n" #: src/variable_bindings/scope.md:15 msgid "\"inner short: {}\"" msgstr "\"inner short: {}\"" #: src/variable_bindings/scope.md:17 msgid "// End of the block\n" msgstr "// ブロックの終わり\n" #: src/variable_bindings/scope.md:19 msgid "// Error! `short_lived_binding` doesn't exist in this scope\n" msgstr "// エラー！`short_lived_binding`はこのスコープ内には存在しません。\n" #: src/variable_bindings/scope.md:20 msgid "\"outer short: {}\"" msgstr "\"outer short: {}\"" #: src/variable_bindings/scope.md:23 msgid "\"outer long: {}\"" msgstr "\"outer long: {}\"" #: src/variable_bindings/scope.md:26 msgid "" "Also, [variable shadowing](https://en.wikipedia.org/wiki/Variable_shadowing) " "is allowed." msgstr "" "[変数のシャドーイング](https://en.wikipedia.org/wiki/Variable_shadowing)も可" "能です。" #: src/variable_bindings/scope.md:32 msgid "\"before being shadowed: {}\"" msgstr "\"before being shadowed: {}\"" #: src/variable_bindings/scope.md:34 msgid "// This binding *shadows* the outer one\n" msgstr "// この変数はスコープ外の同名の変数を *シャドーイング* します。\n" #: src/variable_bindings/scope.md:35 msgid "\"abc\"" msgstr "\"abc\"" #: src/variable_bindings/scope.md:37 msgid "\"shadowed in inner block: {}\"" msgstr "\"shadowed in inner block: {}\"" #: src/variable_bindings/scope.md:39 msgid "\"outside inner block: {}\"" msgstr "\"outside inner block: {}\"" #: src/variable_bindings/scope.md:41 msgid "// This binding *shadows* the previous binding\n" msgstr "// この変数束縛は以前に定義した変数を *シャドーイング* します。\n" #: src/variable_bindings/scope.md:43 msgid "\"shadowed in outer block: {}\"" msgstr "\"shadowed in outer block: {}\"" #: src/variable_bindings/declare.md:3 msgid "" "It's possible to declare variable bindings first, and initialize them later. " "However, this form is seldom used, as it may lead to the use of " "uninitialized variables." msgstr "" "変数の宣言だけを行っておき、初期化をのちに行うことも可能です。しかし、最後ま" "で初期化されない変数が生じる可能性があるため、ふつうは同時に行われます。" #: src/variable_bindings/declare.md:9 msgid "// Declare a variable binding\n" msgstr "// 変数を宣言。\n" #: src/variable_bindings/declare.md:15 msgid "// Initialize the binding\n" msgstr "// 変数を初期化。\n" #: src/variable_bindings/declare.md:19 msgid "\"a binding: {}\"" msgstr "\"a binding: {}\"" #: src/variable_bindings/declare.md:23 msgid "// Error! Use of uninitialized binding\n" msgstr "// エラー！初期化していない変数の使用\n" #: src/variable_bindings/declare.md:24 src/variable_bindings/declare.md:29 msgid "\"another binding: {}\"" msgstr "\"another binding: {}\"" #: src/variable_bindings/declare.md:33 msgid "" "The compiler forbids use of uninitialized variables, as this would lead to " "undefined behavior." msgstr "" "未初期化の変数があると予期せぬ動作をする場合があるため、コンパイラは変数を初" "期化してから使用するよう強制します。" #: src/variable_bindings/freeze.md:3 msgid "" "When data is bound by the same name immutably, it also _freezes_. _Frozen_ " "data can't be modified until the immutable binding goes out of scope:" msgstr "" "データを同じ名前のイミュータブルな変数に束縛しなおすと、データは*凍結*されま" "す。*凍結*したデータは、イミュータブルな束縛がスコープ外になるまで変更できま" "せん。" #: src/variable_bindings/freeze.md:11 msgid "// Shadowing by immutable `_mutable_integer`\n" msgstr "// イミュータブルな`_mutable_integer`でシャドーイングします。\n" #: src/variable_bindings/freeze.md:14 msgid "// Error! `_mutable_integer` is frozen in this scope\n" msgstr "// エラー！`_mutable_integer`はこのスコープでは凍結しています。\n" #: src/variable_bindings/freeze.md:18 msgid "// `_mutable_integer` goes out of scope\n" msgstr "// `_mutable_integer`はスコープを抜けます。\n" #: src/variable_bindings/freeze.md:21 msgid "// Ok! `_mutable_integer` is not frozen in this scope\n" msgstr "// OK！`_mutable_integer`はこのスコープでは凍結していません。\n" #: src/types.md:3 msgid "" "Rust provides several mechanisms to change or define the type of primitive " "and user defined types. The following sections cover:" msgstr "" "Rustには、基本データ型やユーザ定義型を定義したり変換したりする様々な方法があ" "ります。この章は以下の内容を扱います。" #: src/types.md:5 msgid "[Casting](types/cast.md) between primitive types" msgstr "基本データ型の間で[キャスト](types/cast.md)を行う。" #: src/types.md:6 msgid "Specifying the desired type of [literals](types/literals.md)" msgstr "[リテラル](types/literals.md)の型をどれにしたいか指定する。" #: src/types.md:7 msgid "Using [type inference](types/inference.md)" msgstr "[型推論](types/inference.md)を使う。" #: src/types.md:8 msgid "[Aliasing](types/alias.md) types" msgstr "型を[エイリアス](types/alias.md)する。" #: src/types/cast.md:3 msgid "" "Rust provides no implicit type conversion (coercion) between primitive " "types. But, explicit type conversion (casting) can be performed using the " "`as` keyword." msgstr "" "Rustは基本データ型について暗黙的な型変換（`coerction`）を行うことはありませ" "ん。しかし明示的な型変換（`casting`）は可能です。その場合`as`キーワードを使用" "します。" #: src/types/cast.md:6 msgid "" "Rules for converting between integral types follow C conventions generally, " "except in cases where C has undefined behavior. The behavior of all casts " "between integral types is well defined in Rust." msgstr "" "整数型から整数型へ型変換する場合、C言語で可能なケースの場合はC言語と同じで" "す。C言語で未定義の場合の挙動も、Rustでは完全に定義されています。" #: src/types/cast.md:11 msgid "// Suppress all warnings from casts which overflow.\n" msgstr "// オーバーフローを起こすようなキャストによる警告を無視します。\n" #: src/types/cast.md:17 msgid "// Error! No implicit conversion\n" msgstr "// エラー！暗黙的な型変換はできません。\n" #: src/types/cast.md:21 msgid "// Explicit conversion\n" msgstr "// 明示的な型変換\n" #: src/types/cast.md:25 msgid "" "// Error! There are limitations in conversion rules.\n" " // A float cannot be directly converted to a char.\n" msgstr "" "// エラー！変換ルールには制限があります。\n" " // 浮動小数点数を文字に直接変換することはできません。\n" #: src/types/cast.md:30 msgid "\"Casting: {} -> {} -> {}\"" msgstr "\"Casting: {} -> {} -> {}\"" #: src/types/cast.md:32 msgid "" "// when casting any value to an unsigned type, T,\n" " // T::MAX + 1 is added or subtracted until the value\n" " // fits into the new type\n" msgstr "" "// 何らかの値を符号なしの型（仮にTとする）へキャストすると\n" " // 値がTに収まるまで、T::MAX + 1 が加算あるいは減算されます。\n" #: src/types/cast.md:36 msgid "// 1000 already fits in a u16\n" msgstr "// 1000はすでにu16に収まっているため変化しません。\n" #: src/types/cast.md:37 msgid "\"1000 as a u16 is: {}\"" msgstr "\"1000 as a u16 is: {}\"" #: src/types/cast.md:39 msgid "" "// 1000 - 256 - 256 - 256 = 232\n" " // Under the hood, the first 8 least significant bits (LSB) are kept,\n" " // while the rest towards the most significant bit (MSB) get truncated.\n" msgstr "" "// 1000 - 256 - 256 - 256 = 232\n" " // 詳しく見てみると、最下位ビットから8bitが保持され、\n" " // 残りの上位ビットが切り取られる形になります。\n" #: src/types/cast.md:42 src/types/cast.md:61 msgid "\"1000 as a u8 is : {}\"" msgstr "\"1000 as a u8 is : {}\"" #: src/types/cast.md:43 msgid "// -1 + 256 = 255\n" msgstr "// -1 + 256 = 255\n" #: src/types/cast.md:44 msgid "\" -1 as a u8 is : {}\"" msgstr "\" -1 as a u8 is : {}\"" #: src/types/cast.md:46 msgid "// For positive numbers, this is the same as the modulus\n" msgstr "// 正の数では、これは剰余と同じです。\n" #: src/types/cast.md:47 msgid "\"1000 mod 256 is : {}\"" msgstr "\"1000 mod 256 is : {}\"" #: src/types/cast.md:49 msgid "" "// When casting to a signed type, the (bitwise) result is the same as\n" " // first casting to the corresponding unsigned type. If the most " "significant\n" " // bit of that value is 1, then the value is negative.\n" msgstr "" "// 符号付きの型にキャストする場合、（ビットとして見た）結果は対応する\n" " // 符号無し型へのキャストを行った結果と同じです。\n" " // 最上位ビットが1であれば、その値は負であることを示しています。\n" #: src/types/cast.md:53 msgid "// Unless it already fits, of course.\n" msgstr "// すでに収まっている場合はそのままです。\n" #: src/types/cast.md:54 msgid "\" 128 as a i16 is: {}\"" msgstr "\" 128 as a i16 is: {}\"" #: src/types/cast.md:56 msgid "" "// In boundary case 128 value in 8-bit two's complement representation is " "-128\n" msgstr "" "// 境界値のケースを考えると、128の8ビットにおける2の補数は -128です。\n" #: src/types/cast.md:57 msgid "\" 128 as a i8 is : {}\"" msgstr "\" 128 as a i8 is : {}\"" #: src/types/cast.md:59 msgid "" "// repeating the example above\n" " // 1000 as u8 -> 232\n" msgstr "" "// 上で示した例を繰り返すと\n" " // 1000 as u8 -> 232\n" #: src/types/cast.md:62 msgid "" "// and the value of 232 in 8-bit two's complement representation is -24\n" msgstr "// 232の8ビットにおける補数は -24。\n" #: src/types/cast.md:63 msgid "\" 232 as a i8 is : {}\"" msgstr "\" 232 as a i8 is : {}\"" #: src/types/cast.md:65 msgid "" "// Since Rust 1.45, the `as` keyword performs a *saturating cast*\n" " // when casting from float to int. If the floating point value exceeds\n" " // the upper bound or is less than the lower bound, the returned value\n" " // will be equal to the bound crossed.\n" msgstr "" "// Rust 1.45以降、浮動小数点数を整数にキャストするとき、\n" " // `as`キーワードが *飽和的キャスト* を行います。\n" " // 浮動小数点数の値が上限を超えたり下限を下回ったりする場合は、\n" " // 戻り値は越えられた境界の値となります。\n" #: src/types/cast.md:70 msgid "// 300.0 as u8 is 255\n" msgstr "// 300.0 as u8 は 255\n" #: src/types/cast.md:71 src/types/cast.md:82 msgid "\" 300.0 as u8 is : {}\"" msgstr "\" 300.0 as u8 is : {}\"" #: src/types/cast.md:72 msgid "// -100.0 as u8 is 0\n" msgstr "// -100.0 as u8 は 0\n" #: src/types/cast.md:73 src/types/cast.md:84 msgid "\"-100.0 as u8 is : {}\"" msgstr "\"-100.0 as u8 is : {}\"" #: src/types/cast.md:74 src/types/cast.md:85 msgid "// nan as u8 is 0\n" msgstr "// nan as u8 は 0\n" #: src/types/cast.md:75 src/types/cast.md:86 msgid "\" nan as u8 is : {}\"" msgstr "\" nan as u8 is : {}\"" #: src/types/cast.md:77 msgid "" "// This behavior incurs a small runtime cost and can be avoided\n" " // with unsafe methods, however the results might overflow and\n" " // return **unsound values**. Use these methods wisely:\n" msgstr "" "// この挙動は実行時にややコストがかかるため、安全でない方法で回避できます。\n" " // ただし、結果はオーバーフローしたり *不正確な値* を返す場合がありま" "す。\n" " // この方法は賢く使いましょう。\n" #: src/types/cast.md:81 msgid "// 300.0 as u8 is 44\n" msgstr "// 300.0 as u8 は 44\n" #: src/types/cast.md:83 msgid "// -100.0 as u8 is 156\n" msgstr "// -100.0 as u8 は 156\n" #: src/types/literals.md:3 msgid "" "Numeric literals can be type annotated by adding the type as a suffix. As an " "example, to specify that the literal `42` should have the type `i32`, write " "`42i32`." msgstr "" "数値型リテラルはサフィックスにより型を指定することが可能です。例えば、`42`と" "いうリテラルに対して`i32`型を指定するには`42i32`とします。" #: src/types/literals.md:6 msgid "" "The type of unsuffixed numeric literals will depend on how they are used. If " "no constraint exists, the compiler will use `i32` for integers, and `f64` " "for floating-point numbers." msgstr "" "サフィックスを指定しない数値型リテラルの場合、その型がどのように使用されるか" "に依存して決められます。デフォルトでは整数型の場合`i32`が、浮動小数点数型には" "`f64`が使われます。" #: src/types/literals.md:12 msgid "// Suffixed literals, their types are known at initialization\n" msgstr "// サフィックスを指定したリテラル。型は初期化とともに確定します。\n" #: src/types/literals.md:17 msgid "// Unsuffixed literals, their types depend on how they are used\n" msgstr "// サフィックスを指定しないリテラル。型は使用方法に依存します。\n" #: src/types/literals.md:21 msgid "// `size_of_val` returns the size of a variable in bytes\n" msgstr "// `size_of_val`関数は変数のサイズをバイトで返します。\n" #: src/types/literals.md:22 msgid "\"size of `x` in bytes: {}\"" msgstr "\"size of `x` in bytes: {}\"" #: src/types/literals.md:23 msgid "\"size of `y` in bytes: {}\"" msgstr "\"size of `y` in bytes: {}\"" #: src/types/literals.md:24 msgid "\"size of `z` in bytes: {}\"" msgstr "\"size of `z` in bytes: {}\"" #: src/types/literals.md:25 msgid "\"size of `i` in bytes: {}\"" msgstr "\"size of `i` in bytes: {}\"" #: src/types/literals.md:26 msgid "\"size of `f` in bytes: {}\"" msgstr "\"size of `f` in bytes: {}\"" #: src/types/literals.md:30 msgid "" "There are some concepts used in the previous code that haven't been " "explained yet, here's a brief explanation for the impatient readers:" msgstr "" "上のコードには現時点では解説していない考えがいくつか使用されています。気にな" "る方のために簡単に説明をしておきましょう。" #: src/types/literals.md:33 msgid "" "`std::mem::size_of_val` is a function, but called with its _full path_. Code " "can be split in logical units called _modules_. In this case, the " "`size_of_val` function is defined in the `mem` module, and the `mem` module " "is defined in the `std` _crate_. For more details, see [modules](../mod.md) " "and [crates](../crates.md)." msgstr "" "`std::mem::size_of_val`は関数ですが、 *絶対パス* で呼び出されています。ソース" "コードは論理的に区切られた *モジュール* と呼ばれるものにわけられることができ" "ます。今回の場合は`size_of_val`関数は`mem`モジュール内で定義されており、`mem`" "モジュールは`std` *クレート* 内で定義されています。より詳しくは[モジュール]" "(../mod.md)と[クレート](../crates.md)を参照してください。" #: src/types/inference.md:3 msgid "" "The type inference engine is pretty smart. It does more than looking at the " "type of the value expression during an initialization. It also looks at how " "the variable is used afterwards to infer its type. Here's an advanced " "example of type inference:" msgstr "" "Rustの型推論エンジンはなかなか賢くできています。初期化の際に評価値の型を" "チェックするだけでなく、その後にどのような使われ方をしているかを見て推論しま" "す。以下がその例です。" #: src/types/inference.md:10 msgid "" "// Because of the annotation, the compiler knows that `elem` has type u8.\n" msgstr "" "// アノテーションのおかげで、コンパイラは`elem`がu8型であることがわかりま" "す。\n" #: src/types/inference.md:13 msgid "// Create an empty vector (a growable array).\n" msgstr "// 空のベクタ（可変長の配列）を生成。\n" #: src/types/inference.md:15 msgid "" "// At this point the compiler doesn't know the exact type of `vec`, it\n" " // just knows that it's a vector of something (`Vec<_>`).\n" msgstr "" "// この時点でコンパイラは`vec`の型を知りませんが、\n" " // 何らかの値のベクタ（`Vec<_>`）であるということだけは把握しています。\n" #: src/types/inference.md:18 msgid "// Insert `elem` in the vector.\n" msgstr "// `elem`をベクタに挿入。\n" #: src/types/inference.md:20 msgid "" "// Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec`)\n" " // TODO ^ Try commenting out the `vec.push(elem)` line\n" msgstr "" "// よし！これでコンパイラは`vec`が`u8`のベクタ（`Vec`）\n" " // であることを把握しました。\n" " // TODO ^ 上の`vec.push(elem)`をコメントアウトしてみましょう。\n" #: src/types/inference.md:27 msgid "" "No type annotation of variables was needed, the compiler is happy and so is " "the programmer!" msgstr "" "このように、変数の型アノテーションは必要ありません。これでコンパイラもプログ" "ラマもハッピーですね！" #: src/types/alias.md:3 msgid "" "The `type` statement can be used to give a new name to an existing type. " "Types must have `UpperCamelCase` names, or the compiler will raise a " "warning. The exception to this rule are the primitive types: `usize`, `f32`, " "etc." msgstr "" "`type`文を使用することで既存の型に新しい名前を付けることができます。その場" "合、名前は`UpperCamelCase`でなくてはなりません。さもなくばコンパイラがエラー" "を出します。唯一の例外は`usize`や`f32`のような基本データ型です。" #: src/types/alias.md:8 msgid "// `NanoSecond`, `Inch`, and `U64` are new names for `u64`.\n" msgstr "// `NanoSecond` `Inch` `U64` を`u64`の別名として使用します。\n" #: src/types/alias.md:14 msgid "// `NanoSecond` = `Inch` = `U64` = `u64`.\n" msgstr "// `NanoSecond` = `Inch` = `U64` = `u64`\n" #: src/types/alias.md:18 msgid "" "// Note that type aliases *don't* provide any extra type safety, because\n" " // aliases are *not* new types\n" msgstr "" "// 型のエイリアスは、元の型をより型安全する **わけではない** ことに注意。\n" " // なぜならば、エイリアスは新たな型を定義している **わけではない** からで" "す。\n" #: src/types/alias.md:20 msgid "\"{} nanoseconds + {} inches = {} unit?\"" msgstr "\"{} nanoseconds + {} inches = {} unit?\"" #: src/types/alias.md:27 msgid "" "The main use of aliases is to reduce boilerplate; for example the `io::" "Result` type is an alias for the `Result` type." msgstr "" "このようにエイリアスを付ける一番の理由はボイラープレートを減らすことです。例" "えば`io::Result`型は`Result`の別名です。" #: src/types/alias.md:32 msgid "[Attributes](../attribute.md)" msgstr "[アトリビュート](../attribute.md)" #: src/conversion.md:3 msgid "" "Primitive types can be converted to each other through [casting](types/cast." "md)." msgstr "基本データ型同士は[キャスト](types/cast.md)を用いて変換できます。" #: src/conversion.md:5 msgid "" "Rust addresses conversion between custom types (i.e., `struct` and `enum`) " "by the use of [traits](trait.md). The generic conversions will use the " "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`Into`]" "(https://doc.rust-lang.org/std/convert/trait.Into.html) traits. However " "there are more specific ones for the more common cases, in particular when " "converting to and from `String`s." msgstr "" "Rustはカスタム型（例えば`struct`や`enum`）間の変換を[トレイト](trait.md)を用" "いて行います。ジェネリックな型変換には[`From`](https://doc.rust-lang.org/std/" "convert/trait.From.html)および[`Into`](https://doc.rust-lang.org/std/convert/" "trait.Into.html)トレイトを使用します。しかし、よくあるケースにおいて、特に" "`String`との相互の型変換では、特殊なトレイトが使用されます。" #: src/conversion/from_into.md:3 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) traits are " "inherently linked, and this is actually part of its implementation. If you " "are able to convert type A from type B, then it should be easy to believe " "that we should be able to convert type B to type A." msgstr "" "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html)トレイトと" "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html)トレイトは本質" "的に結びついており、そのことが実際の実装に反映されています。もし型Aが型Bから" "の型変換をサポートしているのであれば、型Bは型Aへの型変換ができると思うのが自" "然です。" #: src/conversion/from_into.md:7 msgid "`From`" msgstr "`From`" #: src/conversion/from_into.md:9 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) trait " "allows for a type to define how to create itself from another type, hence " "providing a very simple mechanism for converting between several types. " "There are numerous implementations of this trait within the standard library " "for conversion of primitive and common types." msgstr "" "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html)トレイトは、あ" "る型に対し、別の型からその型を作る方法を定義できるようにするものです。そのた" "め、複数の型の間で型変換を行うための非常にシンプルな仕組みを提供しています。" "標準ライブラリでは、基本データ型やよく使われる型に対して、このトレイトが多数" "実装されています。" #: src/conversion/from_into.md:14 msgid "For example we can easily convert a `str` into a `String`" msgstr "例えば、`str`から`String`への型変換は簡単です。" #: src/conversion/from_into.md:21 msgid "We can do similar for defining a conversion for our own type." msgstr "自作の型に対しても、型変換を定義すれば同じように行えます。" #: src/conversion/from_into.md:39 src/conversion/from_into.md:68 #: src/conversion/from_into.md:98 msgid "\"My number is {:?}\"" msgstr "\"My number is {:?}\"" #: src/conversion/from_into.md:43 msgid "`Into`" msgstr "`Into`" #: src/conversion/from_into.md:45 msgid "" "The [`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) trait is " "simply the reciprocal of the `From` trait. It defines how to convert a type " "into another type." msgstr "" "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html)トレイトは、単" "に`From`トレイトの逆の働きをし、ある型を他の型に変換する方法を定義します。" #: src/conversion/from_into.md:48 msgid "" "Calling `into()` typically requires us to specify the result type as the " "compiler is unable to determine this most of the time." msgstr "" "`into()` の呼び出し時にはほとんどの場合戻り値の型をコンパイラが決定できません。" "そのため戻り値の型は明示的に指定する必要があります。" #: src/conversion/from_into.md:66 msgid "// Try removing the type annotation\n" msgstr "// ここの型アノテーションを消してみましょう。\n" #: src/conversion/from_into.md:72 msgid "`From` and `Into` are interchangable" msgstr "`From`と`Into` は交換可能" #: src/conversion/from_into.md:74 msgid "" "`From` and `Into` are designed to be complementary. We do not need to " "provide an implementation for both traits. If you have implemented the " "`From` trait for your type, `Into` will call it when necessary. Note, " "however, that the converse is not true: implementing `Into` for your type " "will not automatically provide it with an implementation of `From`." msgstr "" "`From` と `Into` は相補的にデザインされているので両方のトレイトを実装する必要はありません。" "`From` トレイトを実装すれば、 `Into` は必要なときに呼ばれます。" "ただし、逆は真ではない点に注意してください。 `Into` が実装されていても、 `From` が自動的に提供されるわけではありません。" #: src/conversion/from_into.md:86 msgid "// Define `From`\n" msgstr "// Define `From`\n" #: src/conversion/from_into.md:96 msgid "// use `Into`\n" msgstr "// use `Into`\n" #: src/conversion/try_from_try_into.md:3 msgid "" "Similar to [`From` and `Into`](from_into.html), [`TryFrom`](https://doc.rust-" "lang.org/std/convert/trait.TryFrom.html) and [`TryInto`](https://doc.rust-" "lang.org/std/convert/trait.TryInto.html) are generic traits for converting " "between types. Unlike `From`/`Into`, the `TryFrom`/`TryInto` traits are used " "for fallible conversions, and as such, return [`Result`](https://doc.rust-" "lang.org/std/result/enum.Result.html)s." msgstr "" "[`From`と`Into`](from_into.html)と同様に、[`TryFrom`](https://doc.rust-lang." "org/std/convert/trait.TryFrom.html)と[`TryInto`](https://doc.rust-lang.org/" "std/convert/trait.TryInto.html)も型変換を行うジェネリックなトレイトです。" "`From`/`Into`と異なり、`TryFrom`/`TryInto`トレイトは失敗する可能性のある型変" "換に用いられるので、[`Result`](https://doc.rust-lang.org/std/result/enum." "Result.html)を返します。" #: src/conversion/try_from_try_into.md:33 msgid "// TryFrom\n" msgstr "// TryFrom\n" #: src/conversion/try_from_try_into.md:38 msgid "// TryInto\n" msgstr "// TryInto\n" #: src/conversion/string.md:1 msgid "To and from Strings" msgstr "Stringとの型変換" #: src/conversion/string.md:3 msgid "Converting to String" msgstr "Stringへの型変換" #: src/conversion/string.md:5 msgid "" "To convert any type to a `String` is as simple as implementing the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "for the type. Rather than doing so directly, you should implement the [`fmt::" "Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html) trait which " "automagically provides [`ToString`](https://doc.rust-lang.org/std/string/" "trait.ToString.html) and also allows printing the type as discussed in the " "section on [`print!`](../hello/print.md)." msgstr "" "任意の型を`String`に変換するのは簡単で、その型に[`ToString`](https://doc." "rust-lang.org/std/string/trait.ToString.html)トレイトを実装するだけです。これ" "を直接実装するよりも、[`fmt::Display`](https://doc.rust-lang.org/std/fmt/" "trait.Display.html)トレイトを実装するのがよいでしょう。そうすることで自動的に" "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html)が提供" "されるだけでなく、[`print!`](../hello/print.md)の章で説明したように、その型を" "表示できるようにもなります。" #: src/conversion/string.md:19 msgid "\"Circle of radius {}\"" msgstr "\"Circle of radius {}\"" #: src/conversion/string.md:29 msgid "Parsing a String" msgstr "Stringの解析" #: src/conversion/string.md:31 msgid "" "It's useful to convert strings into many types, but one of the more common " "string operations is to convert them from string to number. The idiomatic " "approach to this is to use the [`parse`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) function and either to arrange for type " "inference or to specify the type to parse using the 'turbofish' syntax. Both " "alternatives are shown in the following example." msgstr "" "文字列からの型変換において、数値への型変換はよく行われるものの一つです。これ" "を行うイディオムは[`parse`](https://doc.rust-lang.org/std/primitive.str." "html#method.parse)関数を使用することですが、このときに型を推論できるようにす" "るか、もしくはターボフィッシュ構文（`::<>`）を使用して型を指定するかのいずれ" "かを行います。以下の例では、どちらの方法も紹介しています。" #: src/conversion/string.md:37 msgid "" "This will convert the string into the type specified as long as the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait is " "implemented for that type. This is implemented for numerous types within the " "standard library. To obtain this functionality on a user defined type simply " "implement the [`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr." "html) trait for that type." msgstr "" "`parse`関数は、指定された型に[`FromStr`](https://doc.rust-lang.org/std/str/" "trait.FromStr.html)トレイトが実装されていれば、文字列をその型に変換します。こ" "のトレイトは標準ライブラリの多くの型に対して実装されています。ユーザー定義の" "型でこの機能を利用するには、その型に対して[`FromStr`](https://doc.rust-lang." "org/std/str/trait.FromStr.html)トレイトを実装するだけです。" #: src/conversion/string.md:44 src/std_misc/process/wait.md:10 msgid "\"5\"" msgstr "\"5\"" #: src/conversion/string.md:45 src/error/result.md:33 src/error/result.md:68 #: src/error/result/result_map.md:42 src/error/result/result_map.md:75 #: src/error/result/result_alias.md:36 src/error/result/early_returns.md:36 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:67 msgid "\"10\"" msgstr "\"10\"" #: src/conversion/string.md:48 msgid "\"Sum: {:?}\"" msgstr "\"Sum: {:?}\"" #: src/expression.md:3 msgid "A Rust program is (mostly) made up of a series of statements:" msgstr "Rustのプログラムは（ほとんどの場合）文の連続でできています" #: src/expression.md:7 msgid "" "// statement\n" " // statement\n" " // statement\n" msgstr "" "// statement\n" " // statement\n" " // statement\n" #: src/expression.md:13 msgid "" "There are a few kinds of statements in Rust. The most common two are " "declaring a variable binding, and using a `;` with an expression:" msgstr "" "文にはいくつかの種類があります。最も一般的なのは変数の束縛と`;`付きの式です。" #: src/expression.md:18 msgid "// variable binding\n" msgstr "// 変数束縛\n" #: src/expression.md:21 msgid "// expression;\n" msgstr "// 式;\n" #: src/expression.md:28 msgid "" "Blocks are expressions too, so they can be used as values in assignments. " "The last expression in the block will be assigned to the place expression " "such as a local variable. However, if the last expression of the block ends " "with a semicolon, the return value will be `()`." msgstr "" "コードブロックも式の一種です。よってブロックを丸ごと値として扱うことができま" "す。その場合ブロック内の最後の式が場所を表す式（例えばローカル変数）に代入さ" "れます。ただし、ブロック内の最後の式が`;`で終わる場合は返り値は`()`になりま" "す。" #: src/expression.md:41 msgid "// This expression will be assigned to `y`\n" msgstr "// この式は`y`に代入されます。\n" #: src/expression.md:46 msgid "" "// The semicolon suppresses this expression and `()` is assigned to `z`\n" msgstr "// セミコロンがあるので`z`には`()`が入ります。\n" #: src/expression.md:50 msgid "\"x is {:?}\"" msgstr "\"x is {:?}\"" #: src/expression.md:51 msgid "\"y is {:?}\"" msgstr "\"y is {:?}\"" #: src/expression.md:52 msgid "\"z is {:?}\"" msgstr "\"z is {:?}\"" #: src/flow_control.md:3 msgid "" "An integral part of any programming language are ways to modify control " "flow: `if`/`else`, `for`, and others. Let's talk about them in Rust." msgstr "" "処理の流れをコントロールすることはあらゆるプログラミング言語において重要な要" "素です。`if`/`else`、`for`等です。Rustの文法を見ていきましょう。" #: src/flow_control/if_else.md:3 msgid "" "Branching with `if`\\-`else` is similar to other languages. Unlike many of " "them, the boolean condition doesn't need to be surrounded by parentheses, " "and each condition is followed by a block. `if`\\-`else` conditionals are " "expressions, and, all branches must return the same type." msgstr "" "`if`\\-`else`を用いた条件分岐は他の言語に似ています。多くの言語では条件式の中" "を括弧でくくる必要がありますが、Rustではその必要はありません。条件式の直後に" "はブロックが続きます。`if`\\-`else`は式の一種で、いずれの分岐先でも返り値の型" "は同一でなくてはなりません。" #: src/flow_control/if_else.md:13 msgid "\"{} is negative\"" msgstr "\"{} is negative\"" #: src/flow_control/if_else.md:15 msgid "\"{} is positive\"" msgstr "\"{} is positive\"" #: src/flow_control/if_else.md:17 msgid "\"{} is zero\"" msgstr "\"{} is zero\"" #: src/flow_control/if_else.md:22 msgid "\", and is a small number, increase ten-fold\"" msgstr "\", and is a small number, increase ten-fold\"" #: src/flow_control/if_else.md:24 msgid "// This expression returns an `i32`.\n" msgstr "// この式は`i32`を返します。\n" #: src/flow_control/if_else.md:27 msgid "\", and is a big number, halve the number\"" msgstr "\", and is a big number, halve the number\"" #: src/flow_control/if_else.md:29 msgid "// This expression must return an `i32` as well.\n" msgstr "// ここでも返り値の型は`i32`でなくてはなりません。\n" #: src/flow_control/if_else.md:31 msgid "// TODO ^ Try suppressing this expression with a semicolon.\n" msgstr "// TODO ^ セミコロン`;`をつけて返り値を返さないようにしてみましょう\n" #: src/flow_control/if_else.md:33 msgid "" "// ^ Don't forget to put a semicolon here! All `let` bindings need it.\n" msgstr "" "// ^ ここにセミコロンを付けるのを忘れないように！\n" " // `let`による変数束縛の際には必ず必要です。\n" #: src/flow_control/if_else.md:35 src/flow_control/match.md:35 msgid "\"{} -> {}\"" msgstr "\"{} -> {}\"" #: src/flow_control/loop.md:3 msgid "Rust provides a `loop` keyword to indicate an infinite loop." msgstr "" "Rustには`loop`というキーワードが存在します。これは無限ループを作成するのに使" "用します。" #: src/flow_control/loop.md:5 msgid "" "The `break` statement can be used to exit a loop at anytime, whereas the " "`continue` statement can be used to skip the rest of the iteration and start " "a new one." msgstr "" "ループから抜けだす時は`break`、即座に次のループに移るときは`continue`が使用で" "きます。" #: src/flow_control/loop.md:13 msgid "\"Let's count until infinity!\"" msgstr "\"Let's count until infinity!\"" #: src/flow_control/loop.md:15 msgid "// Infinite loop\n" msgstr "// 無限ループ\n" #: src/flow_control/loop.md:20 msgid "\"three\"" msgstr "\"three\"" #: src/flow_control/loop.md:22 msgid "// Skip the rest of this iteration\n" msgstr "// 残りの処理をスキップ。\n" #: src/flow_control/loop.md:29 msgid "\"OK, that's enough\"" msgstr "\"OK, that's enough\"" #: src/flow_control/loop.md:31 msgid "// Exit this loop\n" msgstr "// ループを抜ける。\n" #: src/flow_control/loop/nested.md:3 msgid "" "It's possible to `break` or `continue` outer loops when dealing with nested " "loops. In these cases, the loops must be annotated with some `'label`, and " "the label must be passed to the `break`/`continue` statement." msgstr "" "ネストしたループを回している時に外側のループを`break`または`continue`したい場" "合があります。こういった場合には`'label`を用いてループにラベルを貼り、" "`break`/`continue`にそのラベルを渡します。" #: src/flow_control/loop/nested.md:12 msgid "\"Entered the outer loop\"" msgstr "\"Entered the outer loop\"" #: src/flow_control/loop/nested.md:15 msgid "\"Entered the inner loop\"" msgstr "\"Entered the inner loop\"" #: src/flow_control/loop/nested.md:17 msgid "" "// This would break only the inner loop\n" " //break;\n" msgstr "" "// これは内側のループのみを中断します。\n" " //break;\n" #: src/flow_control/loop/nested.md:20 msgid "// This breaks the outer loop\n" msgstr "// こちらは外側を中断します。\n" #: src/flow_control/loop/nested.md:24 msgid "\"This point will never be reached\"" msgstr "\"This point will never be reached\"" #: src/flow_control/loop/nested.md:27 msgid "\"Exited the outer loop\"" msgstr "\"Exited the outer loop\"" #: src/flow_control/loop/return.md:3 msgid "" "One of the uses of a `loop` is to retry an operation until it succeeds. If " "the operation returns a value though, you might need to pass it to the rest " "of the code: put it after the `break`, and it will be returned by the `loop` " "expression." msgstr "" "`loop`の用途のひとつに「成功するまである処理を再試行する」ことがあります。も" "しその処理が値を返すならば、それをコードの他の部分に渡す必要があるでしょう。" "`break`の後に値を置くと、それが`loop`式の値として返されます。" #: src/flow_control/while.md:3 msgid "" "The `while` keyword can be used to run a loop while a condition is true." msgstr "" "`while`キーワードは条件が真である限り実行され続けるループのために使用します。" #: src/flow_control/while.md:5 msgid "" "Let's write the infamous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) " "using a `while` loop." msgstr "" "悪名高い[FizzBuzz問題](https://en.wikipedia.org/wiki/Fizz_buzz)を`while`を用" "いて解いてみましょう。" #: src/flow_control/while.md:9 msgid "// A counter variable\n" msgstr "// カウンタとなる変数\n" #: src/flow_control/while.md:12 msgid "// Loop while `n` is less than 101\n" msgstr "// `n`が101より小さい場合のループ\n" #: src/flow_control/while.md:15 src/flow_control/for.md:17 #: src/flow_control/for.md:37 src/fn.md:34 msgid "\"fizzbuzz\"" msgstr "\"fizzbuzz\"" #: src/flow_control/while.md:17 src/flow_control/for.md:19 #: src/flow_control/for.md:39 src/fn.md:36 msgid "\"fizz\"" msgstr "\"fizz\"" #: src/flow_control/while.md:19 src/flow_control/for.md:21 #: src/flow_control/for.md:41 src/fn.md:38 msgid "\"buzz\"" msgstr "\"buzz\"" #: src/flow_control/while.md:24 msgid "// Increment counter\n" msgstr "// カウンタに1を追加。\n" #: src/flow_control/for.md:1 msgid "for loops" msgstr "forループ" #: src/flow_control/for.md:5 msgid "" "The `for in` construct can be used to iterate through an `Iterator`. One of " "the easiest ways to create an iterator is to use the range notation `a..b`. " "This yields values from `a` (inclusive) to `b` (exclusive) in steps of one." msgstr "" "`for in`構文を用いることで、イテレータのそれぞれの要素に対して処理をすること" "が可能です。イテレータを作る最も単純な方法は`a..b`のような範囲記法です。これ" "は「`a`」から「`b`のひとつ前」までの要素を順に生成します。" #: src/flow_control/for.md:10 msgid "Let's write FizzBuzz using `for` instead of `while`." msgstr "では`while`の代わりに`for`を用いてFizzBuzzを書いてみましょう。" #: src/flow_control/for.md:14 src/flow_control/for.md:34 msgid "// `n` will take the values: 1, 2, ..., 100 in each iteration\n" msgstr "// `n`は1, 2, ...., 100のそれぞれの値を取ります。\n" #: src/flow_control/for.md:29 msgid "" "Alternatively, `a..=b` can be used for a range that is inclusive on both " "ends. The above can be written as:" msgstr "" "上記の代わりに`a..=b`を用いると、両端の値を含む範囲を指定できます。上記の例は" "次のように書けます。" #: src/flow_control/for.md:49 msgid "for and iterators" msgstr "forとイテレータ" #: src/flow_control/for.md:51 msgid "" "The `for in` construct is able to interact with an `Iterator` in several " "ways. As discussed in the section on the [Iterator](../trait/iter.md) trait, " "by default the `for` loop will apply the `into_iter` function to the " "collection. However, this is not the only means of converting collections " "into iterators." msgstr "" "`for in`構文はイテレータとさまざまな方法でやり取りできます。[Iterator](../" "trait/iter.md)トレイトの章で説明したように、デフォルトでは`for`ループにおいて" "`into_iter`関数がコレクションに対して適用されます。しかし、コレクションをイテ" "レータに変換する方法はこれだけではありません。" #: src/flow_control/for.md:56 msgid "" "`into_iter`, `iter` and `iter_mut` all handle the conversion of a collection " "into an iterator in different ways, by providing different views on the data " "within." msgstr "" "`into_iter`、`iter`、`iter_mut`はいずれもコレクションのイテレータへの変換を行" "いますが、データの「見せ方」の違いにより、そのやり方はそれぞれ異なります。" #: src/flow_control/for.md:60 msgid "" "`iter` - This borrows each element of the collection through each iteration. " "Thus leaving the collection untouched and available for reuse after the loop." msgstr "" "`iter` - この関数は、各周回においてコレクションの要素を借用します。よってコレ" "クションには手を加えないので、ループの実行後もコレクションを再利用できます。" #: src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Frank\"" msgstr "\"Frank\"" #: src/flow_control/for.md:65 src/flow_control/for.md:69 #: src/flow_control/for.md:85 src/flow_control/for.md:89 #: src/flow_control/for.md:104 src/flow_control/for.md:108 msgid "\"Ferris\"" msgstr "\"Ferris\"" #: src/flow_control/for.md:69 src/flow_control/for.md:89 #: src/flow_control/for.md:108 msgid "\"There is a rustacean among us!\"" msgstr "\"There is a rustacean among us!\"" #: src/flow_control/for.md:70 msgid "// TODO ^ Try deleting the & and matching just \"Ferris\"\n" msgstr "" #: src/flow_control/for.md:71 src/flow_control/for.md:90 msgid "\"Hello {}\"" msgstr "\"Hello {}\"" #: src/flow_control/for.md:75 src/flow_control/for.md:94 #: src/flow_control/for.md:113 msgid "\"names: {:?}\"" msgstr "\"names: {:?}\"" #: src/flow_control/for.md:79 msgid "" "`into_iter` - This consumes the collection so that on each iteration the " "exact data is provided. Once the collection has been consumed it is no " "longer available for reuse as it has been 'moved' within the loop." msgstr "" "`into_iter` - この関数はコレクションからデータを取り出すので、各周回において" "要素のデータそのものが提供されます。データを取り出してしまうと、データはルー" "プ内に「移動」してしまうので、ループ実行後にコレクションを再利用することはで" "きません。" #: src/flow_control/for.md:99 msgid "" "`iter_mut` - This mutably borrows each element of the collection, allowing " "for the collection to be modified in place." msgstr "" "`iter_mut` - この関数はコレクションの各要素をミュータブル（変更可能）で借用す" "るので、コレクションの要素をその場で変更できます。" #: src/flow_control/for.md:109 msgid "\"Hello\"" msgstr "\"Hello\"" #: src/flow_control/for.md:117 msgid "" "In the above snippets note the type of `match` branch, that is the key " "difference in the types of iteration. The difference in type then of course " "implies differing actions that are able to be performed." msgstr "" "上記に示した3つのコードにおいて、`match`の選択肢の型の違いに注意してくださ" "い。ここがそれぞれの方法の違いを生む鍵になっています。型が異なれば、当然なが" "らそれに対して行える処理も変わります。" #: src/flow_control/for.md:123 msgid "[Iterator](../trait/iter.md)" msgstr "[イテレータ](../trait/iter.md)" #: src/flow_control/match.md:3 msgid "" "Rust provides pattern matching via the `match` keyword, which can be used " "like a C `switch`. The first matching arm is evaluated and all possible " "values must be covered." msgstr "" "Rustは`match`を用いて、C言語における`switch`のようなパターンマッチングを行う" "ことができます。マッチする最初のアームが評価され、取りうるすべての値はカバー" "されていなければなりません。" #: src/flow_control/match.md:10 msgid "// TODO ^ Try different values for `number`\n" msgstr "// TODO ^ `number` の値を変えて試してみましょう。\n" #: src/flow_control/match.md:12 msgid "\"Tell me about {}\"" msgstr "\"Tell me about {}\"" #: src/flow_control/match.md:14 msgid "// Match a single value\n" msgstr "// 単一の値とのマッチをチェック。\n" #: src/flow_control/match.md:15 msgid "\"One!\"" msgstr "\"One!\"" #: src/flow_control/match.md:16 msgid "// Match several values\n" msgstr "// いくつかの値とのマッチをチェック。\n" #: src/flow_control/match.md:17 msgid "\"This is a prime\"" msgstr "\"This is a prime\"" #: src/flow_control/match.md:18 msgid "" "// TODO ^ Try adding 13 to the list of prime values\n" " // Match an inclusive range\n" msgstr "" "// TODO ^ 素数のリストに13を加えてみましょう。\n" " // 特定の範囲の値とのマッチをチェック。\n" #: src/flow_control/match.md:20 msgid "\"A teen\"" msgstr "\"A teen\"" #: src/flow_control/match.md:21 msgid "// Handle the rest of cases\n" msgstr "// その他の場合の処理\n" #: src/flow_control/match.md:22 msgid "\"Ain't special\"" msgstr "\"Ain't special\"" #: src/flow_control/match.md:23 msgid "// TODO ^ Try commenting out this catch-all arm\n" msgstr "" "// TODO ^ この全てをキャッチするアームをコメントアウトしてみましょう。\n" #: src/flow_control/match.md:27 msgid "// Match is an expression too\n" msgstr "// マッチは式でもあります。\n" #: src/flow_control/match.md:29 msgid "// The arms of a match must cover all the possible values\n" msgstr "// マッチは全ての可能な値をカバーしなくてはなりません。\n" #: src/flow_control/match.md:32 msgid "// TODO ^ Try commenting out one of these arms\n" msgstr "// TODO ^ 試しに片方をコメントアウトしてみましょう。\n" #: src/flow_control/match/destructuring.md:3 msgid "A `match` block can destructure items in a variety of ways." msgstr "`match`は値をさまざまなやり方でデストラクトすることができます。" #: src/flow_control/match/destructuring.md:5 msgid "[Destructuring Tuples](destructuring/destructure_tuple.md)" msgstr "[タプルのデストラクト](destructuring/destructure_tuple.md)" #: src/flow_control/match/destructuring.md:6 msgid "[Destructuring Arrays and Slices](destructuring/destructure_slice.md)" msgstr "[配列とスライスのデストラクト](destructuring/destructure_slice.md)" #: src/flow_control/match/destructuring.md:7 msgid "[Destructuring Enums](destructuring/destructure_enum.md)" msgstr "[列挙型のデストラクト](destructuring/destructure_enum.md)" #: src/flow_control/match/destructuring.md:8 msgid "[Destructuring Pointers](destructuring/destructure_pointers.md)" msgstr "[ポインタのデストラクト](destructuring/destructure_pointers.md)" #: src/flow_control/match/destructuring.md:9 msgid "[Destructuring Structures](destructuring/destructure_structures.md)" msgstr "[構造体のデストラクト](destructuring/destructure_structures.md)" #: src/flow_control/match/destructuring/destructure_tuple.md:3 msgid "Tuples can be destructured in a `match` as follows:" msgstr "以下のように、タプルは`match`を用いてデストラクトすることができます。" #: src/flow_control/match/destructuring/destructure_tuple.md:8 msgid "// TODO ^ Try different values for `triple`\n" msgstr "// TODO ^ `triple`に別の値を入れてみましょう。\n" #: src/flow_control/match/destructuring/destructure_tuple.md:10 msgid "\"Tell me about {:?}\"" msgstr "\"Tell me about {:?}\"" #: src/flow_control/match/destructuring/destructure_tuple.md:11 msgid "// Match can be used to destructure a tuple\n" msgstr "// `match`を用いてタプルをデストラクトしてみましょう。\n" #: src/flow_control/match/destructuring/destructure_tuple.md:13 msgid "// Destructure the second and third elements\n" msgstr "// 2つ目と3つ目の要素をデストラクト。\n" #: src/flow_control/match/destructuring/destructure_tuple.md:14 msgid "\"First is `0`, `y` is {:?}, and `z` is {:?}\"" msgstr "\"First is `0`, `y` is {:?}, and `z` is {:?}\"" #: src/flow_control/match/destructuring/destructure_tuple.md:15 msgid "\"First is `1` and the rest doesn't matter\"" msgstr "\"First is `1` and the rest doesn't matter\"" #: src/flow_control/match/destructuring/destructure_tuple.md:16 msgid "\"last is `2` and the rest doesn't matter\"" msgstr "\"last is `2` and the rest doesn't matter\"" #: src/flow_control/match/destructuring/destructure_tuple.md:17 msgid "\"First is `3`, last is `4`, and the rest doesn't matter\"" msgstr "\"First is `3`, last is `4`, and the rest doesn't matter\"" #: src/flow_control/match/destructuring/destructure_tuple.md:18 msgid "// `..` can be used to ignore the rest of the tuple\n" msgstr "// `..`を使うと、タプルの残りの部分を無視できます。\n" #: src/flow_control/match/destructuring/destructure_tuple.md:19 msgid "\"It doesn't matter what they are\"" msgstr "\"It doesn't matter what they are\"" #: src/flow_control/match/destructuring/destructure_tuple.md:20 msgid "// `_` means don't bind the value to a variable\n" msgstr "// ここでは`_`は、値を変数に束縛しないことを意味します。\n" #: src/flow_control/match/destructuring/destructure_tuple.md:27 msgid "[Tuples](../../../primitives/tuples.md)" msgstr "[タプル](../../../primitives/tuples.md)" #: src/flow_control/match/destructuring/destructure_slice.md:3 msgid "Like tuples, arrays and slices can be destructured this way:" msgstr "タプル同様、配列とスライスも以下のようにデストラクトできます。" #: src/flow_control/match/destructuring/destructure_slice.md:7 msgid "// Try changing the values in the array, or make it a slice!\n" msgstr "" "// 配列中の値を変更してみましょう。または、スライスにしてみましょう。\n" #: src/flow_control/match/destructuring/destructure_slice.md:11 msgid "" "// Binds the second and the third elements to the respective variables\n" msgstr "// 2番目と3番目の要素を変数に束縛します。\n" #: src/flow_control/match/destructuring/destructure_slice.md:13 msgid "\"array[0] = 0, array[1] = {}, array[2] = {}\"" msgstr "\"array[0] = 0, array[1] = {}, array[2] = {}\"" #: src/flow_control/match/destructuring/destructure_slice.md:15 msgid "// Single values can be ignored with _\n" msgstr "// _で値を無視できます。\n" #: src/flow_control/match/destructuring/destructure_slice.md:17 msgid "\"array[0] = 1, array[2] = {} and array[1] was ignored\"" msgstr "\"array[0] = 1, array[2] = {} and array[1] was ignored\"" #: src/flow_control/match/destructuring/destructure_slice.md:21 msgid "// You can also bind some and ignore the rest\n" msgstr "// いくつかの値を束縛して残りを無視できます。\n" #: src/flow_control/match/destructuring/destructure_slice.md:23 msgid "\"array[0] = -1, array[1] = {} and all the other ones were ignored\"" msgstr "\"array[0] = -1, array[1] = {} and all the other ones were ignored\"" #: src/flow_control/match/destructuring/destructure_slice.md:26 msgid "" "// The code below would not compile\n" " // [-1, second] => ...\n" msgstr "" "// 以下のコードはコンパイルできません。\n" " // [-1, second] => ...\n" #: src/flow_control/match/destructuring/destructure_slice.md:29 msgid "" "// Or store them in another array/slice (the type depends on\n" " // that of the value that is being matched against)\n" msgstr "" "// 別の配列やスライスに値を持たせることもできます。\n" " // (配列かスライスかは、マッチする値の型により異なります)\n" #: src/flow_control/match/destructuring/destructure_slice.md:32 msgid "\"array[0] = 3, array[1] = {} and the other elements were {:?}\"" msgstr "\"array[0] = 3, array[1] = {} and the other elements were {:?}\"" #: src/flow_control/match/destructuring/destructure_slice.md:36 msgid "" "// Combining these patterns, we can, for example, bind the first and\n" " // last values, and store the rest of them in a single array\n" msgstr "" "// 例えば、これらのパターンを組み合わせて、\n" " // 最初と最後の値を束縛し、残りの値を配列に持たせることもできます。\n" #: src/flow_control/match/destructuring/destructure_slice.md:39 msgid "\"array[0] = {}, middle = {:?}, array[2] = {}\"" msgstr "\"array[0] = {}, middle = {:?}, array[2] = {}\"" #: src/flow_control/match/destructuring/destructure_slice.md:48 msgid "" "[Arrays and Slices](../../../primitives/array.md) and [Binding](../binding." "md) for `@` sigil" msgstr "" "[配列とスライス](../../../primitives/array.md), @マークについては[束縛](../" "binding.md)" #: src/flow_control/match/destructuring/destructure_enum.md:3 msgid "An `enum` is destructured similarly:" msgstr "列挙型も似たやり方でデストラクトすることができます。" #: src/flow_control/match/destructuring/destructure_enum.md:6 msgid "" "// `allow` required to silence warnings because only\n" "// one variant is used.\n" msgstr "" "// `allow`は値を一つだけ使用したことによる警告を抑えるために存在します。\n" #: src/flow_control/match/destructuring/destructure_enum.md:10 msgid "// These 3 are specified solely by their name.\n" msgstr "// これら3つの値は名前のみで扱うことができます。\n" #: src/flow_control/match/destructuring/destructure_enum.md:14 msgid "// These likewise tie `u32` tuples to different names: color models.\n" msgstr "" "// 以下の値は名前と`u32`のタプルをペアにしています。\n" " // カラーモデルと呼ばれます。\n" #: src/flow_control/match/destructuring/destructure_enum.md:24 msgid "// TODO ^ Try different variants for `color`\n" msgstr "// TODO ^ `color`に別の値を入れてみましょう。\n" #: src/flow_control/match/destructuring/destructure_enum.md:26 msgid "\"What color is it?\"" msgstr "\"What color is it?\"" #: src/flow_control/match/destructuring/destructure_enum.md:27 msgid "// An `enum` can be destructured using a `match`.\n" msgstr "// `enum`は`match`を利用してデストラクトすることができます。\n" #: src/flow_control/match/destructuring/destructure_enum.md:29 msgid "\"The color is Red!\"" msgstr "\"The color is Red!\"" #: src/flow_control/match/destructuring/destructure_enum.md:30 msgid "\"The color is Blue!\"" msgstr "\"The color is Blue!\"" #: src/flow_control/match/destructuring/destructure_enum.md:31 msgid "\"The color is Green!\"" msgstr "\"The color is Green!\"" #: src/flow_control/match/destructuring/destructure_enum.md:33 msgid "\"Red: {}, green: {}, and blue: {}!\"" msgstr "\"Red: {}, green: {}, and blue: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:35 msgid "\"Hue: {}, saturation: {}, value: {}!\"" msgstr "\"Hue: {}, saturation: {}, value: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:37 msgid "\"Hue: {}, saturation: {}, lightness: {}!\"" msgstr "\"Hue: {}, saturation: {}, lightness: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:39 msgid "\"Cyan: {}, magenta: {}, yellow: {}!\"" msgstr "\"Cyan: {}, magenta: {}, yellow: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:41 msgid "\"Cyan: {}, magenta: {}, yellow: {}, key (black): {}!\"" msgstr "\"Cyan: {}, magenta: {}, yellow: {}, key (black): {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:43 msgid "// Don't need another arm because all variants have been examined\n" msgstr "// 全ての値を列挙したのでその他の場合の処理は必要ありません。\n" #: src/flow_control/match/destructuring/destructure_enum.md:50 msgid "" "[`#[allow(...)]`](../../../attribute/unused.md), [color models](https://en." "wikipedia.org/wiki/Color_model) and [`enum`](../../../custom_types/enum.md)" msgstr "" "[`#[allow(...)]`](../../../attribute/unused.md), [カラーモデル](https://en." "wikipedia.org/wiki/Color_model), [列挙型](../../../custom_types/enum.md)" #: src/flow_control/match/destructuring/destructure_pointers.md:3 msgid "" "For pointers, a distinction needs to be made between destructuring and " "dereferencing as they are different concepts which are used differently from " "languages like C/C++." msgstr "" "Rustのポインタは、C/C++のポインタとは異なる概念なので、デストラクトとデリファ" "レンスを同じようなやり方で扱うことはできません。" #: src/flow_control/match/destructuring/destructure_pointers.md:7 msgid "Dereferencing uses `*`" msgstr "デリファレンスには`*`を用います。" #: src/flow_control/match/destructuring/destructure_pointers.md:8 msgid "Destructuring uses `&`, `ref`, and `ref mut`" msgstr "デストラクトには`&`, `ref`, `ref mut`を用います。" #: src/flow_control/match/destructuring/destructure_pointers.md:12 msgid "" "// Assign a reference of type `i32`. The `&` signifies there\n" " // is a reference being assigned.\n" msgstr "" "// `i32`型への参照を代入します。\n" " // `&`によって参照であることを明示しています。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:17 msgid "" "// If `reference` is pattern matched against `&val`, it results\n" " // in a comparison like:\n" " // `&i32`\n" " // `&val`\n" " // ^ We see that if the matching `&`s are dropped, then the `i32`\n" " // should be assigned to `val`.\n" msgstr "" "// 上で定義した`reference`という変数が`&val`とのパターンマッチ\n" " // に用いられた場合、以下の2つの値が比較されていることになります。\n" " // `&i32`\n" " // `&val`\n" " // ^ よって`&`を落とせば、`i32`が`val`に代入されることがわかりま" "す。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:23 msgid "\"Got a value via destructuring: {:?}\"" msgstr "\"Got a value via destructuring: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:26 msgid "// To avoid the `&`, you dereference before matching.\n" msgstr "// `&`を使用したくない場合は、マッチングの前にデリファレンスします。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:28 msgid "\"Got a value via dereferencing: {:?}\"" msgstr "\"Got a value via dereferencing: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:31 msgid "" "// What if you don't start with a reference? `reference` was a `&`\n" " // because the right side was already a reference. This is not\n" " // a reference because the right side is not one.\n" msgstr "" "// いきなり参照を変数に代入するのではない場合はどうでしょう。\n" " // 先ほどは右辺値が`&`で始まっていたので参照でしたが、\n" " // これは違います。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:36 msgid "" "// Rust provides `ref` for exactly this purpose. It modifies the\n" " // assignment so that a reference is created for the element; this\n" " // reference is assigned.\n" msgstr "" "// このような場合、Rustでは変数束縛時に`ref`を宣言します。\n" " // 要素の参照が作られて、それが束縛対象になります。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:41 msgid "" "// Accordingly, by defining 2 values without references, references\n" " // can be retrieved via `ref` and `ref mut`.\n" msgstr "" "// 同様にミュータブルな値の場合`ref mut`を使用することで参照を\n" " // 取得できます。イミュータブルの場合と合わせてみていきましょう。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:46 msgid "// Use `ref` keyword to create a reference.\n" msgstr "// `ref`を使用して参照を作成。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:48 msgid "\"Got a reference to a value: {:?}\"" msgstr "\"Got a reference to a value: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:51 msgid "// Use `ref mut` similarly.\n" msgstr "// 同様に`ref mut`を使用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:54 msgid "" "// Got a reference. Gotta dereference it before we can\n" " // add anything to it.\n" msgstr "// 参照を取得、値を変更するためにはデリファレンスします。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:57 msgid "\"We added 10. `mut_value`: {:?}\"" msgstr "\"We added 10. `mut_value`: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:65 msgid "[The ref pattern](../../../scope/borrow/ref.md)" msgstr "[ref パターン](../../../scope/borrow/ref.md)" #: src/flow_control/match/destructuring/destructure_structures.md:3 msgid "Similarly, a `struct` can be destructured as shown:" msgstr "以下のようにして、構造体も同様にデストラクトすることができます。" #: src/flow_control/match/destructuring/destructure_structures.md:12 msgid "// Try changing the values in the struct to see what happens\n" msgstr "// 構造体の中の値を変えて、何が起きるか見てみましょう。\n" #: src/flow_control/match/destructuring/destructure_structures.md:16 msgid "\"First of x is 1, b = {}, y = {} \"" msgstr "\"First of x is 1, b = {}, y = {} \"" #: src/flow_control/match/destructuring/destructure_structures.md:18 msgid "" "// you can destructure structs and rename the variables,\n" " // the order is not important\n" msgstr "" "// 構造体をデストラクトして変数をリネーム。\n" " // 順番は重要ではありません。\n" #: src/flow_control/match/destructuring/destructure_structures.md:20 msgid "\"y is 2, i = {:?}\"" msgstr "\"y is 2, i = {:?}\"" #: src/flow_control/match/destructuring/destructure_structures.md:22 msgid "// and you can also ignore some variables:\n" msgstr "// 一部の変数を無視することもできます。\n" #: src/flow_control/match/destructuring/destructure_structures.md:23 msgid "\"y = {}, we don't care about x\"" msgstr "\"y = {}, we don't care about x\"" #: src/flow_control/match/destructuring/destructure_structures.md:24 msgid "" "// this will give an error: pattern does not mention field `x`\n" " //Foo { y } => println!(\"y = {}\", y),\n" msgstr "" "// `x`に言及していないため、以下はエラーになります。\n" " //Foo { y } => println!(\"y = {}\", y),\n" #: src/flow_control/match/destructuring/destructure_structures.md:30 msgid "// You do not need a match block to destructure structs:\n" msgstr "// matchを使わずとも構造体はデストラクトできます。\n" #: src/flow_control/match/destructuring/destructure_structures.md:32 msgid "\"Outside: x0 = {x0:?}, y0 = {y0}\"" msgstr "\"Outside: x0 = {x0:?}, y0 = {y0}\"" #: src/flow_control/match/destructuring/destructure_structures.md:34 msgid "// Destructuring works with nested structs as well:\n" msgstr "// ネストした構造体もデストラクトできます。\n" #: src/flow_control/match/destructuring/destructure_structures.md:41 msgid "\"Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}\"" msgstr "\"Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}\"" #: src/flow_control/match/destructuring/destructure_structures.md:47 msgid "[Structs](../../../custom_types/structs.md)" msgstr "[構造体](../../../custom_types/structs.md)" #: src/flow_control/match/guard.md:3 msgid "A `match` _guard_ can be added to filter the arm." msgstr "" "`match`内の条件文をフィルタリングするために、 *ガード* を使用することができま" "す。" #: src/flow_control/match/guard.md:14 msgid "// ^ TODO try different values for `temperature`\n" msgstr "// ^ TODO `temperature`の値を変更してみましょう。\n" #: src/flow_control/match/guard.md:17 msgid "\"{}C is above 30 Celsius\"" msgstr "\"{}C is above 30 Celsius\"" #: src/flow_control/match/guard.md:18 msgid "// The `if condition` part ^ is a guard\n" msgstr "// ^ `if`とそれに続く条件式がガードです。\n" #: src/flow_control/match/guard.md:19 msgid "\"{}C is equal to or below 30 Celsius\"" msgstr "\"{}C is equal to or below 30 Celsius\"" #: src/flow_control/match/guard.md:21 msgid "\"{}F is above 86 Fahrenheit\"" msgstr "\"{}F is above 86 Fahrenheit\"" #: src/flow_control/match/guard.md:22 msgid "\"{}F is equal to or below 86 Fahrenheit\"" msgstr "\"{}F is equal to or below 86 Fahrenheit\"" #: src/flow_control/match/guard.md:27 msgid "" "Note that the compiler won't take guard conditions into account when " "checking if all patterns are covered by the match expression." msgstr "" "パターンが全てカバーされているかどうかを判断する際に、ガード条件は考慮されな" "いことに注意してください。" #: src/flow_control/match/guard.md:35 msgid "\"Zero\"" msgstr "\"Zero\"" #: src/flow_control/match/guard.md:36 msgid "\"Greater than zero\"" msgstr "\"Greater than zero\"" #: src/flow_control/match/guard.md:37 msgid "" "// _ => unreachable!(\"Should never happen.\"),\n" " // TODO ^ uncomment to fix compilation\n" msgstr "" "// _ => unreachable!(\"Should never happen.\"),\n" " // TODO ^ アンコメントしてコンパイルエラーを直してみましょう。\n" #: src/flow_control/match/guard.md:45 msgid "" "[Tuples](../../primitives/tuples.md) [Enums](../../custom_types/enum.md)" msgstr "" "[タプル](../../primitives/tuples.md) [列挙型](../../custom_types/enum.md)" #: src/flow_control/match/binding.md:3 msgid "" "Indirectly accessing a variable makes it impossible to branch and use that " "variable without re-binding. `match` provides the `@` sigil for binding " "values to names:" msgstr "" "いくつかの変数をまとめてマッチ対象とした場合、そのうちの一つを分岐先で使用す" "ることはそのままでは不可能です。`match`内では`@`マークを使用して変数を束縛す" "ることができます。" #: src/flow_control/match/binding.md:8 msgid "// A function `age` which returns a `u32`.\n" msgstr "// `age`関数は`u32`の値を返します。\n" #: src/flow_control/match/binding.md:14 msgid "\"Tell me what type of person you are\"" msgstr "\"Tell me what type of person you are\"" #: src/flow_control/match/binding.md:17 msgid "\"I haven't celebrated my first birthday yet\"" msgstr "\"I haven't celebrated my first birthday yet\"" #: src/flow_control/match/binding.md:18 msgid "" "// Could `match` 1 ..= 12 directly but then what age\n" " // would the child be? Instead, bind to `n` for the\n" " // sequence of 1 ..= 12. Now the age can be reported.\n" msgstr "" "// `1 ..= 12`の値を一挙に`match`させることができます。\n" " // しかしその場合、子供は何歳でしょうか？\n" " // マッチした値を`n`に束縛することで値を使用できます。\n" #: src/flow_control/match/binding.md:21 msgid "\"I'm a child of age {:?}\"" msgstr "\"I'm a child of age {:?}\"" #: src/flow_control/match/binding.md:22 msgid "\"I'm a teen of age {:?}\"" msgstr "\"I'm a teen of age {:?}\"" #: src/flow_control/match/binding.md:23 msgid "// Nothing bound. Return the result.\n" msgstr "// マッチしなかった場合の処理\n" #: src/flow_control/match/binding.md:24 msgid "\"I'm an old person of age {:?}\"" msgstr "\"I'm an old person of age {:?}\"" #: src/flow_control/match/binding.md:29 msgid "" "You can also use binding to \"destructure\" `enum` variants, such as " "`Option`:" msgstr "" "`Option`のような、列挙型の値をデストラクトするためにも、束縛を利用できます。" #: src/flow_control/match/binding.md:38 msgid "" "// Got `Some` variant, match if its value, bound to `n`,\n" " // is equal to 42.\n" msgstr "// `n`に束縛された`Some`の値が42に等しいときにマッチ。\n" #: src/flow_control/match/binding.md:40 msgid "\"The Answer: {}!\"" msgstr "\"The Answer: {}!\"" #: src/flow_control/match/binding.md:41 msgid "// Match any other number.\n" msgstr "// それ以外の数値にマッチ。\n" #: src/flow_control/match/binding.md:42 msgid "\"Not interesting... {}\"" msgstr "\"Not interesting... {}\"" #: src/flow_control/match/binding.md:43 msgid "// Match anything else (`None` variant).\n" msgstr "// それ以外にマッチ（`None`の値）。\n" #: src/flow_control/match/binding.md:50 msgid "" "[`functions`](../../fn.md), [`enums`](../../custom_types/enum.md) and " "[`Option`](../../std/option.md)" msgstr "" "[関数](../../fn.md), [列挙型](../../custom_types/enum.md), [`Option`](../../" "std/option.md)" #: src/flow_control/if_let.md:3 msgid "" "For some use cases, when matching enums, `match` is awkward. For example:" msgstr "" "列挙型をマッチさせるとき、場合によっては`match`を使用すると不自然な書き方に" "なってしまう場合があります。例えば" #: src/flow_control/if_let.md:6 src/flow_control/while_let.md:7 #: src/flow_control/while_let.md:35 msgid "// Make `optional` of type `Option`\n" msgstr "// `optional`という変数の型を`Option`に指定。\n" #: src/flow_control/if_let.md:11 msgid "\"This is a really long string and `{:?}`\"" msgstr "\"This is a really long string and `{:?}`\"" #: src/flow_control/if_let.md:12 msgid "" "// ^ Needed 2 indentations just so we could destructure\n" " // `i` from the option.\n" msgstr "" "// ^ `i`をOption型からデストラクトするためだけに\n" " // インデントが一つ増えてしまっている。\n" #: src/flow_control/if_let.md:16 msgid "" "// ^ Required because `match` is exhaustive. Doesn't it seem\n" " // like wasted space?\n" msgstr "" "// ^ `match`は全てのパターンに対して網羅的でなくてはならないので必要。\n" " // 冗長に見えませんか？\n" #: src/flow_control/if_let.md:22 msgid "" "`if let` is cleaner for this use case and in addition allows various failure " "options to be specified:" msgstr "" "この場合は`if let`を用いたほうが美しく、失敗時の処理も柔軟に行うことができま" "す。" #: src/flow_control/if_let.md:27 msgid "// All have type `Option`\n" msgstr "// 全て`Option`型\n" #: src/flow_control/if_let.md:32 msgid "" "// The `if let` construct reads: \"if `let` destructures `number` into\n" " // `Some(i)`, evaluate the block (`{}`).\n" msgstr "" "// `if let`文は以下と同じ意味。\n" " // もしletがnumberをデストラクトした結果が`Some(i)`になるならば\n" " // ブロック内（`{}`）を実行します。\n" #: src/flow_control/if_let.md:35 src/flow_control/if_let.md:40 #: src/flow_control/if_let.md:50 msgid "\"Matched {:?}!\"" msgstr "\"Matched {:?}!\"" #: src/flow_control/if_let.md:38 msgid "// If you need to specify a failure, use an else:\n" msgstr "" "// デストラクトした結果が`Some()`にならない場合の処理を明示したい場合、\n" " // `else`を使用します。\n" #: src/flow_control/if_let.md:42 msgid "// Destructure failed. Change to the failure case.\n" msgstr "// デストラクト失敗の場合。このブロック内を実行。\n" #: src/flow_control/if_let.md:43 src/flow_control/if_let.md:54 msgid "\"Didn't match a number. Let's go with a letter!\"" msgstr "\"Didn't match a number. Let's go with a letter!\"" #: src/flow_control/if_let.md:46 msgid "// Provide an altered failing condition.\n" msgstr "// デストラクト失敗時の処理を更に分岐させることもできます。\n" #: src/flow_control/if_let.md:51 msgid "" "// Destructure failed. Evaluate an `else if` condition to see if the\n" " // alternate failure branch should be taken:\n" msgstr "// デストラクト失敗。`else if`を評価し、処理をさらに分岐させます。\n" #: src/flow_control/if_let.md:56 msgid "// The condition evaluated false. This branch is the default:\n" msgstr "// 今回は`else if`の評価がfalseなので、このブロック内がデフォルト。\n" #: src/flow_control/if_let.md:57 msgid "\"I don't like letters. Let's go with an emoticon :)!\"" msgstr "\"I don't like letters. Let's go with an emoticon :)!\"" #: src/flow_control/if_let.md:62 msgid "In the same way, `if let` can be used to match any enum value:" msgstr "同様に`if let`は任意の列挙型のマッチに使えます。" #: src/flow_control/if_let.md:65 msgid "// Our example enum\n" msgstr "// 列挙型の例\n" #: src/flow_control/if_let.md:73 msgid "// Create example variables\n" msgstr "// 変数の作成\n" #: src/flow_control/if_let.md:78 src/flow_control/if_let.md:114 msgid "// Variable a matches Foo::Bar\n" msgstr "// Foo::Barにマッチする変数\n" #: src/flow_control/if_let.md:80 src/flow_control/if_let.md:117 msgid "\"a is foobar\"" msgstr "\"a is foobar\"" #: src/flow_control/if_let.md:83 msgid "" "// Variable b does not match Foo::Bar\n" " // So this will print nothing\n" msgstr "// 変数bはFoo::Barにマッチしないので出力されません。\n" #: src/flow_control/if_let.md:86 msgid "\"b is foobar\"" msgstr "\"b is foobar\"" #: src/flow_control/if_let.md:89 msgid "" "// Variable c matches Foo::Qux which has a value\n" " // Similar to Some() in the previous example\n" msgstr "" "// 変数cはFoo::Quxにマッチしつつ値を取り出せます。\n" " // これはSome()と同様です。\n" #: src/flow_control/if_let.md:92 msgid "\"c is {}\"" msgstr "\"c is {}\"" #: src/flow_control/if_let.md:95 msgid "// Binding also works with `if let`\n" msgstr "// 束縛も可能です。\n" #: src/flow_control/if_let.md:97 msgid "\"c is one hundred\"" msgstr "\"c is one hundred\"" #: src/flow_control/if_let.md:102 msgid "" "Another benefit is that `if let` allows us to match non-parameterized enum " "variants. This is true even in cases where the enum doesn't implement or " "derive `PartialEq`. In such cases `if Foo::Bar == a` would fail to compile, " "because instances of the enum cannot be equated, however `if let` will " "continue to work." msgstr "" "もう一つのメリットは`if let`がパラメータを持たない列挙型にも使えることです。" "列挙型が`PartialEq`を実装または導出していなくても問題ありません。その場合、列" "挙型のインスタンスは比較できないので`if Foo::Bar == a`はコンパイルエラーとな" "りますが、`if let`は引き続き使えます。" #: src/flow_control/if_let.md:104 msgid "Would you like a challenge? Fix the following example to use `if let`:" msgstr "試してみましょう。以下の例を`if let`を使って直してみてください。" #: src/flow_control/if_let.md:107 msgid "" "// This enum purposely neither implements nor derives PartialEq.\n" "// That is why comparing Foo::Bar == a fails below.\n" msgstr "" "// この列挙型はPartialEqを実装も導出もしていません。\n" "// そのためFoo::Bar == aはエラーとなります。\n" #: src/flow_control/if_let.md:116 msgid "// ^-- this causes a compile-time error. Use `if let` instead.\n" msgstr "// ^-- ここでコンパイルエラー。`if let`を使ってみましょう。\n" #: src/flow_control/if_let.md:124 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/160)" msgstr "" "[列挙型](../custom_types/enum.md), [`Option`](../std/option.md), [RFC]" "(https://github.com/rust-lang/rfcs/pull/160)" #: src/flow_control/let_else.md:4 msgid "🛈 stable since: rust 1.65" msgstr "🛈 Rust 1.65で安定化。" #: src/flow_control/let_else.md:6 msgid "" "🛈 you can target specific edition by compiling like this `rustc --" "edition=2021 main.rs`" msgstr "" "🛈 エディションを指定するには`rustc --edition=2021 main.rs`のようにします。" #: src/flow_control/let_else.md:10 msgid "" "With `let`\\-`else`, a refutable pattern can match and bind variables in the " "surrounding scope like a normal `let`, or else diverge (e.g. `break`, " "`return`, `panic!`) when the pattern doesn't match." msgstr "" "`let`\\-`else`を使うと反駁できるパターンにマッチさせつつ、通常の`let`のように" "変数束縛することができます。マッチしなかった場合は（`break`、`return`、" "`panic!`のように）処理を分岐させます。" #: src/flow_control/let_else.md:18 src/flow_control/let_else.md:41 #: src/std/str.md:41 msgid "' '" msgstr "' '" #: src/flow_control/let_else.md:20 src/flow_control/let_else.md:44 msgid "\"Can't segment count item pair: '{s}'\"" msgstr "\"Can't segment count item pair: '{s}'\"" #: src/flow_control/let_else.md:23 src/flow_control/let_else.md:49 msgid "\"Can't parse integer: '{count_str}'\"" msgstr "\"Can't parse integer: '{count_str}'\"" #: src/flow_control/let_else.md:29 src/flow_control/let_else.md:54 msgid "\"3 chairs\"" msgstr "\"3 chairs\"" #: src/flow_control/let_else.md:29 src/flow_control/let_else.md:54 msgid "\"chairs\"" msgstr "\"chairs\"" #: src/flow_control/let_else.md:33 msgid "" "The scope of name bindings is the main thing that makes this different from " "`match` or `if let`\\-`else` expressions. You could previously approximate " "these patterns with an unfortunate bit of repetition and an outer `let`:" msgstr "" "束縛した変数名のスコープが`match`や`if let`\\-`else`式との主な違いです。" "`match`や`if let`\\-`else`でも似たようなことができますが、残念ながらコードの" "繰り返しや追加の`let`が必要になってしまいます。" #: src/flow_control/let_else.md:59 msgid "" "[option](../std/option.md), [match](./match.md), [if let](./if_let.md) and " "the [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)." msgstr "" "[Option](../std/option.md), [match](./match.md), [if let](./if_let.md), [let-" "else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)." #: src/flow_control/while_let.md:3 msgid "" "Similar to `if let`, `while let` can make awkward `match` sequences more " "tolerable. Consider the following sequence that increments `i`:" msgstr "" "`if let`と同様に、`while let`も不格好な`match`処理を多少マシにしてくれます。" "例えば、以下の`i`をインクリメントする処理を見てください。" #: src/flow_control/while_let.md:9 msgid "// Repeatedly try this test.\n" msgstr "// 変数の照合を繰り返し行います。\n" #: src/flow_control/while_let.md:13 msgid "// If `optional` destructures, evaluate the block.\n" msgstr "" "// もし`optional`のデストラクトに成功した場合、値に応じて処理を分岐。\n" #: src/flow_control/while_let.md:16 src/flow_control/while_let.md:42 msgid "\"Greater than 9, quit!\"" msgstr "\"Greater than 9, quit!\"" #: src/flow_control/while_let.md:19 src/flow_control/while_let.md:45 msgid "\"`i` is `{:?}`. Try again.\"" msgstr "\"`i` is `{:?}`. Try again.\"" #: src/flow_control/while_let.md:22 msgid "// ^ Requires 3 indentations!\n" msgstr "// ^ 3つものインデントが必要。\n" #: src/flow_control/while_let.md:24 msgid "// Quit the loop when the destructure fails:\n" msgstr "// デストラクトに失敗した場合、ループを脱出。\n" #: src/flow_control/while_let.md:26 msgid "// ^ Why should this be required? There must be a better way!\n" msgstr "// ^ どうしてこんな行を書く必要が？もっと良い方法があるはずです！\n" #: src/flow_control/while_let.md:31 msgid "Using `while let` makes this sequence much nicer:" msgstr "`while let`を使ってすっきり書くことができます。" #: src/flow_control/while_let.md:38 msgid "" "// This reads: \"while `let` destructures `optional` into\n" " // `Some(i)`, evaluate the block (`{}`). Else `break`.\n" msgstr "" "// これは次のように読めます。「`let`が`optional`を`Some(i)`にデストラクト\n" " // している間はブロック内（`{}`）を評価せよ。さもなくば`break`せよ。」\n" #: src/flow_control/while_let.md:48 msgid "" "// ^ Less rightward drift and doesn't require\n" " // explicitly handling the failing case.\n" msgstr "" "// ^ インデントが少なく、デストラクト失敗時の処理を追加する必要がありませ" "ん。\n" #: src/flow_control/while_let.md:51 msgid "" "// ^ `if let` had additional optional `else`/`else if`\n" " // clauses. `while let` does not have these.\n" msgstr "" "// ^ `if let`の場合は`else`/`else if`句が一つ余分にありましたが、\n" " // `while let`では必要ありません。\n" #: src/flow_control/while_let.md:58 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/214)" msgstr "" "[列挙型](../custom_types/enum.md), [`Option`](../std/option.md), [RFC]" "(https://github.com/rust-lang/rfcs/pull/214)" #: src/fn.md:3 msgid "" "Functions are declared using the `fn` keyword. Its arguments are type " "annotated, just like variables, and, if the function returns a value, the " "return type must be specified after an arrow `->`." msgstr "" "関数は`fn`キーワードを用いて定義することができます。引数は変数と同様に型を指" "定する必要があり、もし関数が値を返すならば`->`の後にその型も指定する必要があ" "ります。" #: src/fn.md:7 msgid "" "The final expression in the function will be used as return value. " "Alternatively, the `return` statement can be used to return a value earlier " "from within the function, even from inside loops or `if` statements." msgstr "" "関数内の最後の式が返り値となります。関数の途中で値を返したい場合は`return`文" "を使用します。ループの最中や`if`文の中からも値を返すことができます。" #: src/fn.md:11 msgid "Let's rewrite FizzBuzz using functions!" msgstr "では、今度は関数を使ってFizzBuzz問題を解いてみましょう！" #: src/fn.md:14 msgid "" "// Unlike C/C++, there's no restriction on the order of function " "definitions\n" msgstr "// C/C++とは違い、関数の定義を行う順番に制限はありません。\n" #: src/fn.md:16 msgid "// We can use this function here, and define it somewhere later\n" msgstr "// ここで関数を使用し、後ほど定義してもかまいません。\n" #: src/fn.md:19 msgid "// Function that returns a boolean value\n" msgstr "// ブーリアン型を返す関数\n" #: src/fn.md:22 msgid "// Corner case, early return\n" msgstr "// 例外的な引数を受けた場合、早めに返します。\n" #: src/fn.md:27 msgid "// This is an expression, the `return` keyword is not necessary here\n" msgstr "// これは式であり、`return`キーワードは必要ありません。\n" #: src/fn.md:30 msgid "" "// Functions that \"don't\" return a value, actually return the unit type " "`()`\n" msgstr "// 値を「返さない」関数、実際にはユニット型（`()`）を返しています。\n" #: src/fn.md:43 msgid "" "// When a function returns `()`, the return type can be omitted from the\n" "// signature\n" msgstr "// 関数が`()`を返すとき、返り値の型は省略できます。\n" #: src/fn/methods.md:1 msgid "Associated functions & Methods" msgstr "関連関数とメソッド" #: src/fn/methods.md:3 msgid "" "Some functions are connected to a particular type. These come in two forms: " "associated functions, and methods. Associated functions are functions that " "are defined on a type generally, while methods are associated functions that " "are called on a particular instance of a type." msgstr "" "関数には特定の型に紐づいたものがあります。これには関連関数とメソッドの2つの形" "式があります。メソッドは特定のインスタンスに関連付けて呼ばれる関数であるのに" "対し、関連関数は型全体に対して定義される関数です。" #: src/fn/methods.md:13 msgid "" "// Implementation block, all `Point` associated functions & methods go in " "here\n" msgstr "" "// 実装のためのブロック。`Point`の持つ関連関数とメソッドを全て定義します。\n" #: src/fn/methods.md:16 msgid "" "// This is an \"associated function\" because this function is associated " "with\n" " // a particular type, that is, Point.\n" " //\n" " // Associated functions don't need to be called with an instance.\n" " // These functions are generally used like constructors.\n" msgstr "" "// これは特定の型（すなわち Point）に関連した関数なので関連関数\n" " //\n" " // 関連関数はインスタンスからでなく呼び出すことができます。\n" " // 以下のようにコンストラクタとしてよく使用されます。\n" #: src/fn/methods.md:25 msgid "// Another associated function, taking two arguments:\n" msgstr "// 引数を2つ取る関連関数\n" #: src/fn/methods.md:37 msgid "" "// This is a method\n" " // `&self` is sugar for `self: &Self`, where `Self` is the type of the\n" " // caller object. In this case `Self` = `Rectangle`\n" msgstr "" "// こちらはメソッド。`&self`は`self: &Self`の糖衣構文。\n" " // `Self`は呼び出し元オブジェクトの型。この場合は`Rectangle`。\n" #: src/fn/methods.md:41 msgid "// `self` gives access to the struct fields via the dot operator\n" msgstr "// `self`はドット演算子によって構造体のフィールドを参照できます。\n" #: src/fn/methods.md:45 msgid "" "// `abs` is a `f64` method that returns the absolute value of the\n" " // caller\n" msgstr "// `abs`は`f64`のメソッドで、呼び出し元の値の絶対値を返します。\n" #: src/fn/methods.md:57 msgid "" "// This method requires the caller object to be mutable\n" " // `&mut self` desugars to `self: &mut Self`\n" msgstr "" "// このメソッドは呼び出し元オブジェクトがミュータブルであることを\n" " // 必要とします。`&mut self`は`self: &mut Self`の糖衣構文です。\n" #: src/fn/methods.md:67 msgid "// `Pair` owns resources: two heap allocated integers\n" msgstr "// `Pair`はヒープ上の整数を2つ保持します。\n" #: src/fn/methods.md:72 msgid "" "// This method \"consumes\" the resources of the caller object\n" " // `self` desugars to `self: Self`\n" msgstr "" "// このメソッドは呼び出し元オブジェクトを「消費」します。\n" " // `self`は`self: Self`の糖衣構文です。\n" #: src/fn/methods.md:75 msgid "// Destructure `self`\n" msgstr "// `self`をデストラクト。\n" #: src/fn/methods.md:78 msgid "\"Destroying Pair({}, {})\"" msgstr "\"Destroying Pair({}, {})\"" #: src/fn/methods.md:80 msgid "// `first` and `second` go out of scope and get freed\n" msgstr "// `first`、`second`はスコープから抜け出すと同時に、解放されます。\n" #: src/fn/methods.md:86 msgid "// Associated functions are called using double colons\n" msgstr "// 関連関数はコロンを2つ挟んで呼び出すことができます。\n" #: src/fn/methods.md:91 msgid "" "// Methods are called using the dot operator\n" " // Note that the first argument `&self` is implicitly passed, i.e.\n" " // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`\n" msgstr "" "// メソッドはドット演算子を用いて呼び出されます。\n" " // 最初の引数`&self`は明示せずに受け渡されていることに注目。つまり\n" " // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`\n" #: src/fn/methods.md:94 msgid "\"Rectangle perimeter: {}\"" msgstr "\"Rectangle perimeter: {}\"" #: src/fn/methods.md:95 msgid "\"Rectangle area: {}\"" msgstr "\"Rectangle area: {}\"" #: src/fn/methods.md:102 msgid "" "// Error! `rectangle` is immutable, but this method requires a mutable\n" " // object\n" " //rectangle.translate(1.0, 0.0);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`rectangle`はイミュータブルですがこのメソッドは\n" " // ミュータブルなオブジェクトを必要とします。\n" " //rectangle.translate(1.0, 0.0);\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/fn/methods.md:107 msgid "// Okay! Mutable objects can call mutable methods\n" msgstr "" "// OK！ミュータブルなオブジェクトはミュータブルなメソッドを呼び出せます。\n" #: src/fn/methods.md:114 msgid "" "// Error! Previous `destroy` call \"consumed\" `pair`\n" " //pair.destroy();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！先ほどの`destroy`で`pair`はすでに消費されてしまっています。\n" " //pair.destroy();\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/fn/closures.md:3 msgid "" "Closures are functions that can capture the enclosing environment. For " "example, a closure that captures the `x` variable:" msgstr "" "Rustにおけるクロージャは、その外側の環境を捕捉した関数のことです。例えば、次" "のコードは変数`x`を捕捉したクロージャです。" #: src/fn/closures.md:10 msgid "" "The syntax and capabilities of closures make them very convenient for on the " "fly usage. Calling a closure is exactly like calling a function. However, " "both input and return types _can_ be inferred and input variable names " "_must_ be specified." msgstr "" "クロージャの構文や機能は、その場限りの用途で何かを作るのに便利です。クロー" "ジャの呼び出しは関数の呼び出しと全く同じです。しかし、入力の型と戻り値の型は" "推論させることができますが、入力変数の名前は必ず指定しなくてはなりません。" #: src/fn/closures.md:15 msgid "Other characteristics of closures include:" msgstr "クロージャの他の特徴を以下に示します。" #: src/fn/closures.md:16 msgid "using `||` instead of `()` around input variables." msgstr "入力変数を囲むのに、`()`の代わりに`||`を用います。" #: src/fn/closures.md:17 msgid "" "optional body delimitation (`{}`) for a single line expression (mandatory " "otherwise)." msgstr "" "本体が単一の式の場合は、本体の区切り文字（`{}`）を省略できます。（それ以外の" "場合は必須です）" #: src/fn/closures.md:18 msgid "the ability to capture the outer environment variables." msgstr "外側の環境にある変数を捕捉することができます。" #: src/fn/closures.md:24 msgid "" "// A regular function can't refer to variables in the enclosing environment\n" " //fn function(i: i32) -> i32 { i + outer_var }\n" " // TODO: uncomment the line above and see the compiler error. The " "compiler\n" " // suggests that we define a closure instead.\n" msgstr "" "// 通常の関数は周辺の環境の変数を参照できません。\n" " //fn function(i: i32) -> i32 { i + outer_var }\n" " // TODO: 上の行をアンコメントしてコンパイルエラーを見てみましょう。\n" " // 代わりにクロージャを定義することをコンパイラが提案してくれます。\n" #: src/fn/closures.md:29 msgid "" "// Closures are anonymous, here we are binding them to references.\n" " // Annotation is identical to function annotation but is optional\n" " // as are the `{}` wrapping the body. These nameless functions\n" " // are assigned to appropriately named variables.\n" msgstr "" "// クロージャは匿名なので、参照に束縛して使います。\n" " // 型アノテーションは、通常の関数と同様の方法で行えますが、必須ではありま" "せん。\n" " // `{}`も必須ではありません。\n" " // このように定義した無名関数を適切な名前の変数に代入します。\n" #: src/fn/closures.md:36 msgid "// Call the closures.\n" msgstr "// クロージャを呼び出す。\n" #: src/fn/closures.md:37 msgid "\"closure_annotated: {}\"" msgstr "\"closure_annotated: {}\"" #: src/fn/closures.md:38 msgid "\"closure_inferred: {}\"" msgstr "\"closure_inferred: {}\"" #: src/fn/closures.md:39 msgid "" "// Once closure's type has been inferred, it cannot be inferred again with " "another type.\n" " //println!(\"cannot reuse closure_inferred with another type: {}\", " "closure_inferred(42i64));\n" " // TODO: uncomment the line above and see the compiler error.\n" msgstr "" "// クロージャの型が一度推論されると、別の型にあらためて推論することはできませ" "ん。\n" " //println!(\"cannot reuse closure_inferred with another type: {}\", " "closure_inferred(42i64));\n" " // TODO: 上の行をアンコメントしてコンパイルエラーを見てみましょう。\n" #: src/fn/closures.md:43 msgid "" "// A closure taking no arguments which returns an `i32`.\n" " // The return type is inferred.\n" msgstr "" "// 引数なしで`i32`を返すクロージャ。\n" " // 戻り値の型は推論されます。\n" #: src/fn/closures.md:46 msgid "\"closure returning one: {}\"" msgstr "\"closure returning one: {}\"" #: src/fn/closures/capture.md:3 msgid "" "Closures are inherently flexible and will do what the functionality requires " "to make the closure work without annotation. This allows capturing to " "flexibly adapt to the use case, sometimes moving and sometimes borrowing. " "Closures can capture variables:" msgstr "" "クロージャはとてもフレキシブルに動作するように出来ています。クロージャにおい" "て型アノテーションをする必要が無いのは前述の仕組みのためですが、この仕組みの" "おかげでユースケースに応じて参照を取得したり値そのものを取得したりといった動" "作が可能になります。クロージャは外側の環境にある要素を、以下の形で取得するこ" "とができます。" #: src/fn/closures/capture.md:8 msgid "by reference: `&T`" msgstr "参照：`&T`" #: src/fn/closures/capture.md:9 msgid "by mutable reference: `&mut T`" msgstr "ミュータブルな参照：`&mut T`" #: src/fn/closures/capture.md:10 msgid "by value: `T`" msgstr "値そのもの：`T`" #: src/fn/closures/capture.md:12 msgid "" "They preferentially capture variables by reference and only go lower when " "required." msgstr "" "クロージャは出来る限り参照を取得しようとし、その他2つは必要なときのみ取得しま" "す。" #: src/fn/closures/capture.md:19 msgid "\"green\"" msgstr "\"green\"" #: src/fn/closures/capture.md:21 msgid "" "// A closure to print `color` which immediately borrows (`&`) `color` and\n" " // stores the borrow and closure in the `print` variable. It will " "remain\n" " // borrowed until `print` is used the last time. \n" " //\n" " // `println!` only requires arguments by immutable reference so it " "doesn't\n" " // impose anything more restrictive.\n" msgstr "" "// `color`を出力するためのクロージャ。\n" " // これは`color`を借用（`&`）し、その借用とクロージャを`print`\n" " // という名の変数に保持します。\n" " // 借用は`print`がスコープから出るまで続きます。\n" " //\n" " // `println!`は参照を与えれば機能するので、\n" " // これ以上なにかする必要はありません。\n" #: src/fn/closures/capture.md:27 msgid "\"`color`: {}\"" msgstr "\"`color`: {}\"" #: src/fn/closures/capture.md:29 msgid "// Call the closure using the borrow.\n" msgstr "// 借用を行ったクロージャを呼び出します。\n" #: src/fn/closures/capture.md:32 msgid "" "// `color` can be borrowed immutably again, because the closure only holds\n" " // an immutable reference to `color`. \n" msgstr "" "// `color`を再びイミュータブルで借用することができます。\n" " // これはクロージャが`color`に対するイミュータブルな\n" " // 参照しか保持しないためです。\n" #: src/fn/closures/capture.md:37 msgid "// A move or reborrow is allowed after the final use of `print`\n" msgstr "// 最後に`print`を使用した後は移動や再借用が許可されます。\n" #: src/fn/closures/capture.md:42 msgid "" "// A closure to increment `count` could take either `&mut count` or `count`\n" " // but `&mut count` is less restrictive so it takes that. Immediately\n" " // borrows `count`.\n" " //\n" " // A `mut` is required on `inc` because a `&mut` is stored inside. " "Thus,\n" " // calling the closure mutates `count` which requires a `mut`.\n" msgstr "" "// `count`をインクリメントするためのクロージャ。`count`と`&mut count`\n" " // の両方を取ることができますが、後者のほうが制限が少ないため、\n" " // （訳注: `count`だと`&mut count`と違い、一度しか呼ぶことができな" "い。）\n" " // そちらを取ります。直後に`count`を借用します。\n" " //\n" " // `inc`には`mut`をつける必要があります。なぜならミュータブルな型が\n" " // 中で使用されているからです。ミュータブルなクロージャは呼ぶたびに\n" " // 内部変数を変更します。\n" #: src/fn/closures/capture.md:50 msgid "\"`count`: {}\"" msgstr "\"`count`: {}\"" #: src/fn/closures/capture.md:53 msgid "// Call the closure using a mutable borrow.\n" msgstr "// ミュータブルな借用を使ってクロージャを実行。\n" #: src/fn/closures/capture.md:56 msgid "" "// The closure still mutably borrows `count` because it is called later.\n" " // An attempt to reborrow will lead to an error.\n" " // let _reborrow = &count; \n" " // ^ TODO: try uncommenting this line.\n" msgstr "" "// クロージャは後で呼ばれるため、まだ `count` をミュータブルで借用していま" "す。\n" " // 再借用しようとするとエラーになります。\n" " // let _reborrow = &count; \n" " // ^ TODO: この行のコメントアウトを解除しましょう。\n" #: src/fn/closures/capture.md:62 msgid "" "// The closure no longer needs to borrow `&mut count`. Therefore, it is\n" " // possible to reborrow without an error\n" msgstr "" "// クロージャはもう`&mut count`を借用する必要がありません。\n" " // なので、エラーを起こさず再借用することができます。\n" #: src/fn/closures/capture.md:67 msgid "// A non-copy type.\n" msgstr "// コピー不可能な型\n" #: src/fn/closures/capture.md:70 msgid "" "// `mem::drop` requires `T` so this must take by value. A copy type\n" " // would copy into the closure leaving the original untouched.\n" " // A non-copy must move and so `movable` immediately moves into\n" " // the closure.\n" msgstr "" "// `mem::drop`は`T`（ジェネリック型）を取る必要があるため、このクロージャは\n" " // 参照ではなく値を取ります。その場合、もしもコピー可能な値ならば、\n" " // 元の値はそのままでコピーのみを取ります。\n" " // 不可能ならば値そのものを移動させます。\n" #: src/fn/closures/capture.md:75 msgid "\"`movable`: {:?}\"" msgstr "\"`movable`: {:?}\"" #: src/fn/closures/capture.md:79 msgid "// `consume` consumes the variable so this can only be called once.\n" msgstr "" "// `consume`は変数を消費（開放）するため、一度しか呼び出すことができませ" "ん。\n" #: src/fn/closures/capture.md:81 msgid "" "// consume();\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" "// consume();\n" " // ^ TODO: この行のコメントアウトを解除しましょう。\n" #: src/fn/closures/capture.md:86 msgid "" "Using `move` before vertical pipes forces closure to take ownership of " "captured variables:" msgstr "" "バーティカルパイプ（訳注：縦線記号`||`）の前に`move`を使用することで、キャプ" "チャする変数の所有権を取ることをクロージャに強制します。" #: src/fn/closures/capture.md:91 msgid "// `Vec` has non-copy semantics.\n" msgstr "// `Vec`はコピーセマンティクスではない。\n" #: src/fn/closures/capture.md:99 msgid "" "// println!(\"There're {} elements in vec\", haystack.len());\n" " // ^ Uncommenting above line will result in compile-time error\n" " // because borrow checker doesn't allow re-using variable after it\n" " // has been moved.\n" msgstr "" "// println!(\"There're {} elements in vec\", haystack.len());\n" " // ^ 上の行のコメントアウトを解除すると、コンパイル時エラーになります。\n" " // これは変数の所有権が移った後の再利用を借用チェッカーが許可しないからで" "す。\n" #: src/fn/closures/capture.md:104 msgid "" "// Removing `move` from closure's signature will cause closure\n" " // to borrow _haystack_ variable immutably, hence _haystack_ is still\n" " // available and uncommenting above line will not cause an error.\n" msgstr "" "// クロージャのシグネチャから`move`を削除すると、クロージャは\n" " // _haystack_ 変数をイミュータブルで借用するようになります。\n" " // そのため _haystack_ はまだ利用可能となり、上の行のコメントアウトを\n" " // 解除してもエラーが発生しなくなります。\n" #: src/fn/closures/capture.md:112 msgid "" "[`Box`](../../std/box.md) and [`std::mem::drop`](https://doc.rust-lang.org/" "std/mem/fn.drop.html)" msgstr "" "[`Box`](../../std/box.md), [`std::mem::drop`](https://doc.rust-lang.org/std/" "mem/fn.drop.html)" #: src/fn/closures/input_parameters.md:3 msgid "" "While Rust chooses how to capture variables on the fly mostly without type " "annotation, this ambiguity is not allowed when writing functions. When " "taking a closure as an input parameter, the closure's complete type must be " "annotated using one of a few `traits`, and they're determined by what the " "closure does with captured value. In order of decreasing restriction, they " "are:" msgstr "" "Rustはたいていの場合、型アノテーションなしでも変数を捕捉する方法を臨機応変に" "選択してくれますが、関数を書く場合にはこの曖昧さは許されません。引数のパラ" "メータとしてクロージャを取る場合、そのクロージャの完全な型はいくつかの" "`traits`の中の1つを使って明示されなければなりません。どれが使われるかは、捕捉" "された値でクロージャが何をするかによって決まります。制限の少ない順に並べる" "と、下記の通りです。" #: src/fn/closures/input_parameters.md:10 msgid "`Fn`: the closure uses the captured value by reference (`&T`)" msgstr "`Fn`：参照（`&T`）によって捕捉するクロージャ" #: src/fn/closures/input_parameters.md:11 msgid "" "`FnMut`: the closure uses the captured value by mutable reference (`&mut T`)" msgstr "`FnMut`：ミュータブルな参照（`&mut T`）によって捕捉するクロージャ" #: src/fn/closures/input_parameters.md:12 msgid "`FnOnce`: the closure uses the captured value by value (`T`)" msgstr "`FnOnce`：値（`T`）によって捕捉するクロージャ" #: src/fn/closures/input_parameters.md:14 msgid "" "On a variable-by-variable basis, the compiler will capture variables in the " "least restrictive manner possible." msgstr "" "変数ごとに、コンパイラは可能な限り制約の少ない方法でその変数を捕捉します。" #: src/fn/closures/input_parameters.md:17 msgid "" "For instance, consider a parameter annotated as `FnOnce`. This specifies " "that the closure _may_ capture by `&T`, `&mut T`, or `T`, but the compiler " "will ultimately choose based on how the captured variables are used in the " "closure." msgstr "" "例えば、`FnOnce`というアノテーションの付けられたパラメータを考えてみましょ" "う。これはそのクロージャが`&T`、`&mut T`もしくは`T`の *どれか* で捕捉すること" "を指定するものですが、コンパイラは捕捉した変数がそのクロージャの中でどのよう" "に使用されるかに基づき、最終的に捕捉する方法を選択することになります。" #: src/fn/closures/input_parameters.md:22 msgid "" "This is because if a move is possible, then any type of borrow should also " "be possible. Note that the reverse is not true. If the parameter is " "annotated as `Fn`, then capturing variables by `&mut T` or `T` are not " "allowed. However, `&T` is allowed." msgstr "" "これは、もし移動が可能であれば、いずれの種類の借用であっても同様に可能だから" "です。その逆は正しくないことに注意してください。パラメータが`Fn`としてアノ" "テーションされている場合、変数を`&mut T`や`T`で捕捉することは許可されません。" "しかし`&T`は許可されます。" #: src/fn/closures/input_parameters.md:27 msgid "" "In the following example, try swapping the usage of `Fn`, `FnMut`, and " "`FnOnce` to see what happens:" msgstr "" "以下の例で、`Fn`、`FnMut`、および`FnOnce`を入れ替えて、何が起こるのかを見てみ" "ましょう。" #: src/fn/closures/input_parameters.md:31 msgid "" "// A function which takes a closure as an argument and calls it.\n" "// denotes that F is a \"Generic type parameter\"\n" msgstr "" "// クロージャを引数として取り、クロージャを呼び出す関数。\n" "// はFが「ジェネリックな型パラメータ」であることを示します。\n" #: src/fn/closures/input_parameters.md:34 msgid "// The closure takes no input and returns nothing.\n" msgstr "// クロージャには引数も返り値もありません。\n" #: src/fn/closures/input_parameters.md:36 msgid "// ^ TODO: Try changing this to `Fn` or `FnMut`.\n" msgstr "// ^ TODO: ここを`Fn`あるいは`FnMut`に変えてみましょう。\n" #: src/fn/closures/input_parameters.md:40 msgid "// A function which takes a closure and returns an `i32`.\n" msgstr "// クロージャを引数に取り、`i32`を返す関数\n" #: src/fn/closures/input_parameters.md:43 msgid "// The closure takes an `i32` and returns an `i32`.\n" msgstr "// このクロージャは引数、返り値ともに`i32`。\n" #: src/fn/closures/input_parameters.md:53 msgid "" "// A non-copy type.\n" " // `to_owned` creates owned data from borrowed one\n" msgstr "// コピーではなくmoveが起きる型\n" #: src/fn/closures/input_parameters.md:55 msgid "\"goodbye\"" msgstr "\"goodbye\"" #: src/fn/closures/input_parameters.md:57 msgid "" "// Capture 2 variables: `greeting` by reference and\n" " // `farewell` by value.\n" msgstr "" "// 変数を2つ捕捉。`greeting`は参照を、\n" " // `farewell`は値をそれぞれ捕捉します。\n" #: src/fn/closures/input_parameters.md:60 msgid "// `greeting` is by reference: requires `Fn`.\n" msgstr "// `greeting`は参照なので、`Fn`が必要です。\n" #: src/fn/closures/input_parameters.md:61 msgid "\"I said {}.\"" msgstr "\"I said {}.\"" #: src/fn/closures/input_parameters.md:63 msgid "" "// Mutation forces `farewell` to be captured by\n" " // mutable reference. Now requires `FnMut`.\n" msgstr "" "// `farewell`の値を変更するので、この時点で`FnMut`\n" " // が必要になります。\n" #: src/fn/closures/input_parameters.md:65 msgid "\"!!!\"" msgstr "\"!!!\"" #: src/fn/closures/input_parameters.md:66 msgid "\"Then I screamed {}.\"" msgstr "\"Then I screamed {}.\"" #: src/fn/closures/input_parameters.md:67 msgid "\"Now I can sleep. zzzzz\"" msgstr "\"Now I can sleep. zzzzz\"" #: src/fn/closures/input_parameters.md:69 msgid "" "// Manually calling drop forces `farewell` to\n" " // be captured by value. Now requires `FnOnce`.\n" msgstr "" "// `mem::drop`を明示的に呼ぶと`farewell`が値で\n" " // 捕捉される必要性が発生します。よって`FnOnce`が必要になります。\n" #: src/fn/closures/input_parameters.md:74 msgid "// Call the function which applies the closure.\n" msgstr "// クロージャを適用する関数を実行。\n" #: src/fn/closures/input_parameters.md:77 msgid "// `double` satisfies `apply_to_3`'s trait bound\n" msgstr "// `double`は`apply_to_3`のトレイト境界を満たす。\n" #: src/fn/closures/input_parameters.md:80 msgid "\"3 doubled: {}\"" msgstr "\"3 doubled: {}\"" #: src/fn/closures/input_parameters.md:86 msgid "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://doc." "rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md), " "[where](../../generics/where.md) and [`FnOnce`](https://doc.rust-lang.org/" "std/ops/trait.FnOnce.html)" msgstr "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://doc." "rust-lang.org/std/ops/trait.FnMut.html), [ジェネリクス](../../generics.md), " "[where](../../generics/where.md), [`FnOnce`](https://doc.rust-lang.org/std/" "ops/trait.FnOnce.html)" #: src/fn/closures/anonymity.md:3 msgid "" "Closures succinctly capture variables from enclosing scopes. Does this have " "any consequences? It surely does. Observe how using a closure as a function " "parameter requires [generics](../../generics.md), which is necessary because " "of how they are defined:" msgstr "" "クロージャが周辺の環境から変数を取得するやり方は非常に明瞭です。何か注意すべ" "き点はあるのでしょうか？もちろんです。関数内でクロージャを使う場合、[ジェネリ" "クス](../../generics.md)を使用する必要があります。詳しく見ていきましょう。" #: src/fn/closures/anonymity.md:9 msgid "// `F` must be generic.\n" msgstr "// `F` はジェネリック型でなくてはなりません。\n" #: src/fn/closures/anonymity.md:16 msgid "" "When a closure is defined, the compiler implicitly creates a new anonymous " "structure to store the captured variables inside, meanwhile implementing the " "functionality via one of the `traits`: `Fn`, `FnMut`, or `FnOnce` for this " "unknown type. This type is assigned to the variable which is stored until " "calling." msgstr "" "クロージャが定義されると、コンパイラは裏側で、無名の構造体を作り、そこにク" "ロージャによって使用される外側の変数を入れます。同時に`Fn`、`FnMut`、`FnOnce`" "という名のトレイトのいずれか一つを介してこの構造体に関数としての機能を実装" "し、実際に呼び出されるまで待ちます。" #: src/fn/closures/anonymity.md:22 msgid "" "Since this new type is of unknown type, any usage in a function will require " "generics. However, an unbounded type parameter `` would still be " "ambiguous and not be allowed. Thus, bounding by one of the `traits`: `Fn`, " "`FnMut`, or `FnOnce` (which it implements) is sufficient to specify its type." msgstr "" "この無名構造体は型が未指定なため、関数を実行する際にはジェネリクスが必要とさ" "れます。とはいえ、``で指定するだけでは、まだ曖昧です。（訳注：`&self`、" "`&mut self`、`self`のいずれをとるのかがわからないため）そのため、`Fn`、" "`FnMut`、`FnOnce`のいずれか一つを実装することで対応しています。" #: src/fn/closures/anonymity.md:28 msgid "" "// `F` must implement `Fn` for a closure which takes no\n" "// inputs and returns nothing - exactly what is required\n" "// for `print`.\n" msgstr "" "// `F`は引数と戻り値を持たないクロージャ`Fn`を実装していなくてはなりませ" "ん。\n" "// これはまさに`print`に必要とされるものです。\n" #: src/fn/closures/anonymity.md:39 msgid "" "// Capture `x` into an anonymous type and implement\n" " // `Fn` for it. Store it in `print`.\n" msgstr "" "// `x`を無名の構造体に入れ、それに対し`Fn`を実装します。\n" " // （訳注: ここでは`Fn`は`fn Fn(&self) -> {println!(\"{}\", &self)}`）\n" " // その構造体を`print`に代入します。\n" #: src/fn/closures/anonymity.md:49 msgid "" "[A thorough analysis](https://huonw.github.io/blog/2015/05/finding-closure-" "in-rust/), [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`]" "(https://doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://" "doc.rust-lang.org/std/ops/trait.FnOnce.html)" msgstr "" "[徹底解説](https://huonw.github.io/blog/2015/05/finding-closure-in-rust/), " "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" #: src/fn/closures/input_functions.md:3 msgid "" "Since closures may be used as arguments, you might wonder if the same can be " "said about functions. And indeed they can! If you declare a function that " "takes a closure as parameter, then any function that satisfies the trait " "bound of that closure can be passed as a parameter." msgstr "" "これまで、クロージャを引数として渡せることを見てきました。すると次の疑問が浮" "かんできます。「クロージャではない普通の関数を引数として渡すことは可能なのだ" "ろうか？」可能です！もしパラメータとしてクロージャを取る関数を定義すれば、そ" "のクロージャのトレイト境界を満たす任意の関数をパラメータとして渡すことができ" "ます。" #: src/fn/closures/input_functions.md:9 msgid "" "// Define a function which takes a generic `F` argument\n" "// bounded by `Fn`, and calls it\n" msgstr "// 関数を引数として取り、即座に実行する関数を定義。\n" #: src/fn/closures/input_functions.md:14 msgid "// Define a wrapper function satisfying the `Fn` bound\n" msgstr "// `Fn`境界を満たすラッパ関数を定義。\n" #: src/fn/closures/input_functions.md:17 msgid "\"I'm a function!\"" msgstr "\"I'm a function!\"" #: src/fn/closures/input_functions.md:21 msgid "// Define a closure satisfying the `Fn` bound\n" msgstr "// `Fn`境界を満たすクロージャを定義。\n" #: src/fn/closures/input_functions.md:22 msgid "\"I'm a closure!\"" msgstr "\"I'm a closure!\"" #: src/fn/closures/input_functions.md:29 msgid "" "As an additional note, the `Fn`, `FnMut`, and `FnOnce` `traits` dictate how " "a closure captures variables from the enclosing scope." msgstr "" "クロージャによる変数の捕捉がどのように行われているかを詳しく見たいときは" "`Fn`、`FnMut`、`FnOnce`を参照してください。" #: src/fn/closures/input_functions.md:34 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" msgstr "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" #: src/fn/closures/output_parameters.md:3 msgid "" "Closures as input parameters are possible, so returning closures as output " "parameters should also be possible. However, anonymous closure types are, by " "definition, unknown, so we have to use `impl Trait` to return them." msgstr "" "クロージャを引数のパラメータとして用いることができるのと同様に、クロージャを" "戻り値として返すことも可能です。しかし無名のクロージャの型はその定義上、不明" "であるため、クロージャを返すためには`impl Trait`を使用する必要があります。" #: src/fn/closures/output_parameters.md:8 msgid "The valid traits for returning a closure are:" msgstr "クロージャを返すために有効なトレイトは下記の通りです。" #: src/fn/closures/output_parameters.md:10 msgid "`Fn`" msgstr "`Fn`" #: src/fn/closures/output_parameters.md:11 msgid "`FnMut`" msgstr "`FnMut`" #: src/fn/closures/output_parameters.md:12 msgid "`FnOnce`" msgstr "`FnOnce`" #: src/fn/closures/output_parameters.md:14 msgid "" "Beyond this, the `move` keyword must be used, which signals that all " "captures occur by value. This is required because any captures by reference " "would be dropped as soon as the function exited, leaving invalid references " "in the closure." msgstr "" "更に、`move`というキーワードを使用し、全ての捕捉が値でおこなわれることを明示" "しなければなりません。これは、関数を抜けると同時に参照による捕捉がドロップさ" "れ、無効な参照がクロージャに残ってしまうのを防ぐためです。" #: src/fn/closures/output_parameters.md:21 msgid "\"Fn\"" msgstr "\"Fn\"" #: src/fn/closures/output_parameters.md:23 #: src/fn/closures/output_parameters.md:29 #: src/fn/closures/output_parameters.md:35 msgid "\"This is a: {}\"" msgstr "\"This is a: {}\"" #: src/fn/closures/output_parameters.md:27 msgid "\"FnMut\"" msgstr "\"FnMut\"" #: src/fn/closures/output_parameters.md:33 msgid "\"FnOnce\"" msgstr "\"FnOnce\"" #: src/fn/closures/output_parameters.md:51 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md) " "and [impl Trait](../../trait/impl_trait.md)." msgstr "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [ジェネリクス](../../generics." "md), [impl Trait](../../trait/impl_trait.md)." #: src/fn/closures/closure_examples.md:3 msgid "" "This section contains a few examples of using closures from the `std` " "library." msgstr "" "この節では`std`ライブラリを用いて、クロージャの利用例を幾つかお見せします。" #: src/fn/closures/closure_examples/iter_any.md:3 msgid "" "`Iterator::any` is a function which when passed an iterator, will return " "`true` if any element satisfies the predicate. Otherwise `false`. Its " "signature:" msgstr "" "`iterator::any`は、イテレータ内に一つでも条件を満たす要素があれば、`true`を返" "し、さもなくば`false`を返すイテレータです。以下がそのシグネチャです" #: src/fn/closures/closure_examples/iter_any.md:9 #: src/fn/closures/closure_examples/iter_find.md:9 msgid "// The type being iterated over.\n" msgstr "// イテレートされる値の型\n" #: src/fn/closures/closure_examples/iter_any.md:12 msgid "" "// `any` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" "// `any`は`&mut self`を取るため、イテレータを呼び出した値を借用し\n" " // 変更しますが、消費することはありません。\n" #: src/fn/closures/closure_examples/iter_any.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `Self::Item` states it takes\n" " // arguments to the closure by value.\n" msgstr "" "// `FnMut`はクロージャによって捕捉される変数が変更される\n" " // 事はあっても消費されることはないということを示します。\n" " // `Self::Item`はクロージャが変数を値として取ることを示します。\n" #: src/fn/closures/closure_examples/iter_any.md:27 msgid "// `iter()` for vecs yields `&i32`. Destructure to `i32`.\n" msgstr "" "// ベクタ型に対する`iter()`は`&i32`を生成するので、`i32`へとデストラクト。\n" #: src/fn/closures/closure_examples/iter_any.md:28 msgid "\"2 in vec1: {}\"" msgstr "\"2 in vec1: {}\"" #: src/fn/closures/closure_examples/iter_any.md:29 msgid "// `into_iter()` for vecs yields `i32`. No destructuring required.\n" msgstr "" "// `into_iter()`の場合は`i32`を生成するので、デストラクトは必要ありません。\n" #: src/fn/closures/closure_examples/iter_any.md:30 msgid "\"2 in vec2: {}\"" msgstr "\"2 in vec2: {}\"" #: src/fn/closures/closure_examples/iter_any.md:32 msgid "" "// `iter()` only borrows `vec1` and its elements, so they can be used again\n" msgstr "" "// `iter()`は`vec1`とその要素を借用するだけなので、再び利用できます。\n" #: src/fn/closures/closure_examples/iter_any.md:33 msgid "\"vec1 len: {}\"" msgstr "\"vec1 len: {}\"" #: src/fn/closures/closure_examples/iter_any.md:34 msgid "\"First element of vec1 is: {}\"" msgstr "\"First element of vec1 is: {}\"" #: src/fn/closures/closure_examples/iter_any.md:35 msgid "" "// `into_iter()` does move `vec2` and its elements, so they cannot be used " "again\n" " // println!(\"First element of vec2 is: {}\", vec2[0]);\n" " // println!(\"vec2 len: {}\", vec2.len());\n" " // TODO: uncomment two lines above and see compiler errors.\n" msgstr "" "// `into_iter()`は`vec2`とその要素をムーブするので、再利用できません。\n" " // println!(\"First element of vec2 is: {}\", vec2[0]);\n" " // println!(\"vec2 len: {}\", vec2.len());\n" " // TODO: 上の2行をアンコメントしてコンパイルエラーを確認しましょう。\n" #: src/fn/closures/closure_examples/iter_any.md:43 msgid "// `iter()` for arrays yields `&i32`.\n" msgstr "// 配列に対する`iter()`は`&i32`を生成します。\n" #: src/fn/closures/closure_examples/iter_any.md:44 msgid "\"2 in array1: {}\"" msgstr "\"2 in array1: {}\"" #: src/fn/closures/closure_examples/iter_any.md:45 msgid "// `into_iter()` for arrays yields `i32`.\n" msgstr "// 配列に`into_iter()`を使うと`&i32`を生成します。\n" #: src/fn/closures/closure_examples/iter_any.md:46 msgid "\"2 in array2: {}\"" msgstr "\"2 in array2: {}\"" #: src/fn/closures/closure_examples/iter_any.md:52 msgid "" "[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.any)" msgstr "" "[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.any)" #: src/fn/closures/closure_examples/iter_find.md:3 msgid "" "`Iterator::find` is a function which iterates over an iterator and searches " "for the first value which satisfies some condition. If none of the values " "satisfy the condition, it returns `None`. Its signature:" msgstr "" "`Iterator::find`はイテレータを辿る関数で、条件を満たす最初の値を探します。も" "し条件を満たす値がなければ`None`を返します。型シグネチャは以下のようになりま" "す。" #: src/fn/closures/closure_examples/iter_find.md:12 msgid "" "// `find` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" "// `find`は`&mut self`を取るため、イテレータを呼び出した値を借用し\n" " // 変更しますが、消費することはありません。\n" #: src/fn/closures/closure_examples/iter_find.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `&Self::Item` states it takes\n" " // arguments to the closure by reference.\n" msgstr "" "// `FnMut`はクロージャによって捕捉される変数が変更される\n" " // 事はあっても消費されることはないということを示します。\n" " // `&Self::Item`はクロージャが変数を参照として取ることを示します。\n" #: src/fn/closures/closure_examples/iter_find.md:27 msgid "// `iter()` for vecs yields `&i32`.\n" msgstr "// ベクタ型に対する`iter`は`&i32`を生成します。\n" #: src/fn/closures/closure_examples/iter_find.md:29 msgid "// `into_iter()` for vecs yields `i32`.\n" msgstr "// `inter_iter()`の場合は`i32`を生成します。\n" #: src/fn/closures/closure_examples/iter_find.md:32 msgid "" "// `iter()` for vecs yields `&i32`, and we want to reference one of its\n" " // items, so we have to destructure `&&i32` to `i32`\n" msgstr "" "// `iter()`は`&i32`を生成し、ここではその参照が必要なので\n" " // `&&i32`を`i32`へとデストラクトします。\n" #: src/fn/closures/closure_examples/iter_find.md:34 msgid "\"Find 2 in vec1: {:?}\"" msgstr "\"Find 2 in vec1: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:35 msgid "" "// `into_iter()` for vecs yields `i32`, and we want to reference one of\n" " // its items, so we have to destructure `&i32` to `i32`\n" msgstr "" "// `into_iter()`は`i32`を生成し、ここではその参照が必要なので\n" " // `&i32`を`i32`へとデストラクトします。\n" #: src/fn/closures/closure_examples/iter_find.md:37 msgid "\"Find 2 in vec2: {:?}\"" msgstr "\"Find 2 in vec2: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:42 msgid "// `iter()` for arrays yields `&&i32`\n" msgstr "// 配列に対する`iter()`も`&i32`を生成します。\n" #: src/fn/closures/closure_examples/iter_find.md:43 msgid "\"Find 2 in array1: {:?}\"" msgstr "\"Find 2 in array1: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:44 msgid "// `into_iter()` for arrays yields `&i32`\n" msgstr "// 配列に`into_iter()`を使うと`&i32`を生成します。\n" #: src/fn/closures/closure_examples/iter_find.md:45 msgid "\"Find 2 in array2: {:?}\"" msgstr "\"Find 2 in array2: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:49 msgid "" "`Iterator::find` gives you a reference to the item. But if you want the " "_index_ of the item, use `Iterator::position`." msgstr "" "`Iterator::find`は要素への参照を返します。要素の _インデックス_ を使用したい" "場合、`Iterator::position`を使用してください。" #: src/fn/closures/closure_examples/iter_find.md:56 msgid "" "// `iter()` for vecs yields `&i32` and `position()` does not take a " "reference, so\n" " // we have to destructure `&i32` to `i32`\n" msgstr "" "// `iter()`は`&i32`を生成しますが`position()`は参照を取らないので\n" " // `&i32`を`i32`へとデストラクトします。\n" #: src/fn/closures/closure_examples/iter_find.md:61 msgid "" "// `into_iter()` for vecs yields `i32` and `position()` does not take a " "reference, so\n" " // we do not have to destructure \n" msgstr "" "// `into_iter()`は`i32`を生成し、`position()`は参照を取らないので\n" " // `デストラクトする必要はありません。\n" #: src/fn/closures/closure_examples/iter_find.md:70 msgid "" "[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.find)" msgstr "" "[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.find)" #: src/fn/closures/closure_examples/iter_find.md:72 msgid "" "[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.find_map)" msgstr "" "[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.find_map)" #: src/fn/closures/closure_examples/iter_find.md:74 msgid "" "[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.position)" msgstr "" "[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.position)" #: src/fn/closures/closure_examples/iter_find.md:76 msgid "" "[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.rposition)" msgstr "" "[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/trait." "Iterator.html#method.rposition)" #: src/fn/hof.md:3 msgid "" "Rust provides Higher Order Functions (HOF). These are functions that take " "one or more functions and/or produce a more useful function. HOFs and lazy " "iterators give Rust its functional flavor." msgstr "" "Rustには高階関数（`Higher Order Functions, HOF`）を扱う機能が備わっています。" #: src/fn/hof.md:13 msgid "\"Find the sum of all the numbers with odd squares under 1000\"" msgstr "\"Find the sum of all the numbers with odd squares under 1000\"" #: src/fn/hof.md:16 msgid "" "// Imperative approach\n" " // Declare accumulator variable\n" msgstr "" "// 宣言型プログラミングによるアプローチ\n" " // 値を蓄積する変数を宣言。\n" #: src/fn/hof.md:19 msgid "// Iterate: 0, 1, 2, ... to infinity\n" msgstr "// 0から無限までイテレートします。\n" #: src/fn/hof.md:21 msgid "// Square the number\n" msgstr "// 値を2乗。\n" #: src/fn/hof.md:25 msgid "// Break loop if exceeded the upper limit\n" msgstr "// 上限に達した場合、ループを終了。\n" #: src/fn/hof.md:28 msgid "// Accumulate value, if it's odd\n" msgstr "// 奇数ならば値を値を足しあわせていきます。\n" #: src/fn/hof.md:32 msgid "\"imperative style: {}\"" msgstr "\"imperative style: {}\"" #: src/fn/hof.md:34 msgid "// Functional approach\n" msgstr "// 関数型プログラミングによるアプローチ\n" #: src/fn/hof.md:36 msgid "// All natural numbers squared\n" msgstr "// 全自然数を2乗し\n" #: src/fn/hof.md:37 msgid "// Below upper limit\n" msgstr "// 上限より小さい値で\n" #: src/fn/hof.md:38 msgid "// That are odd\n" msgstr "// かつ奇数のものを\n" #: src/fn/hof.md:39 msgid "// Sum them\n" msgstr "// 合計します。\n" #: src/fn/hof.md:40 msgid "\"functional style: {}\"" msgstr "\"functional style: {}\"" #: src/fn/hof.md:44 msgid "" "[Option](https://doc.rust-lang.org/core/option/enum.Option.html) and " "[Iterator](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "implement their fair share of HOFs." msgstr "" "[Option](https://doc.rust-lang.org/core/option/enum.Option.html) と [イテレー" "タ](https://doc.rust-lang.org/core/iter/trait.Iterator.html) には高階関数が使" "用されています。" #: src/fn/diverging.md:3 msgid "" "Diverging functions never return. They are marked using `!`, which is an " "empty type." msgstr "" "発散する関数は決してリターンしない関数です。こうした関数は `!` を使って、空の" "型であることが示されます。" #: src/fn/diverging.md:7 src/fn/diverging.md:35 msgid "\"This call never returns.\"" msgstr "\"This call never returns.\"" #: src/fn/diverging.md:11 msgid "" "As opposed to all the other types, this one cannot be instantiated, because " "the set of all possible values this type can have is empty. Note that, it is " "different from the `()` type, which has exactly one possible value." msgstr "" "他の全ての型と異なり、この型はインスタンス化できません。この型が持ちうる全て" "の値の集合は空です。この型は`()`型とは異なることに注意してください。`()`型は" "値をただ1つだけ持つ型です。" #: src/fn/diverging.md:15 msgid "" "For example, this function returns as usual, although there is no " "information in the return value." msgstr "" "例えば、この関数は通常どおりリターンしますが、戻り値には何の情報も含みませ" "ん。" #: src/fn/diverging.md:25 msgid "\"This function returns and you can see this line.\"" msgstr "\"This function returns and you can see this line.\"" #: src/fn/diverging.md:29 msgid "" "As opposed to this function, which will never return the control back to the " "caller." msgstr "一方、この関数は呼び出し元に決してリターンしません。" #: src/fn/diverging.md:36 msgid "\"You will never see this line!\"" msgstr "\"You will never see this line!\"" #: src/fn/diverging.md:40 msgid "" "Although this might seem like an abstract concept, it is in fact very useful " "and often handy. The main advantage of this type is that it can be cast to " "any other one and therefore used at places where an exact type is required, " "for instance in `match` branches. This allows us to write code like this:" msgstr "" "これは抽象的な概念に見えるかもしれませんが、実際のところはとても実用的で、便" "利なことも多いのです。この型の主な利点は、他のどのような型にもキャストできる" "ことです。そのため、例えば`match`の分岐の中のような正確な型が要求される場所で" "も使用できます。" #: src/fn/diverging.md:50 msgid "" "// Notice that the return type of this match expression must be u32\n" " // because of the type of the \"addition\" variable.\n" msgstr "" "// 変数\"addition\"の型がu32であるため、\n" " // このmatch式はu32をリターンしなければならないことに注意。\n" #: src/fn/diverging.md:53 msgid "// The \"i\" variable is of type u32, which is perfectly fine.\n" msgstr "// 変数\"i\"はu32型であるため、全く問題ありません。\n" #: src/fn/diverging.md:55 msgid "" "// On the other hand, the \"continue\" expression does not return\n" " // u32, but it is still fine, because it never returns and " "therefore\n" " // does not violate the type requirements of the match " "expression.\n" msgstr "" "// 一方、\"continue\"式はu32をリターンしませんが、これでも問題ありません。\n" " // 決してリターンしないため、このmatch式が要求する型に違反し" "ないからです。\n" #: src/fn/diverging.md:64 msgid "\"Sum of odd numbers up to 9 (excluding): {}\"" msgstr "\"Sum of odd numbers up to 9 (excluding): {}\"" #: src/fn/diverging.md:68 msgid "" "It is also the return type of functions that loop forever (e.g. `loop {}`) " "like network servers or functions that terminate the process (e.g. `exit()`)." msgstr "" "この型は、ネットワークサーバのような永遠にループする関数（例：`loop {}`）の戻" "り値の型や、プロセスを終了させる関数（例：`exit()`）の戻り値の型としても使用" "されます。" #: src/mod.md:3 msgid "" "Rust provides a powerful module system that can be used to hierarchically " "split code in logical units (modules), and manage visibility (public/" "private) between them." msgstr "" "Rustにはコードを階層的に分割し、お互いの機能を隠蔽・公開するための強力なモ" "ジュールシステムがあります。" #: src/mod.md:7 msgid "" "A module is a collection of items: functions, structs, traits, `impl` " "blocks, and even other modules." msgstr "" "モジュールは関数、構造体、トレイト、`impl`ブロック、さらには他のモジュールな" "どの要素の集合です。" #: src/mod/visibility.md:3 msgid "" "By default, the items in a module have private visibility, but this can be " "overridden with the `pub` modifier. Only the public items of a module can be " "accessed from outside the module scope." msgstr "" "デフォルトでは、モジュール内の要素はプライベートですが、これは`pub`で修飾する" "ことでパブリックな属性にすることができます。パブリックな属性のみがモジュール" "の外のスコープからアクセスできます。" #: src/mod/visibility.md:8 msgid "// A module named `my_mod`\n" msgstr "// `my_mod`という名前のモジュール\n" #: src/mod/visibility.md:10 msgid "// Items in modules default to private visibility.\n" msgstr "// モジュール内の要素はデフォルトでプライベート。\n" #: src/mod/visibility.md:12 msgid "\"called `my_mod::private_function()`\"" msgstr "\"called `my_mod::private_function()`\"" #: src/mod/visibility.md:15 msgid "// Use the `pub` modifier to override default visibility.\n" msgstr "// `pub`を用いてパブリックに変更。\n" #: src/mod/visibility.md:17 msgid "\"called `my_mod::function()`\"" msgstr "\"called `my_mod::function()`\"" #: src/mod/visibility.md:20 msgid "" "// Items can access other items in the same module,\n" " // even when private.\n" msgstr "// モジュール内からならば、プライベートな属性にアクセスできます。\n" #: src/mod/visibility.md:23 msgid "\"called `my_mod::indirect_access()`, that\\n> \"" msgstr "\"called `my_mod::indirect_access()`, that\\n> \"" #: src/mod/visibility.md:27 msgid "// Modules can also be nested\n" msgstr "// モジュールもネストできます。\n" #: src/mod/visibility.md:30 msgid "\"called `my_mod::nested::function()`\"" msgstr "\"called `my_mod::nested::function()`\"" #: src/mod/visibility.md:35 msgid "\"called `my_mod::nested::private_function()`\"" msgstr "\"called `my_mod::nested::private_function()`\"" #: src/mod/visibility.md:38 msgid "" "// Functions declared using `pub(in path)` syntax are only visible\n" " // within the given path. `path` must be a parent or ancestor " "module\n" msgstr "" "// `pub(in path)`形式で宣言された関数は該当のパス内でのみアクセスできます。\n" " // `path`は親や先祖のモジュールでなくてはなりません。\n" #: src/mod/visibility.md:41 msgid "\"called `my_mod::nested::public_function_in_my_mod()`, that\\n> \"" msgstr "\"called `my_mod::nested::public_function_in_my_mod()`, that\\n> \"" #: src/mod/visibility.md:45 msgid "" "// Functions declared using `pub(self)` syntax are only visible within\n" " // the current module, which is the same as leaving them private\n" msgstr "" "// `pub(self)`形式で宣言された関数は現在のモジュール内でのみアクセスできま" "す。\n" " // つまり、プライベートにするのと同じです。\n" #: src/mod/visibility.md:48 msgid "\"called `my_mod::nested::public_function_in_nested()`\"" msgstr "\"called `my_mod::nested::public_function_in_nested()`\"" #: src/mod/visibility.md:51 msgid "" "// Functions declared using `pub(super)` syntax are only visible within\n" " // the parent module\n" msgstr "" "// `pub(super)`形式で宣言された関数は親モジュール内でのみアクセスできます。\n" #: src/mod/visibility.md:54 msgid "\"called `my_mod::nested::public_function_in_super_mod()`\"" msgstr "\"called `my_mod::nested::public_function_in_super_mod()`\"" #: src/mod/visibility.md:59 msgid "\"called `my_mod::call_public_function_in_my_mod()`, that\\n> \"" msgstr "\"called `my_mod::call_public_function_in_my_mod()`, that\\n> \"" #: src/mod/visibility.md:61 msgid "\"> \"" msgstr "\"> \"" #: src/mod/visibility.md:65 msgid "// pub(crate) makes functions visible only within the current crate\n" msgstr "// pub(crate)により関数は現在のクレート内でのみアクセスできます。\n" #: src/mod/visibility.md:67 msgid "\"called `my_mod::public_function_in_crate()`\"" msgstr "\"called `my_mod::public_function_in_crate()`\"" #: src/mod/visibility.md:70 msgid "// Nested modules follow the same rules for visibility\n" msgstr "// ネストしたモジュールも、同様の性質を示します。\n" #: src/mod/visibility.md:74 msgid "\"called `my_mod::private_nested::function()`\"" msgstr "\"called `my_mod::private_nested::function()`\"" #: src/mod/visibility.md:77 msgid "" "// Private parent items will still restrict the visibility of a child item,\n" " // even if it is declared as visible within a bigger scope.\n" msgstr "" "// 親がプライベートな場合、子要素がより大きなスコープでアクセスできるように宣" "言されていても、\n" " // 子要素にアクセス可能な範囲は制限されます。\n" #: src/mod/visibility.md:81 msgid "\"called `my_mod::private_nested::restricted_function()`\"" msgstr "\"called `my_mod::private_nested::restricted_function()`\"" #: src/mod/visibility.md:87 src/mod/use.md:25 src/mod/super.md:8 #: src/mod/split.md:24 msgid "\"called `function()`\"" msgstr "\"called `function()`\"" #: src/mod/visibility.md:91 msgid "" "// Modules allow disambiguation between items that have the same name.\n" msgstr "// モジュールによって、同名の関数を区別することができます。\n" #: src/mod/visibility.md:95 msgid "" "// Public items, including those inside nested modules, can be\n" " // accessed from outside the parent module.\n" msgstr "" "// パブリックな要素ならば、たとえネストしたものでも、\n" " // モジュールの外からアクセスすることができます。\n" #: src/mod/visibility.md:101 msgid "// pub(crate) items can be called from anywhere in the same crate\n" msgstr "" "// pub(crate)の要素は同じクレートのどこからでも呼び出すことができます。\n" #: src/mod/visibility.md:104 msgid "" "// pub(in path) items can only be called from within the module specified\n" " // Error! function `public_function_in_my_mod` is private\n" " //my_mod::nested::public_function_in_my_mod();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// pub(in path)の要素は指定されたモジュールからのみ呼び出すことができます。\n" " // エラー！`public_function_in_my_mod`関数はプライベート。\n" " //my_mod::nested::public_function_in_my_mod();\n" " // TODO ^ 試しにこの行をアンコメントしてみましょう。\n" #: src/mod/visibility.md:109 msgid "" "// Private items of a module cannot be directly accessed, even if\n" " // nested in a public module:\n" msgstr "" "// プライベートな要素は、たとえパブリックなモジュール内に存在していても\n" " // 直接アクセスすることはできません。\n" #: src/mod/visibility.md:112 msgid "" "// Error! `private_function` is private\n" " //my_mod::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`private_function`はプライベート。\n" " //my_mod::private_function();\n" " // TODO ^ 試しにこの行をアンコメントしてみましょう。\n" #: src/mod/visibility.md:116 msgid "" "// Error! `private_function` is private\n" " //my_mod::nested::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`private_function`はプライベート。\n" " //my_mod::nested::private_function();\n" " // TODO ^ 試しにこの行をアンコメントしてみましょう。\n" #: src/mod/visibility.md:120 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`private_nested`はプライベートなモジュール。\n" " //my_mod::private_nested::function();\n" " // TODO ^ 試しにこの行をアンコメントしてみましょう。\n" #: src/mod/visibility.md:124 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::restricted_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`private_nested`はプライベートなモジュール。\n" " //my_mod::private_nested::restricted_function();\n" " // TODO ^ 試しにこの行をアンコメントしてみましょう。\n" #: src/mod/struct_visibility.md:3 msgid "" "Structs have an extra level of visibility with their fields. The visibility " "defaults to private, and can be overridden with the `pub` modifier. This " "visibility only matters when a struct is accessed from outside the module " "where it is defined, and has the goal of hiding information (encapsulation)." msgstr "" "構造体はそれ自身に加え、フィールドごとにもパブリック・プライベートを設定する" "ことができます。デフォルトではプライベートですが、`pub`宣言をすることで、" "フィールドをパブリックにすることができます。これは、構造体がモジュールの外か" "ら参照される時に限り意味のあるもので、情報の隠蔽（カプセル化）を達成するため" "の機能です。" #: src/mod/struct_visibility.md:10 msgid "// A public struct with a public field of generic type `T`\n" msgstr "" "// パブリックなフィールド`T`（ジェネリック型）を持つパブリックな構造体\n" #: src/mod/struct_visibility.md:15 msgid "// A public struct with a private field of generic type `T`\n" msgstr "" "// プライベートなフィールド`T`（ジェネリック型）を持つパブリックな構造体\n" #: src/mod/struct_visibility.md:21 msgid "// A public constructor method\n" msgstr "// パブリックなコンストラクタメソッドを持つ構造体\n" #: src/mod/struct_visibility.md:31 msgid "// Public structs with public fields can be constructed as usual\n" msgstr "" "// パブリックなフィールドを持つパブリックな構造体は、通常通り\n" " // インスタンス化できます。\n" #: src/mod/struct_visibility.md:32 msgid "\"public information\"" msgstr "\"public information\"" #: src/mod/struct_visibility.md:34 msgid "// and their fields can be normally accessed.\n" msgstr "// フィールドにも普通にアクセスできます。\n" #: src/mod/struct_visibility.md:35 msgid "\"The open box contains: {}\"" msgstr "\"The open box contains: {}\"" #: src/mod/struct_visibility.md:37 msgid "" "// Public structs with private fields cannot be constructed using field " "names.\n" " // Error! `ClosedBox` has private fields\n" " //let closed_box = my::ClosedBox { contents: \"classified information" "\" };\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// プライベートなフィールドを持つ構造体は、インスタンス化する際に\n" " // フィールド名を指定することができません。\n" " // エラー！`ClosedBox`にはプライベートなフィールドがあります。\n" " //let closed_box = my::ClosedBox { contents: \"classified information" "\" };\n" " // TODO ^ 試しにここをアンコメントしてみましょう。\n" #: src/mod/struct_visibility.md:42 msgid "" "// However, structs with private fields can be created using\n" " // public constructors\n" msgstr "" "// そのような場合でも、パブリックなコンストラクタを介して作成\n" " // することはできます。\n" #: src/mod/struct_visibility.md:44 msgid "\"classified information\"" msgstr "\"classified information\"" #: src/mod/struct_visibility.md:46 msgid "" "// and the private fields of a public struct cannot be accessed.\n" " // Error! The `contents` field is private\n" " //println!(\"The closed box contains: {}\", _closed_box.contents);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// パブリックな構造体でも、プライベートなフィールドにはアクセスできません。\n" " // エラー！`contents`フィールドはプライベートです。\n" " //println!(\"The closed box contains: {}\", _closed_box.contents);\n" " // TODO ^ ここをアンコメントしてみましょう。\n" #: src/mod/struct_visibility.md:55 msgid "[generics](../generics.md) and [methods](../fn/methods.md)" msgstr "[ジェネリクス](../generics.md), [メソッド](../fn/methods.md)" #: src/mod/use.md:3 msgid "" "The `use` declaration can be used to bind a full path to a new name, for " "easier access. It is often used like this:" msgstr "" "`use`宣言をすることで、要素の絶対パスを新しい名前に束縛することができ、より簡" "潔な記述が可能になります。例えば以下のように使えます。" #: src/mod/use.md:18 msgid "You can use the `as` keyword to bind imports to a different name:" msgstr "" "`as`キーワードを使用することで、インポートを別名に束縛することができます。" #: src/mod/use.md:21 msgid "// Bind the `deeply::nested::function` path to `other_function`.\n" msgstr "// `deeply::nested::function`を`other_function`に束縛\n" #: src/mod/use.md:31 msgid "\"called `deeply::nested::function()`\"" msgstr "\"called `deeply::nested::function()`\"" #: src/mod/use.md:37 msgid "// Easier access to `deeply::nested::function`\n" msgstr "// `deeply::nested::function`へ、より簡潔にアクセス。\n" #: src/mod/use.md:40 msgid "\"Entering block\"" msgstr "\"Entering block\"" #: src/mod/use.md:42 msgid "" "// This is equivalent to `use deeply::nested::function as function`.\n" " // This `function()` will shadow the outer one.\n" msgstr "" "// これは`use deeply::nested::function as function`と同等\n" " // この`function()`は外の`function()`をシャドウイングします。\n" #: src/mod/use.md:46 msgid "" "// `use` bindings have a local scope. In this case, the\n" " // shadowing of `function()` is only in this block.\n" msgstr "" "// `use`束縛は局所的なスコープを持ちます。\n" " // この場合には`function()`のシャドーイングはこのブロック内のみとなり" "ます。\n" #: src/mod/use.md:50 msgid "\"Leaving block\"" msgstr "\"Leaving block\"" #: src/mod/super.md:3 msgid "" "The `super` and `self` keywords can be used in the path to remove ambiguity " "when accessing items and to prevent unnecessary hardcoding of paths." msgstr "" "`super`及び`self`キーワードは、要素にアクセスする際に、曖昧さをなくし、不必要" "なハードコーディングを避けるために使用できます。" #: src/mod/super.md:13 msgid "\"called `cool::function()`\"" msgstr "\"called `cool::function()`\"" #: src/mod/super.md:19 src/mod/split.md:49 msgid "\"called `my::function()`\"" msgstr "\"called `my::function()`\"" #: src/mod/super.md:24 msgid "\"called `my::cool::function()`\"" msgstr "\"called `my::cool::function()`\"" #: src/mod/super.md:29 msgid "// Let's access all the functions named `function` from this scope!\n" msgstr "" "// `function`という名の様々な関数をこのスコープ内から参照してみましょう。\n" #: src/mod/super.md:30 msgid "\"called `my::indirect_call()`, that\\n> \"" msgstr "\"called `my::indirect_call()`, that\\n> \"" #: src/mod/super.md:32 msgid "" "// The `self` keyword refers to the current module scope - in this case " "`my`.\n" " // Calling `self::function()` and calling `function()` directly both " "give\n" " // the same result, because they refer to the same function.\n" msgstr "" "// `self`キーワードは現在のモジュールスコープを示します。\n" " // この場合は`my`です。`self::function()`と`funcition()`は\n" " // 同じ関数であるため、同じ結果になります。\n" #: src/mod/super.md:38 msgid "// We can also use `self` to access another module inside `my`:\n" msgstr "" "// `my`以下の別のモジュールを呼び出す際に\n" " // `self`を用いて明示的に参照できます。\n" #: src/mod/super.md:41 msgid "" "// The `super` keyword refers to the parent scope (outside the `my` " "module).\n" msgstr "// `super`は親スコープ（`my`の外側）を参照します。\n" #: src/mod/super.md:44 msgid "" "// This will bind to the `cool::function` in the *crate* scope.\n" " // In this case the crate scope is the outermost scope.\n" msgstr "" "// 以下は *クレート* スコープ内の`cool::function`を束縛します。\n" " // この場合、クレートスコープは一番外側のスコープです。\n" #: src/mod/split.md:3 msgid "" "Modules can be mapped to a file/directory hierarchy. Let's break down the " "[visibility example](visibility.md) in files:" msgstr "" "モジュールはファイル・ディレクトリの階層構造と対応関係にあります。以下の様な" "ファイルで[可視性の例](visibility.md)を詳しく見ていきましょう。" #: src/mod/split.md:16 msgid "In `split.rs`:" msgstr "`split.rs`は以下のようになります。" #: src/mod/split.md:19 msgid "" "// This declaration will look for a file named `my.rs` and will\n" "// insert its contents inside a module named `my` under this scope\n" msgstr "" "// このように宣言すると、`my.rs`という名のファイルを探し、\n" "// その内容をこのファイル中で`my`という名から使用することができるようにしま" "す。\n" #: src/mod/split.md:39 msgid "In `my.rs`:" msgstr "`my.rs`は以下のようになります。" #: src/mod/split.md:42 msgid "" "// Similarly `mod inaccessible` and `mod nested` will locate the `nested." "rs`\n" "// and `inaccessible.rs` files and insert them here under their respective\n" "// modules\n" msgstr "" "// 同様に`mod inaccessible`、`mod nested`によって、`nested.rs`、" "`inaccessible.rs`\n" "// の内容をこの中で使用することができるようになります。\n" "// 訳注：`pub`をつけないかぎり、この中でしか使用できません。\n" #: src/mod/split.md:53 msgid "\"called `my::private_function()`\"" msgstr "\"called `my::private_function()`\"" #: src/mod/split.md:57 msgid "\"called `my::indirect_access()`, that\\n> \"" msgstr "\"called `my::indirect_access()`, that\\n> \"" #: src/mod/split.md:63 msgid "In `my/nested.rs`:" msgstr "`my/nested.rs`は以下のようになります。" #: src/mod/split.md:67 msgid "\"called `my::nested::function()`\"" msgstr "\"called `my::nested::function()`\"" #: src/mod/split.md:72 msgid "\"called `my::nested::private_function()`\"" msgstr "\"called `my::nested::private_function()`\"" #: src/mod/split.md:76 msgid "In `my/inaccessible.rs`:" msgstr "`my/inaccessible.rs`は以下のようになります。" #: src/mod/split.md:81 msgid "\"called `my::inaccessible::public_function()`\"" msgstr "\"called `my::inaccessible::public_function()`\"" #: src/mod/split.md:85 msgid "Let's check that things still work as before:" msgstr "では、以前と同じように実行できるか確認しましょう。" #: src/crates.md:3 msgid "" "A crate is a compilation unit in Rust. Whenever `rustc some_file.rs` is " "called, `some_file.rs` is treated as the _crate file_. If `some_file.rs` has " "`mod` declarations in it, then the contents of the module files would be " "inserted in places where `mod` declarations in the crate file are found, " "_before_ running the compiler over it. In other words, modules do _not_ get " "compiled individually, only crates get compiled." msgstr "" "クレートはRustにおけるコンパイルの単位です。`rustc some_file.rs`が呼ばれる" "と、`some_file.rs`は必ず *クレートファイル* として扱われます。もし`some_file." "rs`が`mod`宣言を含んでいるのならば、コンパイルの *前に* 、そのモジュールファ" "イルの中身が`mod`の位置に挿入されます。言い換えると、それぞれのモジュールが独" "立にコンパイルされるということはありませんが、それぞれのクレートは互いに独立" "にコンパイルされるということです。" #: src/crates.md:10 msgid "" "A crate can be compiled into a binary or into a library. By default, `rustc` " "will produce a binary from a crate. This behavior can be overridden by " "passing the `--crate-type` flag to `lib`." msgstr "" "クレートはバイナリあるいはライブラリ形式でコンパイルされることが可能です。デ" "フォルトでは`rustc`はクレートからバイナリを作り出しますが、この振る舞いは`--" "crate-type`フラグに`lib`を渡すことでオーバーライドできます。" #: src/crates/lib.md:3 msgid "Let's create a library, and then see how to link it to another crate." msgstr "" "ではライブラリを作成し、それを別のクレートにリンクする方法を見ていきましょ" "う。" #: src/crates/lib.md:5 msgid "In `rary.rs`:" msgstr "`rary.rs`は以下のようになります。" #: src/crates/lib.md:9 src/attribute/crate.md:19 msgid "\"called rary's `public_function()`\"" msgstr "\"called rary's `public_function()`\"" #: src/crates/lib.md:13 src/attribute/crate.md:23 msgid "\"called rary's `private_function()`\"" msgstr "\"called rary's `private_function()`\"" #: src/crates/lib.md:17 src/attribute/crate.md:27 msgid "\"called rary's `indirect_access()`, that\\n> \"" msgstr "\"called rary's `indirect_access()`, that\\n> \"" #: src/crates/lib.md:29 msgid "" "Libraries get prefixed with \"lib\", and by default they get named after " "their crate file, but this default name can be overridden by passing the `--" "crate-name` option to `rustc` or by using the [`crate_name` attribute](../" "attribute/crate.md)." msgstr "" "ライブラリは「lib」が頭につき、デフォルトでは、その後ろに元となったクレート" "ファイル名をつけます。（訳注: ここでは`lib` + `rary`）この振る舞いは" "[`crate_name`アトリビュート](../attribute/crate.md)を用いてオーバーライドでき" "ます。" #: src/crates/using_lib.md:3 msgid "" "To link a crate to this new library you may use `rustc`'s `--extern` flag. " "All of its items will then be imported under a module named the same as the " "library. This module generally behaves the same way as any other module." msgstr "" "クレートをこの新しいライブラリにリンクするには、`rustc`の`--extern`フラグを利" "用します。クレートの要素を全てライブラリと同じ名前のモジュールにインポートし" "ます。一般に、このモジュールは他のモジュールと同じように振る舞います。" #: src/crates/using_lib.md:8 msgid "" "// extern crate rary; // May be required for Rust 2015 edition or earlier\n" msgstr "// extern crate rary; // Rust 2015以前で必要。\n" #: src/crates/using_lib.md:13 msgid "" "// Error! `private_function` is private\n" " //rary::private_function();\n" msgstr "" "// エラー！`private_function`はプライベート。\n" " //rary::private_function();\n" #: src/cargo.md:3 msgid "" "`cargo` is the official Rust package management tool. It has lots of really " "useful features to improve code quality and developer velocity! These include" msgstr "" "`cargo`はRustの公式パッケージ管理ツールです。とても便利な機能が多くあり、コー" "ドの品質や開発速度の向上に役立ちます。以下はその例です。" #: src/cargo.md:6 msgid "" "Dependency management and integration with [crates.io](https://crates.io) " "(the official Rust package registry)" msgstr "" "依存関係の管理と[crates.io](https://crates.io)（Rustの公式パッケージレジスト" "リ）との統合" #: src/cargo.md:8 msgid "Awareness of unit tests" msgstr "ユニットテスト" #: src/cargo.md:9 msgid "Awareness of benchmarks" msgstr "ベンチマーク" #: src/cargo.md:11 msgid "" "This chapter will go through some quick basics, but you can find the " "comprehensive docs in [The Cargo Book](https://doc.rust-lang.org/cargo/)." msgstr "" "この章では、簡単な基本機能を説明します。包括的なドキュメントは[The Cargo " "Book](https://doc.rust-lang.org/cargo/)を参照してください。" #: src/cargo/deps.md:3 msgid "" "Most programs have dependencies on some libraries. If you have ever managed " "dependencies by hand, you know how much of a pain this can be. Luckily, the " "Rust ecosystem comes standard with `cargo`! `cargo` can manage dependencies " "for a project." msgstr "" "ほとんどのプログラムはライブラリに依存関係を持ちます。もし依存関係を手動で管" "理したことがあれば、それがどれだけ苦痛であるか分かるでしょう。幸運なことに、" "Rustのエコシステムには`cargo`が標準装備されています！`cargo`によってプロジェ" "クトの依存関係を管理することができます。" #: src/cargo/deps.md:8 msgid "To create a new Rust project," msgstr "Rustのプロジェクトを新しく作るには下記のようにします。" #: src/cargo/deps.md:11 msgid "# A binary\n" msgstr "# バイナリ\n" #: src/cargo/deps.md:13 msgid "# A library\n" msgstr "# ライブラリ\n" #: src/cargo/deps.md:18 msgid "" "For the rest of this chapter, let's assume we are making a binary, rather " "than a library, but all of the concepts are the same." msgstr "" "この章の残りでは、ライブラリではなくバイナリを作ることを想定しますが、コンセ" "プトはすべて同じです。" #: src/cargo/deps.md:21 msgid "After the above commands, you should see a file hierarchy like this:" msgstr "上のコマンドを実行すると、次のようなファイル階層ができます。" #: src/cargo/deps.md:35 msgid "" "The `main.rs` is the root source file for your new `foo` project -- nothing " "new there. The `Cargo.toml` is the config file for `cargo` for this project. " "If you look inside it, you should see something like this:" msgstr "" "`main.rs`がこの新規プロジェクト `foo` のルートのソースファイルです。なにも新" "しいことはありませんね。`Cargo.toml`はこのプロジェクトの`cargo`の設定ファイル" "です。中を見てみるとこのようになっています。" #: src/cargo/deps.md:39 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "```" msgstr "" #: src/cargo/deps.md:48 msgid "" "The `name` field under `[package]` determines the name of the project. This " "is used by `crates.io` if you publish the crate (more later). It is also the " "name of the output binary when you compile." msgstr "" "`[package]`の下の`name`フィールドがプロジェクトの名前を決定します。これはク" "レートを公開するときに`crates.io`によって使われます（詳細は後述）。またコンパ" "イルしたときの出力ファイルの名前でもあります。" #: src/cargo/deps.md:52 msgid "" "The `version` field is a crate version number using [Semantic Versioning]" "(http://semver.org/)." msgstr "" "`version`フィールドはクレートのバージョン番号で、[セマンティックバージョニン" "グ](http://semver.org/)を使っています。" #: src/cargo/deps.md:55 msgid "" "The `authors` field is a list of authors used when publishing the crate." msgstr "" "`authors`フィールドは作者のリストで、クレートを公開するときに使われます。" #: src/cargo/deps.md:57 msgid "" "The `[dependencies]` section lets you add dependencies for your project." msgstr "`[dependencies]`セクションにはプロジェクトの依存関係を追加できます。" #: src/cargo/deps.md:59 msgid "" "For example, suppose that we want our program to have a great CLI. You can " "find lots of great packages on [crates.io](https://crates.io) (the official " "Rust package registry). One popular choice is [clap](https://crates.io/" "crates/clap). As of this writing, the most recent published version of " "`clap` is `2.27.1`. To add a dependency to our program, we can simply add " "the following to our `Cargo.toml` under `[dependencies]`: `clap = " "\"2.27.1\"`. And that's it! You can start using `clap` in your program." msgstr "" "例えば、プログラムに素晴らしいCLIが欲しいとします。[crates.io](https://" "crates.io)（Rustの公式パッケージレジストリ）には素晴らしいパッケージがたくさ" "んあります。よくある選択肢の1つは[clap](https://crates.io/crates/clap)です。" "この記事を書いている時点での`clap`の最新の公開バージョンは`2.27.1`です。依存" "関係をプログラムに追加するには、`Cargo.toml`の`[dependencies]`の下に`clap = " "\"2.27.1\"`と単に書き加えます。これだけです！`clap`をプログラム内で使用できま" "す。" #: src/cargo/deps.md:67 msgid "" "`cargo` also supports [other types of dependencies](https://doc.rust-lang." "org/cargo/reference/specifying-dependencies.html). Here is just a small " "sampling:" msgstr "" "`cargo`は[他の形式の依存関係](https://doc.rust-lang.org/cargo/reference/" "specifying-dependencies.html)もサポートしています。その一部を示します。" #: src/cargo/deps.md:70 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "clap = \"2.27.1\" # from crates.io\n" "rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # from online " "repo\n" "bar = { path = \"../bar\" } # from a path in the local filesystem\n" "```" msgstr "" #: src/cargo/deps.md:82 msgid "" "`cargo` is more than a dependency manager. All of the available " "configuration options are listed in the [format specification](https://doc." "rust-lang.org/cargo/reference/manifest.html) of `Cargo.toml`." msgstr "" "`cargo`は依存管理ツール以上のこともできます。`Cargo.toml`の[format " "specification](https://doc.rust-lang.org/cargo/reference/manifest.html)に全て" "の設定オプションがリストアップされています。" #: src/cargo/deps.md:86 msgid "" "To build our project we can execute `cargo build` anywhere in the project " "directory (including subdirectories!). We can also do `cargo run` to build " "and run. Notice that these commands will resolve all dependencies, download " "crates if needed, and build everything, including your crate. (Note that it " "only rebuilds what it has not already built, similar to `make`)." msgstr "" "プロジェクトをビルドするには、プロジェクトディレクトリのどこか（サブディレク" "トでも！）で`cargo build`を実行します。また`cargo run`でビルドと実行をできま" "す。これらのコマンドは、全ての依存関係の解決、必要なクレートのダウンロード、" "自分のクレートを含む全てのビルドを行うことに注意してください。（`make`と同" "様、まだビルドしていないものだけをビルドします。）" #: src/cargo/deps.md:92 msgid "Voila! That's all there is to it!" msgstr "Voila！これで完成です！" #: src/cargo/conventions.md:3 msgid "In the previous chapter, we saw the following directory hierarchy:" msgstr "前の章ではこのようなディレクトリ階層がありました。" #: src/cargo/conventions.md:12 msgid "" "Suppose that we wanted to have two binaries in the same project, though. " "What then?" msgstr "しかし同じプロジェクトで2つのバイナリが欲しいとします。その場合は？" #: src/cargo/conventions.md:15 msgid "" "It turns out that `cargo` supports this. The default binary name is `main`, " "as we saw before, but you can add additional binaries by placing them in a " "`bin/` directory:" msgstr "" "`cargo`はこれもサポートしています。以前見た通りデフォルトのバイナリ名は`main`" "ですが、`bin/`ディレクトリに置くことで他のバイナリを追加できます。" #: src/cargo/conventions.md:28 msgid "" "To tell `cargo` to only compile or run this binary, we just pass `cargo` the " "`--bin my_other_bin` flag, where `my_other_bin` is the name of the binary we " "want to work with." msgstr "" "このバイナリだけをコンパイルや実行するように`cargo`に伝えるには、`cargo`に`--" "bin my_other_bin`フラグを渡します。ここでは`my_other_bin`が対象のバイナリの名" "前です。" #: src/cargo/conventions.md:32 msgid "" "In addition to extra binaries, `cargo` supports [more features](https://doc." "rust-lang.org/cargo/guide/project-layout.html) such as benchmarks, tests, " "and examples." msgstr "" "バイナリの追加に加えて、`cargo`はベンチマークやテスト、サンプルなどの[その他" "の機能](https://doc.rust-lang.org/cargo/guide/project-layout.html)もサポート" "しています。" #: src/cargo/conventions.md:35 msgid "In the next chapter, we will look more closely at tests." msgstr "次の章ではテストについてより詳しく見ていきます。" #: src/cargo/test.md:3 msgid "" "As we know testing is integral to any piece of software! Rust has first-" "class support for unit and integration testing ([see this chapter](https://" "doc.rust-lang.org/book/ch11-00-testing.html) in TRPL)." msgstr "" "知っての通り、テストはどんなソフトウェアにも不可欠です！Rustはユニットテスト" "と統合テストを第一級にサポートしています（TRPLの[この章を参照してください]" "(https://doc.rust-lang.org/book/ch11-00-testing.html)）。" #: src/cargo/test.md:8 msgid "" "From the testing chapters linked above, we see how to write unit tests and " "integration tests. Organizationally, we can place unit tests in the modules " "they test and integration tests in their own `tests/` directory:" msgstr "" "上のリンク先のテストの章では、ユニットテストと統合テストの書き方を紹介してい" "ます。ユニットテストはテスト対象のモジュール内に、統合テストは`tests/`ディレ" "クトリ内に置きます。" #: src/cargo/test.md:23 msgid "" "Each file in `tests` is a separate [integration test](https://doc.rust-lang." "org/book/ch11-03-test-organization.html#integration-tests), i.e. a test that " "is meant to test your library as if it were being called from a dependent " "crate." msgstr "" "`tests`内の各ファイルは個別の[統合テスト](https://doc.rust-lang.org/book/" "ch11-03-test-organization.html#integration-tests)です。これはライブラリを依存" "クレートから呼ばれたかのようにテストできます。" #: src/cargo/test.md:28 msgid "" "The [Testing](../testing.md) chapter elaborates on the three different " "testing styles: [Unit](../testing/unit_testing.md), [Doc](../testing/" "doc_testing.md), and [Integration](../testing/integration_testing.md)." msgstr "" "[テスト](../testing.md)の章は3つの異なるテストスタイルについて解説していま" "す。[単体テスト](../testing/unit_testing.md)、[ドキュメンテーションテスト]" "(../testing/doc_testing.md)、そして[結合テスト](../testing/" "integration_testing.md)です。" #: src/cargo/test.md:31 msgid "`cargo` naturally provides an easy way to run all of your tests!" msgstr "`cargo`は、全てのテストを簡単に実行する方法を提供します。" #: src/cargo/test.md:37 msgid "You should see output like this:" msgstr "出力はこのようになります。" #: src/cargo/test.md:39 msgid "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" msgstr "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" #: src/cargo/test.md:54 msgid "You can also run tests whose name matches a pattern:" msgstr "パターンにマッチする名前のテストを実行することもできます。" #: src/cargo/test.md:60 msgid "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" msgstr "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" #: src/cargo/test.md:73 msgid "" "One word of caution: Cargo may run multiple tests concurrently, so make sure " "that they don't race with each other." msgstr "" "注意：Cargoは複数のテストを並列で実行することがありますので、それらが互いに競" "合しないようにしてください。" #: src/cargo/test.md:76 msgid "" "One example of this concurrency causing issues is if two tests output to a " "file, such as below:" msgstr "" "並行性が問題を引き起こす一例として、以下のように、2つのテストが1つのファイル" "に出力するケースがあります。" #: src/cargo/test.md:82 msgid "// Import the necessary modules\n" msgstr "// 必要なモジュールをインポートします。\n" #: src/cargo/test.md:86 msgid "// This test writes to a file\n" msgstr "// ファイルに書き込むテスト\n" #: src/cargo/test.md:89 src/cargo/test.md:106 msgid "// Opens the file ferris.txt or creates one if it doesn't exist.\n" msgstr "// ferris.txtというファイルを開くか、存在しない場合は作成します。\n" #: src/cargo/test.md:93 src/cargo/test.md:110 msgid "\"ferris.txt\"" msgstr "\"ferris.txt\"" #: src/cargo/test.md:94 src/cargo/test.md:111 msgid "\"Failed to open ferris.txt\"" msgstr "\"Failed to open ferris.txt\"" #: src/cargo/test.md:96 msgid "// Print \"Ferris\" 5 times.\n" msgstr "// \"Ferris\"と5回書き込みます。\n" #: src/cargo/test.md:98 msgid "\"Ferris\\n\"" msgstr "\"Ferris\\n\"" #: src/cargo/test.md:99 src/cargo/test.md:116 msgid "\"Could not write to ferris.txt\"" msgstr "\"Could not write to ferris.txt\"" #: src/cargo/test.md:103 msgid "// This test tries to write to the same file\n" msgstr "// 同じファイルに書き込むテスト\n" #: src/cargo/test.md:113 msgid "// Print \"Corro\" 5 times.\n" msgstr "// \"Corro\"と5回書き込みます。\n" #: src/cargo/test.md:115 msgid "\"Corro\\n\"" msgstr "\"Corro\\n\"" #: src/cargo/test.md:122 msgid "Although the intent is to get the following:" msgstr "以下のような結果を得ようと意図しています。" #: src/cargo/test.md:136 msgid "What actually gets put into `ferris.txt` is this:" msgstr "しかし、実際に`ferris.txt`に出力されるのは、以下の通りです。" #: src/cargo/build_scripts.md:3 msgid "" "Sometimes a normal build from `cargo` is not enough. Perhaps your crate " "needs some pre-requisites before `cargo` will successfully compile, things " "like code generation, or some native code that needs to be compiled. To " "solve this problem we have build scripts that Cargo can run." msgstr "" "`cargo`による通常のビルドでは十分でないことが時々あります。コード生成や、コン" "パイルが必要なネイティブコードなど、`cargo`がクレートをうまくコンパイルするに" "はなんらかの前提条件が必要かもしれません。この問題を解決するため、Cargoが実行" "できるビルドスクリプトがあります。" #: src/cargo/build_scripts.md:8 msgid "" "To add a build script to your package it can either be specified in the " "`Cargo.toml` as follows:" msgstr "" "ビルドスクリプトをパッケージに追加するには、以下のように`Cargo.toml`の中で指" "定できます。" #: src/cargo/build_scripts.md:11 msgid "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" msgstr "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" #: src/cargo/build_scripts.md:17 msgid "" "Otherwise Cargo will look for a `build.rs` file in the project directory by " "default." msgstr "" "それ以外の場合、Cargoはデフォルトでプロジェクトディレクトリから`build.rs`を探" "します。" #: src/cargo/build_scripts.md:20 msgid "How to use a build script" msgstr "ビルドスクリプトの使い方" #: src/cargo/build_scripts.md:22 msgid "" "The build script is simply another Rust file that will be compiled and " "invoked prior to compiling anything else in the package. Hence it can be " "used to fulfill pre-requisites of your crate." msgstr "" "ビルドスクリプトは単にRustのファイルの1つで、パッケージ内の他のファイルをコン" "パイルする前にコンパイルされて起動されます。そのため、クレートの前提条件を満" "たすために使用できます。" #: src/cargo/build_scripts.md:26 msgid "" "Cargo provides the script with inputs via environment variables [specified " "here](https://doc.rust-lang.org/cargo/reference/environment-variables." "html#environment-variables-cargo-sets-for-build-scripts) that can be used." msgstr "" "Cargoは、[ここで指定された](https://doc.rust-lang.org/cargo/reference/" "environment-variables.html#environment-variables-cargo-sets-for-build-" "scripts)環境変数を介してスクリプトに入力を与えます。" #: src/cargo/build_scripts.md:29 msgid "" "The script provides output via stdout. All lines printed are written to " "`target/debug/build//output`. Further, lines prefixed with `cargo:` " "will be interpreted by Cargo directly and hence can be used to define " "parameters for the package's compilation." msgstr "" "スクリプトは標準出力に出力します。出力される行は全て、`target/debug/build/" "/output`に書き込まれます。さらに、行頭に`cargo:`がついた行はCargoに直接" "解釈されるため、パッケージのコンパイル時のパラメーターを定義するのに使用でき" "ます。" #: src/cargo/build_scripts.md:34 msgid "" "For further specification and examples have a read of the [Cargo " "specification](https://doc.rust-lang.org/cargo/reference/build-scripts.html)." msgstr "" "より詳細な仕様や例については、[Cargo specification](https://doc.rust-lang." "org/cargo/reference/build-scripts.html)を参照してください。" #: src/attribute.md:3 msgid "" "An attribute is metadata applied to some module, crate or item. This " "metadata can be used to/for:" msgstr "" "アトリビュートはモジュール、クレート、要素に対するメタデータです。以下がその" "使用目的です。" #: src/attribute.md:8 msgid "[conditional compilation of code](attribute/cfg.md)" msgstr "[コンパイル時の条件分岐](attribute/cfg.md)" #: src/attribute.md:9 msgid "" "[set crate name, version and type (binary or library)](attribute/crate.md)" msgstr "" "[クレート名、バージョン、種類（バイナリか、ライブラリか）の設定](attribute/" "crate.md)" #: src/attribute.md:10 msgid "" "disable [lints](https://en.wikipedia.org/wiki/Lint_%28software%29) (warnings)" msgstr "[リント](https://en.wikipedia.org/wiki/Lint_%28software%29)の無効化" #: src/attribute.md:11 msgid "enable compiler features (macros, glob imports, etc.)" msgstr "コンパイラ付属の機能（マクロ、グロブ、インポートなど）の使用" #: src/attribute.md:12 msgid "link to a foreign library" msgstr "外部ライブラリへのリンク" #: src/attribute.md:13 msgid "mark functions as unit tests" msgstr "ユニットテスト用の関数を明示" #: src/attribute.md:14 msgid "mark functions that will be part of a benchmark" msgstr "ベンチマーク用の関数を明示" #: src/attribute.md:15 msgid "" "[attribute like macros](https://doc.rust-lang.org/book/ch19-06-macros." "html#attribute-like-macros)" msgstr "" "[アトリビュートマクロ](https://doc.rust-lang.org/book/ch19-06-macros." "html#attribute-like-macros)" #: src/attribute.md:17 msgid "" "Attributes look like `#[outer_attribute]` or `#![inner_attribute]`, with the " "difference between them being where they apply." msgstr "" #: src/attribute.md:20 msgid "" "`#[outer_attribute]` applies to the [item](https://doc.rust-lang.org/stable/" "reference/items.html) immediately following it. Some examples of items are: " "a function, a module declaration, a constant, a structure, an enum. Here is " "an example where attribute `#[derive(Debug)]` applies to the struct " "`Rectangle`:" msgstr "" #: src/attribute.md:33 msgid "" "`#![inner_attribute]` applies to the enclosing [item](https://doc.rust-lang." "org/stable/reference/items.html) (typically a module or a crate). In other " "words, this attribute is interpreted as applying to the entire scope in " "which it's placed. Here is an example where `#![allow(unused_variables)]` " "applies to the whole crate (if placed in `main.rs`):" msgstr "" #: src/attribute.md:42 msgid "// This would normally warn about an unused variable.\n" msgstr "" #: src/attribute.md:46 msgid "Attributes can take arguments with different syntaxes:" msgstr "アトリビュートは以下の様な書き方で引数を取ることができます。" #: src/attribute.md:48 msgid "`#[attribute = \"value\"]`" msgstr "`#[attribute = \"value\"]`" #: src/attribute.md:49 msgid "`#[attribute(key = \"value\")]`" msgstr "`#[attribute(key = \"value\")]`" #: src/attribute.md:50 msgid "`#[attribute(value)]`" msgstr "`#[attribute(value)]`" #: src/attribute.md:52 msgid "" "Attributes can have multiple values and can be separated over multiple " "lines, too:" msgstr "" "アトリビュートは複数の値を取ることができ、複数の行に分割することもできます。" #: src/attribute/unused.md:3 msgid "" "The compiler provides a `dead_code` [_lint_](https://en.wikipedia.org/wiki/" "Lint_%28software%29) that will warn about unused functions. An _attribute_ " "can be used to disable the lint." msgstr "" "コンパイラは`dead_code`と呼ばれる[リント](https://en.wikipedia.org/wiki/Lint_" "%28software%29)機能を持つため、使用されていない関数が存在するときに警告を出し" "ます。*アトリビュート* によってこの機能を無効化することができます。" #: src/attribute/unused.md:9 msgid "" "// `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint\n" msgstr "" "/ `#[allow(dead_code)]`は`dead_code`リントを抑制するアトリビュートです。\n" #: src/attribute/unused.md:14 msgid "// FIXME ^ Add an attribute to suppress the warning\n" msgstr "// FIXME ^ 警告を抑制するアトリビュートを追加しましょう。\n" #: src/attribute/unused.md:22 msgid "" "Note that in real programs, you should eliminate dead code. In these " "examples we'll allow dead code in some places because of the interactive " "nature of the examples." msgstr "" "実際のコード中では、使用されていないコードが有る場合はそれを除外するべきで" "す。この文書中では随所でアトリビュートによって警告を抑制していますが、それは" "あくまでインタラクティブな例を皆さんに提供するためです。" #: src/attribute/crate.md:3 msgid "" "The `crate_type` attribute can be used to tell the compiler whether a crate " "is a binary or a library (and even which type of library), and the " "`crate_name` attribute can be used to set the name of the crate." msgstr "" "`crate_type`アトリビュートは、そのクレートがライブラリ、バイナリのいずれにコ" "ンパイルされるべきかをコンパイラに伝えるために使用します。ライブラリの場合" "は、どのタイプのライブラリであるかも伝えることができます。`crate_name`はク" "レートの名前を決定するのに使用します。" #: src/attribute/crate.md:7 msgid "" "However, it is important to note that both the `crate_type` and `crate_name` " "attributes have **no** effect whatsoever when using Cargo, the Rust package " "manager. Since Cargo is used for the majority of Rust projects, this means " "real-world uses of `crate_type` and `crate_name` are relatively limited." msgstr "" "しかし、`crate_type`アトリビュートも`crate_name`アトリビュートも、Rustのパッ" "ケージマネージャCargoを利用している場合は**何の**影響もないと知っておくことは" "重要です。Cargoは大半のRustプロジェクトで利用されており、実世界での" "`crate_type`と`crate_name`の利用は比較的限られています。" #: src/attribute/crate.md:13 msgid "// This crate is a library\n" msgstr "// このクレートはライブラリです。\n" #: src/attribute/crate.md:14 msgid "\"lib\"" msgstr "\"lib\"" #: src/attribute/crate.md:14 msgid "// The library is named \"rary\"\n" msgstr "// このライブラリの名前は「rary」です。\n" #: src/attribute/crate.md:16 msgid "\"rary\"" msgstr "\"rary\"" #: src/attribute/crate.md:33 msgid "" "When the `crate_type` attribute is used, we no longer need to pass the `--" "crate-type` flag to `rustc`." msgstr "" "`crate_type`アトリビュートが使用されているときは、`rustc`に`--crate-type`フラ" "グを伝える必要はありません。" #: src/attribute/cfg.md:3 msgid "" "Configuration conditional checks are possible through two different " "operators:" msgstr "環境に応じたコンパイルをするには2種類の方法があります。" #: src/attribute/cfg.md:5 msgid "the `cfg` attribute: `#[cfg(...)]` in attribute position" msgstr "`cfg`アトリビュート：`#[cfg(...)]`をアトリビュートとして使用する。" #: src/attribute/cfg.md:6 msgid "the `cfg!` macro: `cfg!(...)` in boolean expressions" msgstr "`cfg!`マクロ：`cfg!(...)`をブーリアンとして評価する。" #: src/attribute/cfg.md:8 msgid "" "While the former enables conditional compilation, the latter conditionally " "evaluates to `true` or `false` literals allowing for checks at run-time. " "Both utilize identical argument syntax." msgstr "" "前者は条件付きコンパイルを行いますが、後者は`true`または`false`リテラルに評価" "され実行時にチェックすることが可能です。いずれの場合も適切なシンタックスで記" "述する必要があります。" #: src/attribute/cfg.md:12 msgid "" "`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true " "or false. For example, all blocks in an if/else expression need to be valid " "when `cfg!` is used for the condition, regardless of what `cfg!` is " "evaluating." msgstr "" "`#[cfg]`と異なり、`cfg!`はコードを削除せず、trueまたはfalseに評価されるだけで" "す。例えば、`cfg!`が何を評価しているかに関係なく、`cfg!`が条件に利用されると" "き、if/else式の中のすべてのブロックが有効でなくてはなりません。" #: src/attribute/cfg.md:15 msgid "// This function only gets compiled if the target OS is linux\n" msgstr "// この関数はターゲットOSがLinuxの時のみコンパイルされます。\n" #: src/attribute/cfg.md:16 src/attribute/cfg.md:22 src/attribute/cfg.md:31 msgid "\"linux\"" msgstr "\"linux\"" #: src/attribute/cfg.md:18 msgid "\"You are running linux!\"" msgstr "\"You are running linux!\"" #: src/attribute/cfg.md:20 msgid "" "// And this function only gets compiled if the target OS is *not* linux\n" msgstr "" "// そしてこの関数はターゲットOSがLinux *ではない* ときのみコンパイルされま" "す。\n" #: src/attribute/cfg.md:24 msgid "\"You are *not* running linux!\"" msgstr "\"You are *not* running linux!\"" #: src/attribute/cfg.md:30 msgid "\"Are you sure?\"" msgstr "\"Are you sure?\"" #: src/attribute/cfg.md:32 msgid "\"Yes. It's definitely linux!\"" msgstr "\"Yes. It's definitely linux!\"" #: src/attribute/cfg.md:34 msgid "\"Yes. It's definitely *not* linux!\"" msgstr "\"Yes. It's definitely *not* linux!\"" #: src/attribute/cfg.md:41 msgid "" "[the reference](https://doc.rust-lang.org/reference/attributes." "html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/std/macro." "cfg!.html), and [macros](../macros.md)." msgstr "" "[リファレンス](https://doc.rust-lang.org/reference/attributes." "html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/std/macro." "cfg!.html), [マクロ](../macros.md)." #: src/attribute/cfg/custom.md:3 msgid "" "Some conditionals like `target_os` are implicitly provided by `rustc`, but " "custom conditionals must be passed to `rustc` using the `--cfg` flag." msgstr "" "`target_os`のように、いくつかの条件分岐は`rustc`が暗黙のうちに提供していま" "す。条件を独自に追加する場合には`--cfg`フラグを用いて`rustc`に伝える必要があ" "ります。" #: src/attribute/cfg/custom.md:9 msgid "\"condition met!\"" msgstr "\"condition met!\"" #: src/attribute/cfg/custom.md:17 msgid "Try to run this to see what happens without the custom `cfg` flag." msgstr "独自の`cfg`フラグを用いない場合、何が起きるかやってみてください。" #: src/attribute/cfg/custom.md:19 msgid "With the custom `cfg` flag:" msgstr "`cfg`フラグがある場合：" #: src/generics.md:3 msgid "" "_Generics_ is the topic of generalizing types and functionalities to broader " "cases. This is extremely useful for reducing code duplication in many ways, " "but can call for rather involved syntax. Namely, being generic requires " "taking great care to specify over which types a generic type is actually " "considered valid. The simplest and most common use of generics is for type " "parameters." msgstr "" "ジェネリクスとは、型と関数の機能をより汎用的に使えるようにするための機能で" "す。これはあらゆる局面でコードの重複を避けるために非常に役立ちますが、多少構" "文が複雑になります。すなわち、ジェネリック型を使いこなすには、どのようなジェ" "ネリック型がきちんと機能するかに細心の注意を払う必要があります。最もシンプル" "で一般的なジェネリクスの利用法は型パラメータです。" #: src/generics.md:10 msgid "" "A type parameter is specified as generic by the use of angle brackets and " "upper [camel case](https://en.wikipedia.org/wiki/CamelCase): ``. \"Generic type parameters\" are typically represented as ``. In Rust, " "\"generic\" also describes anything that accepts one or more generic type " "parameters ``. Any type specified as a generic type parameter is generic, " "and everything else is concrete (non-generic)." msgstr "" "ジェネリック型の型パラメータにはかぎ括弧とアッパー[キャメルケース](https://" "en.wikipedia.org/wiki/CamelCase)（``）が使われます。ジェネリッ" "クな型パラメータはたいていの場合``で示されます。Rustの場合、「ジェネリク" "ス」には「１つ以上のジェネリックな型パラメータ``を受け付けるもの」という意" "味もあります。ジェネリックな型パラメータを指定された場合、それは必ずジェネ" "リック型になり、そうでなければ必ず非ジェネリック型、すなわち具象型になりま" "す。" #: src/generics.md:16 msgid "" "For example, defining a _generic function_ named `foo` that takes an " "argument `T` of any type:" msgstr "" "例として、あらゆる型の引数`T`をとる *ジェネリック関数* `foo`を定義すると" #: src/generics.md:23 msgid "" "Because `T` has been specified as a generic type parameter using ``, it " "is considered generic when used here as `(arg: T)`. This is the case even if " "`T` has previously been defined as a `struct`." msgstr "" "となります。`T`はジェネリックな型パラメータに指定されているので、この場所で" "`(arg: T)`のように使用するとジェネリック型として扱われます。これは`T`という構" "造体がそれ以前に定義されていても同様です。" #: src/generics.md:27 msgid "This example shows some of the syntax in action:" msgstr "では、手を動かしながらジェネリック型の構文を体験していきましょう。" #: src/generics.md:30 msgid "// A concrete type `A`.\n" msgstr "// `A`という具象型\n" #: src/generics.md:32 msgid "" "// In defining the type `Single`, the first use of `A` is not preceded by " "``.\n" "// Therefore, `Single` is a concrete type, and `A` is defined as above.\n" msgstr "" "// `Single`という型を定義する際に`A`を使用していますが、その最初の使用よりも" "先に\n" "// ``がないため、また、`A`自身も具象型であるため、`Single`は具象型となりま" "す。\n" #: src/generics.md:35 msgid "// ^ Here is `Single`s first use of the type `A`.\n" msgstr "// ^ `Single`による`A`の一番最初の使用はここ。\n" #: src/generics.md:37 msgid "" "// Here, `` precedes the first use of `T`, so `SingleGen` is a generic " "type.\n" "// Because the type parameter `T` is generic, it could be anything, " "including\n" "// the concrete type `A` defined at the top.\n" msgstr "" "// ここでは``が一番初めの`T`の使用よりも先に来ています。\n" "// よって`SingleGen`はジェネリック型となります。\n" "// なぜならば型パラメータ`T`がジェネリックだからです。\n" "// `T`はどんな型にもなりえるため、上で定義した`A`を受け取ることもできます。\n" #: src/generics.md:44 msgid "// `Single` is concrete and explicitly takes `A`.\n" msgstr "// `Single`は具象型で、`A`のみを受け取ります。\n" #: src/generics.md:47 msgid "" "// Create a variable `_char` of type `SingleGen`\n" " // and give it the value `SingleGen('a')`.\n" " // Here, `SingleGen` has a type parameter explicitly specified.\n" msgstr "" "// `_char`という名の変数を生成します。これは`SingleGen`\n" " // という型で、値は`SingleGen('a')`となります。\n" " // ここでは、`SingleGen`には明示的な型パラメータが与えられています。\n" #: src/generics.md:52 msgid "// `SingleGen` can also have a type parameter implicitly specified:\n" msgstr "" "// `SingleGen`型の変数には明示的に型パラメータを与えなくても構いません。\n" #: src/generics.md:53 msgid "// Uses `A` defined at the top.\n" msgstr "// 上で定義した`A`を使用。\n" #: src/generics.md:54 msgid "// Uses `i32`.\n" msgstr "// `i32`を使用。\n" #: src/generics.md:55 msgid "// Uses `char`.\n" msgstr "// `char`を使用。\n" #: src/generics.md:61 msgid "[`structs`](custom_types/structs.md)" msgstr "[構造体](custom_types/structs.md)" #: src/generics/gen_fn.md:3 msgid "" "The same set of rules can be applied to functions: a type `T` becomes " "generic when preceded by ``." msgstr "" "「型`T`はその前に``があるとジェネリック型になる」というルールは関数に対し" "ても当てはまります。" #: src/generics/gen_fn.md:6 msgid "" "Using generic functions sometimes requires explicitly specifying type " "parameters. This may be the case if the function is called where the return " "type is generic, or if the compiler doesn't have enough information to infer " "the necessary type parameters." msgstr "" "ジェネリック関数を使用する際、型パラメータを明示する必要がある場合がありま" "す。返り値がジェネリック型である場合や、コンパイラが型パラメータを推論するの" "に十分な情報がない場合です。" #: src/generics/gen_fn.md:11 msgid "" "A function call with explicitly specified type parameters looks like: `fun::" "()`." msgstr "" "型パラメータを明示したうえでの関数呼び出しの構文は`fun::()`のよう" "になります。" #: src/generics/gen_fn.md:15 msgid "// Concrete type `A`.\n" msgstr "// 具象型`A`\n" #: src/generics/gen_fn.md:16 msgid "// Concrete type `S`.\n" msgstr "// 具象型`S`\n" #: src/generics/gen_fn.md:17 msgid "// Generic type `SGen`.\n" msgstr "// ジェネリック型`SGen`\n" #: src/generics/gen_fn.md:18 msgid "" "// The following functions all take ownership of the variable passed into\n" "// them and immediately go out of scope, freeing the variable.\n" msgstr "" "// 以下の関数は全て変数の所有権をとった後すぐにスコープを抜けて\n" "// 変数をメモリ上から開放します。\n" #: src/generics/gen_fn.md:21 msgid "" "// Define a function `reg_fn` that takes an argument `_s` of type `S`.\n" "// This has no `` so this is not a generic function.\n" msgstr "" "// `S`という型の引数`_s`をとる`reg_fn`という関数を定義。\n" "// ``がないのでジェネリック関数ではありません。\n" #: src/generics/gen_fn.md:25 msgid "" "// Define a function `gen_spec_t` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `A`, but because `A` has " "not \n" "// been specified as a generic type parameter for `gen_spec_t`, it is not " "generic.\n" msgstr "" "// `gen_spec_t`という関数を定義。これは`A`という型を与えられた`SGen`\n" "// という型の引数`_s`を取ります。関数名の直後に``という型パラメータでAが\n" "// ジェネリックであることを明示していないので、この関数はAをジェネリック型\n" "// としては取りません\n" #: src/generics/gen_fn.md:30 msgid "" "// Define a function `gen_spec_i32` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `i32`, which is a " "specific type.\n" "// Because `i32` is not a generic type, this function is also not generic.\n" msgstr "" "// `gen_spec_i32`という関数を定義。\n" "// これは明示的な型パラメータとして`i32`を与えられた\n" "// `SGen`型の引数`_s`を取ります。\n" "// この関数もジェネリックではありません。\n" #: src/generics/gen_fn.md:35 msgid "" "// Define a function `generic` that takes an argument `_s` of type " "`SGen`.\n" "// Because `SGen` is preceded by ``, this function is generic over " "`T`.\n" msgstr "" "// `generic`という関数を定義。`SGen`という型の引数`_s`を取ります。\n" "// ``が`SGen`に先行しているため、これはTに対してジェネリックな関数で" "す。\n" #: src/generics/gen_fn.md:41 msgid "// Using the non-generic functions\n" msgstr "// ジェネリックでない関数を使用します。\n" #: src/generics/gen_fn.md:42 msgid "// Concrete type.\n" msgstr "// 具象型\n" #: src/generics/gen_fn.md:43 msgid "// Implicitly specified type parameter `A`.\n" msgstr "// 型パラメータ`A`を暗黙のうちに受け取ります。\n" #: src/generics/gen_fn.md:44 msgid "// Implicitly specified type parameter `i32`.\n" msgstr "// 型パラメータ`i32`を暗黙のうちに受け取ります。\n" #: src/generics/gen_fn.md:46 msgid "// Explicitly specified type parameter `char` to `generic()`.\n" msgstr "// 型パラメータ`char`を明示的に`generic()`に渡します。\n" #: src/generics/gen_fn.md:49 msgid "// Implicitly specified type parameter `char` to `generic()`.\n" msgstr "// 型パラメータ`char`を暗黙的に`generic()`に渡します。\n" #: src/generics/gen_fn.md:50 msgid "'c'" msgstr "'c'" #: src/generics/gen_fn.md:56 msgid "[functions](../fn.md) and [`struct`s](../custom_types/structs.md)" msgstr "[関数](../fn.md), [構造体](../custom_types/structs.md)" #: src/generics/impl.md:3 msgid "Similar to functions, implementations require care to remain generic." msgstr "" "関数と同様、`impl`でメソッドを実装する際にもジェネリック型特有の記法が必要で" "す。" #: src/generics/impl.md:6 msgid "// Concrete type `S`\n" msgstr "// 具象型`S`\n" #: src/generics/impl.md:7 msgid "// Generic type `GenericVal`\n" msgstr "// ジェネリック型`GenericVal`\n" #: src/generics/impl.md:8 msgid "// impl of GenericVal where we explicitly specify type parameters:\n" msgstr "// 型パラメータを指定したうえで、GenericValにメソッドを実装。\n" #: src/generics/impl.md:10 msgid "// Specify `f32`\n" msgstr "// `f32`の場合のメソッド\n" #: src/generics/impl.md:11 msgid "// Specify `S` as defined above\n" msgstr "// 上で定義した`S`への実装\n" #: src/generics/impl.md:12 msgid "// `` Must precede the type to remain generic\n" msgstr "// ジェネリック型のまま扱うには``が先に来る必要があります。\n" #: src/generics/impl.md:25 msgid "// impl of Val\n" msgstr "// Valに対して実装。\n" #: src/generics/impl.md:32 msgid "// impl of GenVal for a generic type `T`\n" msgstr "// ジェネリック型`T`の場合のメソッドをGenValに対して実装。\n" #: src/generics/impl.md:50 msgid "" "[functions returning references](../scope/lifetime/fn.md), [`impl`](../fn/" "methods.md), and [`struct`](../custom_types/structs.md)" msgstr "" "[参照を返す関数](../scope/lifetime/fn.md), [`impl`](../fn/methods.md), [構造" "体](../custom_types/structs.md)" #: src/generics/gen_trait.md:3 msgid "" "Of course `trait`s can also be generic. Here we define one which " "reimplements the `Drop` `trait` as a generic method to `drop` itself and an " "input." msgstr "" "もちろんトレイトもジェネリクスを活用することができます。ここでは`Drop`トレイ" "トをジェネリックメソッドとして再実装し、自身と引数として受け取った値の両方を" "`drop`するようなメソッドにします。" #: src/generics/gen_trait.md:7 msgid "// Non-copyable types.\n" msgstr "" "// コピー不可な型\n" "// 訳注: `clone()`メソッドを用いないかぎり、値のコピーではなくムーブが起きる" "型\n" #: src/generics/gen_trait.md:10 msgid "// A trait generic over `T`.\n" msgstr "// ジェネリック型 `T`に対するトレイト\n" #: src/generics/gen_trait.md:13 msgid "" "// Define a method on the caller type which takes an\n" " // additional single parameter `T` and does nothing with it.\n" msgstr "" "// `self`に加えてもう一つジェネリック型を受け取り、\n" " // 何もしないメソッドのシグネチャを定義。\n" #: src/generics/gen_trait.md:17 msgid "" "// Implement `DoubleDrop` for any generic parameter `T` and\n" "// caller `U`.\n" msgstr "" "// `U`を`self`として、`T`をもう一つの引数として受け取る`DoubleDrop`\n" "// を実装する。`U`,`T`はいずれもジェネリック型。\n" #: src/generics/gen_trait.md:21 msgid "" "// This method takes ownership of both passed arguments,\n" " // deallocating both.\n" msgstr "// このメソッドは2つの引数の所有権を取り、メモリ上から開放します。\n" #: src/generics/gen_trait.md:30 msgid "// Deallocate `empty` and `null`.\n" msgstr "// `empty`と`null`を開放。\n" #: src/generics/gen_trait.md:33 msgid "" "//empty;\n" " //null;\n" " // ^ TODO: Try uncommenting these lines.\n" msgstr "" "//empty;\n" " //null;\n" " // ^ TODO: これらの行をアンコメントしてみましょう。\n" #: src/generics/gen_trait.md:41 msgid "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`struct`](../" "custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [構造体](../" "custom_types/structs.md), [トレイト](../trait.md)" #: src/generics/bounds.md:3 msgid "" "When working with generics, the type parameters often must use traits as " "_bounds_ to stipulate what functionality a type implements. For example, the " "following example uses the trait `Display` to print and so it requires `T` " "to be bound by `Display`; that is, `T` _must_ implement `Display`." msgstr "" "ジェネリックプログラミングをしていると、型パラメータが特定の機能を持っている" "ことを規定するため、トレイトに境界を設ける必要があることがよくあります。例え" "ば、以下の例では、引数の`Display`トレイトを用いて出力を行うため、`T`が" "`Display`を持っていることを規定しています。つまり、「`T`は`Display`を実装 *し" "ていなくてはならない* 」という意味です。" #: src/generics/bounds.md:9 msgid "" "// Define a function `printer` that takes a generic type `T` which\n" "// must implement trait `Display`.\n" msgstr "" "// `Display`トレイトを実装している`T`を引数として取ります。\n" "// `printer`という関数を定義。\n" #: src/generics/bounds.md:16 msgid "" "Bounding restricts the generic to types that conform to the bounds. That is:" msgstr "" "境界は、ジェネリクスを全ての型ではなく、一定条件を満たす型に対してのみ適用す" "るためにあります。つまり" #: src/generics/bounds.md:20 msgid "" "// Error! `Vec` does not implement `Display`. This\n" "// specialization will fail.\n" msgstr "" "// エラー！`Vec`は`Display`を実装していないため、この特殊化\n" "// は失敗します。\n" #: src/generics/bounds.md:26 msgid "" "Another effect of bounding is that generic instances are allowed to access " "the [methods](../fn/methods.md) of traits specified in the bounds. For " "example:" msgstr "" "境界のもう一つの効果は、ジェネリック型のインスタンスが、境界条件となるトレイ" "トの[メソッド](../fn/methods.md)にアクセスすることができるようになる点です。" "以下がその例です。" #: src/generics/bounds.md:30 msgid "// A trait which implements the print marker: `{:?}`.\n" msgstr "// 出力時のマーカー`{:?}`を実装するトレイト\n" #: src/generics/bounds.md:45 msgid "" "// The generic `T` must implement `Debug`. Regardless\n" "// of the type, this will work properly.\n" msgstr "" "// ジェネリック型`T`は`Debug`トレイトを実装していなくてはなりません。\n" "// その限りにおいて、`T`がどのような具象型であろうとも次の関数は動作しま" "す。\n" #: src/generics/bounds.md:51 msgid "" "// `T` must implement `HasArea`. Any type which meets\n" "// the bound can access `HasArea`'s function `area`.\n" msgstr "" "// 「`T`は`HasArea`を実装していなくてはならない」という境界条件を\n" "// 満たしていれば、`HasArea`の関数`area`にアクセスできます。\n" #: src/generics/bounds.md:61 msgid "\"Area: {}\"" msgstr "\"Area: {}\"" #: src/generics/bounds.md:63 msgid "" "//print_debug(&_triangle);\n" " //println!(\"Area: {}\", area(&_triangle));\n" " // ^ TODO: Try uncommenting these.\n" " // | Error: Does not implement either `Debug` or `HasArea`. \n" msgstr "" "//print_debug(&_triangle);\n" " //println!(\"Area: {}\", area(&_triangle));\n" " // ^ TODO: これらの行をアンコメントしてみましょう。\n" " // | Error: `Debug` も `HasArea`もどちらも実装されていません！\n" #: src/generics/bounds.md:70 msgid "" "As an additional note, [`where`](../generics/where.md) clauses can also be " "used to apply bounds in some cases to be more expressive." msgstr "" "付け加えておくと、[`where`](../generics/where.md)句を用いて境界を適用すること" "もできます。場合によってはこちらの記法を使用したほうが読みやすくなる場合もあ" "ります。" #: src/generics/bounds.md:75 msgid "" "[`std::fmt`](../hello/print.md), [`struct`s](../custom_types/structs.md), " "and [`trait`s](../trait.md)" msgstr "" "[`std::fmt`](../hello/print.md), [構造体](../custom_types/structs.md), [トレ" "イト](../trait.md)" #: src/generics/bounds/testcase_empty.md:3 msgid "" "A consequence of how bounds work is that even if a `trait` doesn't include " "any functionality, you can still use it as a bound. `Eq` and `Copy` are " "examples of such `trait`s from the `std` library." msgstr "" "トレイト境界の仕組みから、「トレイトがなにも機能を持っていなくとも境界条件と" "して使用できることには変わりはない」という帰結がもたらされます。`Eq`と`Copy`" "は`std`ライブラリにおけるそのような例です。" #: src/generics/bounds/testcase_empty.md:17 msgid "" "// These functions are only valid for types which implement these\n" "// traits. The fact that the traits are empty is irrelevant.\n" msgstr "" "// 以下の関数はトレイト境界を設けていますが、そのトレイトが空である\n" "// か否かとは関係ありません。\n" #: src/generics/bounds/testcase_empty.md:20 msgid "\"red\"" msgstr "\"red\"" #: src/generics/bounds/testcase_empty.md:21 msgid "\"blue\"" msgstr "\"blue\"" #: src/generics/bounds/testcase_empty.md:28 msgid "" "// `red()` won't work on a blue jay nor vice versa\n" " // because of the bounds.\n" msgstr "" "// トレイト境界のため、`red`は`blue_jay`に対しては使用できません。\n" " // `blue`と`Cardinal`も同様です。\n" #: src/generics/bounds/testcase_empty.md:30 msgid "\"A cardinal is {}\"" msgstr "\"A cardinal is {}\"" #: src/generics/bounds/testcase_empty.md:31 msgid "\"A blue jay is {}\"" msgstr "\"A blue jay is {}\"" #: src/generics/bounds/testcase_empty.md:32 msgid "" "//println!(\"A turkey is {}\", red(&_turkey));\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" "//println!(\"A turkey is {}\", red(&_turkey));\n" " // ^ TODO: この行をアンコメントしてみましょう。\n" #: src/generics/bounds/testcase_empty.md:39 msgid "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), [`std::" "marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), and " "[`trait`s](../../trait.md)" msgstr "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), [`std::" "marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), [トレイ" "ト](../../trait.md)" #: src/generics/multi_bounds.md:3 msgid "" "Multiple bounds for a single type can be applied with a `+`. Like normal, " "different types are separated with `,`." msgstr "" "`+`を用いて1つの型に複数のトレイト境界を設けることができます。複数の引数を受" "け取るときは、通常時と同様、`,`で区切ります。" #: src/generics/multi_bounds.md:10 msgid "\"Debug: `{:?}`\"" msgstr "\"Debug: `{:?}`\"" #: src/generics/multi_bounds.md:11 msgid "\"Display: `{}`\"" msgstr "\"Display: `{}`\"" #: src/generics/multi_bounds.md:15 msgid "\"t: `{:?}`\"" msgstr "\"t: `{:?}`\"" #: src/generics/multi_bounds.md:16 msgid "\"u: `{:?}`\"" msgstr "\"u: `{:?}`\"" #: src/generics/multi_bounds.md:20 msgid "\"words\"" msgstr "\"words\"" #: src/generics/multi_bounds.md:25 msgid "" "//compare_prints(&array);\n" " // TODO ^ Try uncommenting this.\n" msgstr "" "//compare_prints(&array);\n" " // TODO ^ ここをアンコメントしてみましょう。\n" #: src/generics/multi_bounds.md:34 msgid "[`std::fmt`](../hello/print.md) and [`trait`s](../trait.md)" msgstr "[`std::fmt`](../hello/print.md), [トレイト](../trait.md)" #: src/generics/where.md:3 msgid "" "A bound can also be expressed using a `where` clause immediately before the " "opening `{`, rather than at the type's first mention. Additionally, `where` " "clauses can apply bounds to arbitrary types, rather than just to type " "parameters." msgstr "" "トレイト境界は、`{`の直前に`where`句を導入することでも設けることができます。" "`where`はさらに、型パラメータだけでなく任意の型に対して適用できます。" #: src/generics/where.md:8 msgid "Some cases that a `where` clause is useful:" msgstr "`where`句のほうが有効なケースには例えば以下のようなものがあります。" #: src/generics/where.md:10 msgid "When specifying generic types and bounds separately is clearer:" msgstr "" "ジェネリック型とジェネリック境界に別々に制限を加えたほうが明瞭になる場合" #: src/generics/where.md:14 msgid "// Expressing bounds with a `where` clause\n" msgstr "// `where`を用いてジェネリック境界を設けます。\n" #: src/generics/where.md:21 msgid "" "When using a `where` clause is more expressive than using normal syntax. The " "`impl` in this example cannot be directly expressed without a `where` clause:" msgstr "" "`where`句の方が通常の構文より表現力が高い場合。この例では`where`句を使わずに" "書くことはできません。" #: src/generics/where.md:30 msgid "" "// Because we would otherwise have to express this as `T: Debug` or \n" "// use another method of indirect approach, this requires a `where` clause:\n" msgstr "" "// `where`句を用いない場合、以下と等価な機能を実装するには、\n" "// `T: Debug`という形で表現するか、別の直接的でない方法\n" "// を使用するかしなくてはなりません。\n" #: src/generics/where.md:35 msgid "" "// We want `Option: Debug` as our bound because that is what's\n" " // being printed. Doing otherwise would be using the wrong bound.\n" msgstr "" "// 出力されるのが`Some(self)`であるため、この関数の\n" " // ジェネリック境界として`Option: Debug`を使用したい。\n" #: src/generics/where.md:51 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), " "[`struct`](../custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), [構" "造体](../custom_types/structs.md), [トレイト](../trait.md)" #: src/generics/new_types.md:3 msgid "" "The `newtype` idiom gives compile time guarantees that the right type of " "value is supplied to a program." msgstr "" "ニュータイプイディオムは正しい型の値が与えられていることをコンパイル時に保証" "することができます。" #: src/generics/new_types.md:6 msgid "" "For example, an age verification function that checks age in years, _must_ " "be given a value of type `Years`." msgstr "" "例えば、年齢を年単位で確認する`is_adult`には「Years」という型の値を *与えな" "ければならない* ようにすることが可能です。" #: src/generics/new_types.md:22 msgid "/// truncates partial years\n" msgstr "/// 1年に満たない日付は切り捨て。\n" #: src/generics/new_types.md:35 src/generics/new_types.md:36 msgid "\"Is an adult? {}\"" msgstr "" #: src/generics/new_types.md:37 msgid "// println!(\"Is an adult? {}\", is_adult(&age_days));\n" msgstr "// println!(\"Is an adult? {}\", is_adult(&age_days));\n" #: src/generics/new_types.md:41 msgid "" "Uncomment the last print statement to observe that the type supplied must be " "`Years`." msgstr "" "最後の print文 のコメントを外して、与えられた型が `Years` でなければならない" "ことを確認してください。" #: src/generics/new_types.md:43 msgid "" "To obtain the `newtype`'s value as the base type, you may use the tuple or " "destructuring syntax like so:" msgstr "" "`newtype`の元に使われている型のデータを取得するには、以下のようにタプルやデス" "トラクト構文を用いることで取得できます。" #: src/generics/new_types.md:49 msgid "// Tuple\n" msgstr "// タプル\n" #: src/generics/new_types.md:50 msgid "// Destructuring\n" msgstr "// デストラクト\n" #: src/generics/new_types.md:56 msgid "[`structs`](../custom_types/structs.md)" msgstr "[構造体](../custom_types/structs.md)" #: src/generics/assoc_items.md:3 msgid "" "\"Associated Items\" refers to a set of rules pertaining to [`item`](https://" "doc.rust-lang.org/reference/items.html)s of various types. It is an " "extension to `trait` generics, and allows `trait`s to internally define new " "items." msgstr "" "関連要素とは複数の型の[要素](https://doc.rust-lang.org/reference/items.html)" "に関係のある規則の総称です。トレイトの拡張機能であり、トレイトの中で新しい要" "素を定義することを可能にします。" #: src/generics/assoc_items.md:7 msgid "" "One such item is called an _associated type_, providing simpler usage " "patterns when the `trait` is generic over its container type." msgstr "" "そのように定義する要素の一つに **関連型** があります。これにより、ジェネリッ" "クなコンテナ型に対するトレイトを使用する際に、よりシンプルな書き方ができるよ" "うになります。" #: src/generics/assoc_items.md:12 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" msgstr "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" #: src/generics/assoc_items/the_problem.md:3 msgid "" "A `trait` that is generic over its container type has type specification " "requirements - users of the `trait` _must_ specify all of its generic types." msgstr "" "コンテナ型に、その要素に対してジェネリックなトレイトを実装した場合、そのトレ" "イトを使用する者は全てのジェネリック型を明記 *しなくてはなりません* 。" #: src/generics/assoc_items/the_problem.md:6 msgid "" "In the example below, the `Contains` `trait` allows the use of the generic " "types `A` and `B`. The trait is then implemented for the `Container` type, " "specifying `i32` for `A` and `B` so that it can be used with `fn " "difference()`." msgstr "" "以下の例では`Contains`トレイトはジェネリック型`A`と`B`の使用を許しています。" "その後、`Container`型に対して`Contains`を実装していますが、その際後に`fn " "difference()`が使用できるように、`A`、`B`はそれぞれ`i32`と明記されています。" #: src/generics/assoc_items/the_problem.md:10 msgid "" "Because `Contains` is generic, we are forced to explicitly state _all_ of " "the generic types for `fn difference()`. In practice, we want a way to " "express that `A` and `B` are determined by the _input_ `C`. As you will see " "in the next section, associated types provide exactly that capability." msgstr "" "`Contains`はジェネリックトレイトなので、`fn difference()`では **全ての** ジェ" "ネリック型を宣言しなくてはなりません。実際のところ、`A`と`B`は **引数** であ" "る`C`によって決定されていて欲しいにも関わらず、です。これは次のページで紹介す" "る関連型と呼ばれる機能によって可能です。" #: src/generics/assoc_items/the_problem.md:17 #: src/generics/assoc_items/types.md:36 msgid "" "// A trait which checks if 2 items are stored inside of container.\n" "// Also retrieves first or last value.\n" msgstr "" "// ２つの要素がコンテナ型の中にあることをチェックするトレイト\n" "// また、最初と最後の値を取得することもできます。\n" #: src/generics/assoc_items/the_problem.md:21 msgid "// Explicitly requires `A` and `B`.\n" msgstr "// `A`と`B`両方を明示的に要求します。\n" #: src/generics/assoc_items/the_problem.md:22 #: src/generics/assoc_items/the_problem.md:23 msgid "// Doesn't explicitly require `A` or `B`.\n" msgstr "// `A`、`B`いずれも要求しません。\n" #: src/generics/assoc_items/the_problem.md:27 msgid "// True if the numbers stored are equal.\n" msgstr "// コンテナ内の２つの要素が等しければTrueを返します。\n" #: src/generics/assoc_items/the_problem.md:32 #: src/generics/assoc_items/types.md:60 msgid "// Grab the first number.\n" msgstr "// ひとつ目の値を取得。\n" #: src/generics/assoc_items/the_problem.md:35 #: src/generics/assoc_items/types.md:63 msgid "// Grab the last number.\n" msgstr "// 最後（2つめ）の値を取得。\n" #: src/generics/assoc_items/the_problem.md:38 msgid "" "// `C` contains `A` and `B`. In light of that, having to express `A` and\n" "// `B` again is a nuisance.\n" msgstr "" "// `A`と`B`は`C`に保持されていることを考慮すると、`A`と`B`を\n" "// ２度も書くのは面倒。\n" #: src/generics/assoc_items/the_problem.md:52 #: src/generics/assoc_items/types.md:77 msgid "\"Does container contain {} and {}: {}\"" msgstr "\"Does container contain {} and {}: {}\"" #: src/generics/assoc_items/the_problem.md:55 #: src/generics/assoc_items/types.md:80 msgid "\"First number: {}\"" msgstr "\"First number: {}\"" #: src/generics/assoc_items/the_problem.md:56 #: src/generics/assoc_items/types.md:81 msgid "\"Last number: {}\"" msgstr "\"Last number: {}\"" #: src/generics/assoc_items/the_problem.md:58 #: src/generics/assoc_items/types.md:83 msgid "\"The difference is: {}\"" msgstr "\"The difference is: {}\"" #: src/generics/assoc_items/the_problem.md:64 msgid "" "[`struct`s](../../custom_types/structs.md), and [`trait`s](../../trait.md)" msgstr "[構造体](../../custom_types/structs.md), [トレイト](../../trait.md)" #: src/generics/assoc_items/types.md:3 msgid "" "The use of \"Associated types\" improves the overall readability of code by " "moving inner types locally into a trait as _output_ types. Syntax for the " "`trait` definition is as follows:" msgstr "" "関連型を使用すると、コンテナ型の中の要素をトレイトの中に *出力型* として書く" "ことで、全体の可読性を上げることができます。トレイトを定義する際の構文は以下" "のようになります。" #: src/generics/assoc_items/types.md:8 msgid "" "// `A` and `B` are defined in the trait via the `type` keyword.\n" "// (Note: `type` in this context is different from `type` when used for\n" "// aliases).\n" msgstr "" "// `A`と`B`は`type`キーワードを用いてトレイト内で宣言されています。\n" "// （注意：この文脈で使用する`type`は型エイリアスを宣言する際の`type`とは\n" "// 異なることに注意しましょう。）\n" #: src/generics/assoc_items/types.md:15 msgid "// Updated syntax to refer to these new types generically.\n" msgstr "" "// これらの新しい型をジェネリックに使用するために、構文が\n" " // アップデートされています。\n" #: src/generics/assoc_items/types.md:20 msgid "" "Note that functions that use the `trait` `Contains` are no longer required " "to express `A` or `B` at all:" msgstr "" "`Contains`トレイトを使用する関数において、`A`と`B`を明示する必要がなくなって" "いることに注目しましょう。" #: src/generics/assoc_items/types.md:24 msgid "// Without using associated types\n" msgstr "// 関連型を使用しない場合\n" #: src/generics/assoc_items/types.md:27 msgid "// Using associated types\n" msgstr "// 使用する場合\n" #: src/generics/assoc_items/types.md:32 msgid "" "Let's rewrite the example from the previous section using associated types:" msgstr "前セクションの例を関連型を使用して書きなおしてみましょう。" #: src/generics/assoc_items/types.md:40 msgid "// Define generic types here which methods will be able to utilize.\n" msgstr "// メソッドが使用できるジェネリック型を定義。\n" #: src/generics/assoc_items/types.md:50 msgid "" "// Specify what types `A` and `B` are. If the `input` type\n" " // is `Container(i32, i32)`, the `output` types are determined\n" " // as `i32` and `i32`.\n" msgstr "" "// `A`と`B`がどの型であるかを明示。入力型（訳注：つまり`Self`の型）\n" " // が`Container(i32, i32)`である場合、出力型は`i32`と`i32`となります。\n" #: src/generics/assoc_items/types.md:56 msgid "// `&Self::A` and `&Self::B` are also valid here.\n" msgstr "// `&i32`の代わりに`&Self::A`または`&Self::B`と書いても構いません\n" #: src/generics/phantom.md:3 msgid "" "A phantom type parameter is one that doesn't show up at runtime, but is " "checked statically (and only) at compile time." msgstr "" "幽霊型とは実行時には存在しないけれども、コンパイル時に静的に型チェックされる" "ような型のことです。" #: src/generics/phantom.md:6 msgid "" "Data types can use extra generic type parameters to act as markers or to " "perform type checking at compile time. These extra parameters hold no " "storage values, and have no runtime behavior." msgstr "" "構造体などのデータ型は、ジェネリック型パラメータを一つ余分に持ち、それをマー" "カーとして使ったりコンパイル時の型検査に使ったりすることができます。このマー" "カーは実際の値を何も持たず、したがって実行時の挙動そのものにはいかなる影響も" "もたらしません。" #: src/generics/phantom.md:10 msgid "" "In the following example, we combine [std::marker::PhantomData](https://doc." "rust-lang.org/std/marker/struct.PhantomData.html) with the phantom type " "parameter concept to create tuples containing different data types." msgstr "" "以下の例では、そのようなマーカーとして幽霊型（[std::marker::PhantomData]" "(https://doc.rust-lang.org/std/marker/struct.PhantomData.html)）を用い、それ" "ぞれ異なった型の値を持つタプルを作成します。" #: src/generics/phantom.md:16 msgid "" "// A phantom tuple struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "// ジェネリックなタプル構造体。2つ目のパラメータは幽霊型。\n" #: src/generics/phantom.md:18 src/generics/phantom.md:22 msgid "// Allow equality test for this type.\n" msgstr "// 比較演算子（`==`）での比較を可能にします。\n" #: src/generics/phantom.md:20 msgid "" "// A phantom type struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "// 同様に構造体を定義。\n" #: src/generics/phantom.md:24 msgid "" "// Note: Storage is allocated for generic type `A`, but not for `B`.\n" "// Therefore, `B` cannot be used in computations.\n" msgstr "" "// 注意点: ジェネリック型Aに対してはメモリが割り当てられていますが、\n" "// Bには割り当てられていないため、計算に使うことはできません。\n" #: src/generics/phantom.md:29 msgid "" "// Here, `f32` and `f64` are the hidden parameters.\n" " // PhantomTuple type specified as ``.\n" msgstr "" "// ここで `f32` と `f64` は隠しパラメータです。\n" " // と型宣言されたPhantomTupleを作成。\n" #: src/generics/phantom.md:31 src/generics/phantom.md:33 #: src/generics/phantom.md:37 src/generics/phantom.md:42 #: src/scope/borrow/ref.md:12 msgid "'Q'" msgstr "'Q'" #: src/generics/phantom.md:32 msgid "// PhantomTuple type specified as ``.\n" msgstr "// と型宣言されたPhantomTupleを作成。\n" #: src/generics/phantom.md:35 msgid "// Type specified as ``.\n" msgstr "// の型が与えられた構造体を作成。\n" #: src/generics/phantom.md:40 msgid "// Type specified as ``.\n" msgstr "// 同様にの構造体\n" #: src/generics/phantom.md:46 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_tuple1 == _tuple2 yields: {}\",\n" " // _tuple1 == _tuple2);\n" msgstr "" "// コンパイルエラー！型が違うので比較することができません！\n" " // println!(\"_tuple1 == _tuple2 yields: {}\",\n" " // _tuple1 == _tuple2);\n" #: src/generics/phantom.md:50 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_struct1 == _struct2 yields: {}\",\n" " // _struct1 == _struct2);\n" msgstr "" "// コンパイルエラー! 型が違うので比較することができません!\n" " // println!(\"_struct1 == _struct2 yields: {}\",\n" " // _struct1 == _struct2);\n" #: src/generics/phantom.md:58 msgid "" "[Derive](../trait/derive.md), [struct](../custom_types/structs.md), and " "[TupleStructs](../custom_types/structs.md)" msgstr "" "[導出](../trait/derive.md), [構造体](../custom_types/structs.md), [タプル構造" "体](../custom_types/structs.md)" #: src/generics/phantom/testcase_units.md:3 msgid "" "A useful method of unit conversions can be examined by implementing `Add` " "with a phantom type parameter. The `Add` `trait` is examined below:" msgstr "" "共通の単位同士を扱う際のチェックのために、`Add`を幽霊型を用いた実装にすると便" "利な場合があります。その場合`Add`トレイトは以下のようになります。" #: src/generics/phantom/testcase_units.md:7 msgid "" "// This construction would impose: `Self + RHS = Output`\n" "// where RHS defaults to Self if not specified in the implementation.\n" msgstr "" "// このように定義しておくと、`Self + RHS = Output`であることが保証され、\n" "// かつ、impl時にRHSの型が明示されていない場合、デフォルトでSelfと同じに\n" "// なります。\n" #: src/generics/phantom/testcase_units.md:14 msgid "// `Output` must be `T` so that `T + T = T`.\n" msgstr "" "// `Output`は`T`でなくてはならないので`T + T = T`となります。\n" #: src/generics/phantom/testcase_units.md:22 msgid "The whole implementation:" msgstr "以下は全体を示した例です。" #: src/generics/phantom/testcase_units.md:27 msgid "/// Create void enumerations to define unit types.\n" msgstr "/// 単位を定義するため、空の列挙型を作成。\n" #: src/generics/phantom/testcase_units.md:33 msgid "" "/// `Length` is a type with phantom type parameter `Unit`,\n" "/// and is not generic over the length type (that is `f64`).\n" "///\n" "/// `f64` already implements the `Clone` and `Copy` traits.\n" msgstr "" "/// `Length`は`Unit`という幽霊型パラメータを持つ型ですが\n" "/// 長さを表す型はジェネリック型ではなく`f64`です。\n" "///\n" "/// `f64`ははじめから`Clone`、`Copy`トレイトを持っています。\n" #: src/generics/phantom/testcase_units.md:40 msgid "/// The `Add` trait defines the behavior of the `+` operator.\n" msgstr "/// `Add`トレイトは加算演算子(`+`)の挙動を定義します。\n" #: src/generics/phantom/testcase_units.md:45 msgid "// add() returns a new `Length` struct containing the sum.\n" msgstr "" "// add()は`Length`の新しいインスタンスを返します。\n" " // Lengthの中の値は合計値になっています。\n" #: src/generics/phantom/testcase_units.md:47 msgid "// `+` calls the `Add` implementation for `f64`.\n" msgstr "// ここでの`+`は`f64`の`Add`実装を呼び出します。\n" #: src/generics/phantom/testcase_units.md:53 msgid "// Specifies `one_foot` to have phantom type parameter `Inch`.\n" msgstr "// `one_foot`が幽霊型`Inch`を持つように明示します。\n" #: src/generics/phantom/testcase_units.md:55 msgid "// `one_meter` has phantom type parameter `Mm`.\n" msgstr "// `one_meter`が幽霊型`Mm`を持つように明示します。\n" #: src/generics/phantom/testcase_units.md:58 msgid "" "// `+` calls the `add()` method we implemented for `Length`.\n" " //\n" " // Since `Length` implements `Copy`, `add()` does not consume\n" " // `one_foot` and `one_meter` but copies them into `self` and `rhs`.\n" msgstr "" "// 以下の`+`は上で定義した`Length`用の`add()`メソッドを呼び出します。\n" " //\n" " // `Length`は`Copy`トレイトを持っているため、`add()`は`one_foot`と" "`one_meter`\n" " // を消費する代わりにそのコピーを作り、`self`、`rhs`として扱います。\n" #: src/generics/phantom/testcase_units.md:65 msgid "// Addition works.\n" msgstr "// 加算が問題なく実行されていることを確認。\n" #: src/generics/phantom/testcase_units.md:66 msgid "\"one foot + one_foot = {:?} in\"" msgstr "\"one foot + one_foot = {:?} in\"" #: src/generics/phantom/testcase_units.md:67 msgid "\"one meter + one_meter = {:?} mm\"" msgstr "\"one meter + one_meter = {:?} mm\"" #: src/generics/phantom/testcase_units.md:69 msgid "" "// Nonsensical operations fail as they should:\n" " // Compile-time Error: type mismatch.\n" " //let one_feter = one_foot + one_meter;\n" msgstr "" "// 異なる単位間の加算は意味を成さないので、\n" " // 以下はきちんとコンパイルエラーになります。\n" " // コンパイルエラー：タイプミスマッチ\n" " //let one_feter = one_foot + one_meter;\n" #: src/generics/phantom/testcase_units.md:77 msgid "" "[Borrowing (`&`)](../../scope/borrow.md), [Bounds (`X: Y`)](../../generics/" "bounds.md), [enum](../../custom_types/enum.md), [impl & self](../../fn/" "methods.md), [Overloading](../../trait/ops.md), [ref](../../scope/borrow/ref." "md), [Traits (`X for Y`)](../../trait.md), and [TupleStructs](../../" "custom_types/structs.md)." msgstr "" "[借用 (`&`)](../../scope/borrow.md), [境界 (`X: Y`)](../../generics/bounds." "md), [列挙型](../../custom_types/enum.md), [impl & self](../../fn/methods." "md), [演算子のオーバーロード](../../trait/ops.md), [ref](../../scope/borrow/" "ref.md), [トレイト (`X for Y`)](../../trait.md), [タプル構造体](../../" "custom_types/structs.md)." #: src/scope.md:3 msgid "" "Scopes play an important part in ownership, borrowing, and lifetimes. That " "is, they indicate to the compiler when borrows are valid, when resources can " "be freed, and when variables are created or destroyed." msgstr "" "所有権、借用、ライフタイムといったRustに特有の概念において、変数のスコープは" "重要な役割を果たします。すなわち、スコープの存在によってコンパイラは借用は可" "能か否か、メモリ上の資源は解放可能か、変数はいつ作成され、いつ破棄されるか。" "といったことを知るのです。" #: src/scope/raii.md:3 msgid "" "Variables in Rust do more than just hold data in the stack: they also _own_ " "resources, e.g. `Box` owns memory in the heap. Rust enforces [RAII]" "(https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) " "(Resource Acquisition Is Initialization), so whenever an object goes out of " "scope, its destructor is called and its owned resources are freed." msgstr "" "Rustの変数は単にデータをスタック上に保持するだけのものではありません。例えば" "ヒープメモリを確保する`Box`のように、変数はメモリ上の資源を *保有* する場" "合もあるのです。Rustは[RAII](https://en.wikipedia.org/wiki/" "Resource_Acquisition_Is_Initialization)(Resource Acquisition Is " "Initialization)を強制するので、オブジェクトがスコープを抜けると、必ずデストラ" "クタが呼び出されてそのオブジェクトが保持していた資源が解放されます。" #: src/scope/raii.md:8 msgid "" "This behavior shields against _resource leak_ bugs, so you'll never have to " "manually free memory or worry about memory leaks again! Here's a quick " "showcase:" msgstr "" "この振る舞いは *リソースリーク* バグを防ぐのに役立ちます。手動でメモリを解放" "したり、メモリリークバグにわずらわされたりすることはなくなるのです！簡単な例" "で説明しましょう。" #: src/scope/raii.md:12 msgid "// raii.rs\n" msgstr "// raii.rs\n" #: src/scope/raii.md:14 src/scope/raii.md:21 src/scope/raii.md:26 msgid "// Allocate an integer on the heap\n" msgstr "// 整数をヒープ上に確保。\n" #: src/scope/raii.md:17 msgid "// `_box1` is destroyed here, and memory gets freed\n" msgstr "// `_box1`はここで破棄され、メモリは解放されます。\n" #: src/scope/raii.md:24 msgid "// A nested scope:\n" msgstr "// ネストしたスコープ\n" #: src/scope/raii.md:29 msgid "// `_box3` is destroyed here, and memory gets freed\n" msgstr "// `_box3`はここで破棄され、メモリは解放されます。\n" #: src/scope/raii.md:32 msgid "" "// Creating lots of boxes just for fun\n" " // There's no need to manually free memory!\n" msgstr "" "// お遊びで大量のボックスを作ります。\n" " // もちろん手動で開放する必要はないよ！\n" #: src/scope/raii.md:38 msgid "// `_box2` is destroyed here, and memory gets freed\n" msgstr "// `_box2`はここで破棄され、メモリは解放されます。\n" #: src/scope/raii.md:42 msgid "" "Of course, we can double check for memory errors using [`valgrind`](http://" "valgrind.org/info/):" msgstr "" "[`valgrind`](http://valgrind.org/info/)を用いて、メモリエラーが起きていないか" "2重チェックすることももちろん可能です。" #: src/scope/raii.md:65 msgid "No leaks here!" msgstr "リークはないみたいですね！" #: src/scope/raii.md:67 msgid "Destructor" msgstr "デストラクタ" #: src/scope/raii.md:69 msgid "" "The notion of a destructor in Rust is provided through the [`Drop`](https://" "doc.rust-lang.org/std/ops/trait.Drop.html) trait. The destructor is called " "when the resource goes out of scope. This trait is not required to be " "implemented for every type, only implement it for your type if you require " "its own destructor logic." msgstr "" "Rustにおけるデストラクタの概念は[`Drop`](https://doc.rust-lang.org/std/ops/" "trait.Drop.html)トレイトによって提供されています。デストラクタは資源がスコー" "プを抜けるときに呼び出されます。`Drop`トレイトは型定義のたびに必ず実装する必" "要があるわけではなく、デストラクタに独自のロジックが必要な場合にのみ実装しま" "す。" #: src/scope/raii.md:74 msgid "" "Run the below example to see how the [`Drop`](https://doc.rust-lang.org/std/" "ops/trait.Drop.html) trait works. When the variable in the `main` function " "goes out of scope the custom destructor will be invoked." msgstr "" "下のコードを実行して、[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop." "html)トレイトの動作を確認してみましょう。`main`関数内の変数がスコープを抜ける" "ときにカスタムデストラクタが呼び出されるはずです。" #: src/scope/raii.md:82 msgid "\"ToDrop is being dropped\"" msgstr "\"ToDrop is being dropped\"" #: src/scope/raii.md:88 msgid "\"Made a ToDrop!\"" msgstr "\"Made a ToDrop!\"" #: src/scope/raii.md:94 msgid "[Box](../std/box.md)" msgstr "[Box](../std/box.md)" #: src/scope/move.md:3 msgid "" "Because variables are in charge of freeing their own resources, **resources " "can only have one owner**. This prevents resources from being freed more " "than once. Note that not all variables own resources (e.g. [references](../" "flow_control/match/destructuring/destructure_pointers.md))." msgstr "" "変数には自身の保持する資源を開放する責任があるため、**資源は一度に一つの所有" "者** しか持つことができません。これはまた、資源を2度以上開放することができな" "いということでもあります。ここで、全ての変数が資源を所有するわけではないとい" "うことに注意しましょう。（e.g. [参照](../flow_control/match/destructuring/" "destructure_pointers.md)）" #: src/scope/move.md:8 msgid "" "When doing assignments (`let x = y`) or passing function arguments by value " "(`foo(x)`), the _ownership_ of the resources is transferred. In Rust-speak, " "this is known as a _move_." msgstr "" "変数を代入する（`let x = y`）際や、関数に引数を値渡しする（`foo(x)`）際は、資" "源の *所有権* が移動します。Rustっぽく言うと、「 *ムーブ* 」です。" #: src/scope/move.md:12 msgid "" "After moving resources, the previous owner can no longer be used. This " "avoids creating dangling pointers." msgstr "" "資源を移動すると、それまでの所有者（訳注：変数などのこと）を使用することはで" "きなくなります。これによりダングリングポインタの発生を防げます。" #: src/scope/move.md:16 msgid "// This function takes ownership of the heap allocated memory\n" msgstr "// この関数はヒープメモリ上の資源の所有権を取ります。\n" #: src/scope/move.md:18 msgid "\"Destroying a box that contains {}\"" msgstr "\"Destroying a box that contains {}\"" #: src/scope/move.md:20 msgid "// `c` is destroyed and the memory freed\n" msgstr "// `c`は破棄されメモリは開放されます。\n" #: src/scope/move.md:24 msgid "// _Stack_ allocated integer\n" msgstr "// _スタック_上に置かれた整数\n" #: src/scope/move.md:27 msgid "// *Copy* `x` into `y` - no resources are moved\n" msgstr "// `x`を`y`に *コピー* します。元の値が移動するわけではありません。\n" #: src/scope/move.md:30 msgid "// Both values can be independently used\n" msgstr "// 両方の値はそれぞれ独立に使うことができます。\n" #: src/scope/move.md:31 msgid "\"x is {}, and y is {}\"" msgstr "\"x is {}, and y is {}\"" #: src/scope/move.md:33 msgid "// `a` is a pointer to a _heap_ allocated integer\n" msgstr "// `a`は_ヒープ_上の整数へのポインタ。\n" #: src/scope/move.md:36 msgid "\"a contains: {}\"" msgstr "\"a contains: {}\"" #: src/scope/move.md:38 msgid "// *Move* `a` into `b`\n" msgstr "// `a`を`b`に *ムーブ* します。\n" #: src/scope/move.md:40 msgid "" "// The pointer address of `a` is copied (not the data) into `b`.\n" " // Both are now pointers to the same heap allocated data, but\n" " // `b` now owns it.\n" msgstr "" "// すなわち、`a`の指すメモリ上の番地が`b`にコピーされるため\n" " // いずれもヒープ上の同じ値を指すポインタとなります。\n" " // しかし所有権は`b`にあります。\n" #: src/scope/move.md:44 msgid "" "// Error! `a` can no longer access the data, because it no longer owns the\n" " // heap memory\n" " //println!(\"a contains: {}\", a);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`a`は所有権を持たないため、ヒープ上のデータにアクセスできませ" "ん。\n" " //println!(\"a contains: {}\", a);\n" " // TODO ^ 試しにここをアンコメントしてみましょう。\n" #: src/scope/move.md:49 msgid "" "// This function takes ownership of the heap allocated memory from `b`\n" msgstr "// この関数はヒープメモリ上の所有権を`b`から取ります。\n" #: src/scope/move.md:52 msgid "" "// Since the heap memory has been freed at this point, this action would\n" " // result in dereferencing freed memory, but it's forbidden by the " "compiler\n" " // Error! Same reason as the previous Error\n" " //println!(\"b contains: {}\", b);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// この時点でヒープメモリ上の資源は開放されているので、次の操作は\n" " // 解放済みメモリをデリファレンスすることになります。\n" " // しかしそれはコンパイラが許しません。\n" " // エラー！上述の理由より\n" " //println!(\"b contains: {}\", b);\n" " // TODO ^ 試しにここをアンコメントしてみましょう。\n" #: src/scope/move/mut.md:3 msgid "Mutability of data can be changed when ownership is transferred." msgstr "データのミュータビリティは所有権を移譲した際に変更できます。" #: src/scope/move/mut.md:9 msgid "\"immutable_box contains {}\"" msgstr "\"immutable_box contains {}\"" #: src/scope/move/mut.md:11 msgid "" "// Mutability error\n" " //*immutable_box = 4;\n" msgstr "" "// ミュータビリティエラー\n" " //*immutable_box = 4;\n" #: src/scope/move/mut.md:14 msgid "// *Move* the box, changing the ownership (and mutability)\n" msgstr "// boxを *ムーブ* する、同時に所有権とミュータビリティを変更します。\n" #: src/scope/move/mut.md:17 msgid "\"mutable_box contains {}\"" msgstr "\"mutable_box contains {}\"" #: src/scope/move/mut.md:19 msgid "// Modify the contents of the box\n" msgstr "// boxの内容を変更。\n" #: src/scope/move/mut.md:22 msgid "\"mutable_box now contains {}\"" msgstr "\"mutable_box now contains {}\"" #: src/scope/move/partial_move.md:3 msgid "" "Within the [destructuring](../../flow_control/match/destructuring.md) of a " "single variable, both `by-move` and `by-reference` pattern bindings can be " "used at the same time. Doing this will result in a _partial move_ of the " "variable, which means that parts of the variable will be moved while other " "parts stay. In such a case, the parent variable cannot be used afterwards as " "a whole, however the parts that are only referenced (and not moved) can " "still be used." msgstr "" "1つの変数の [デストラクト](../../flow_control/match/destructuring.md) の中" "で、`ムーブ` と `参照` の両方のパターン束縛を同時に使用することができます。両" "方を使用すると、変数の一部がムーブされ、他の部分が参照として残るという変数の" "部分的ムーブが発生した状態になります。変数の部分的ムーブが発生すると親変数は" "その後使用できませんが、参照されているだけの部分（ムーブされていない部分）は" "使用することができます。" #: src/scope/move/partial_move.md:24 msgid "// `name` is moved out of person, but `age` is referenced\n" msgstr "// `name` は person からムーブしたが、 `age` は参照されています。\n" #: src/scope/move/partial_move.md:27 msgid "\"The person's age is {}\"" msgstr "\"The person's age is {}\"" #: src/scope/move/partial_move.md:29 msgid "\"The person's name is {}\"" msgstr "\"The person's name is {}\"" #: src/scope/move/partial_move.md:31 msgid "" "// Error! borrow of partially moved value: `person` partial move occurs\n" " //println!(\"The person struct is {:?}\", person);\n" msgstr "" "// エラー！部分的ムーブした値の借用：`person` では部分的ムーブが発生していま" "す。\n" " //println!(\"The person struct is {:?}\", person);\n" #: src/scope/move/partial_move.md:34 msgid "" "// `person` cannot be used but `person.age` can be used as it is not moved\n" msgstr "" "// `person` は使用できませんが、\n" " // `person.age` はムーブしていないので使用できます。\n" #: src/scope/move/partial_move.md:35 msgid "\"The person's age from person struct is {}\"" msgstr "\"The person's age from person struct is {}\"" #: src/scope/move/partial_move.md:38 msgid "" "(In this example, we store the `age` variable on the heap to illustrate the " "partial move: deleting `ref` in the above code would give an error as the " "ownership of `person.age` would be moved to the variable `age`. If `Person." "age` were stored on the stack, `ref` would not be required as the definition " "of `age` would copy the data from `person.age` without moving it.)" msgstr "" "この例では、`age`変数をヒープ上に保持し、部分的ムーブを説明しています。上記" "コードで`ref`を削除すると、`person.age`の所有権が`age`変数にムーブされるた" "め、エラーになります。もしも`Person.age`がスタック上に保持されていたら、`age`" "の定義が`person.age`をムーブすることなくデータをコピーするので、`ref`は必須で" "はないのですが、実際にはヒープ上に保持されているため`ref`は必須です。" #: src/scope/move/partial_move.md:46 msgid "[destructuring](../../flow_control/match/destructuring.md)" msgstr "[デストラクト](../../flow_control/match/destructuring.md)" #: src/scope/borrow.md:3 msgid "" "Most of the time, we'd like to access data without taking ownership over it. " "To accomplish this, Rust uses a _borrowing_ mechanism. Instead of passing " "objects by value (`T`), objects can be passed by reference (`&T`)." msgstr "" "実際には、データの所有権を完全に受け渡すことなく一時的にアクセスしたいという" "場合がほとんどです。そのために、Rustでは *借用* という仕組みを用います。値そ" "のもの（`T`）を受け渡すのではなく、その参照（`&T`）を渡すのです。" #: src/scope/borrow.md:7 msgid "" "The compiler statically guarantees (via its borrow checker) that references " "_always_ point to valid objects. That is, while references to an object " "exist, the object cannot be destroyed." msgstr "" "コンパイラは借用チェッカを用いて参照が *常に* 有効なオブジェクトへの参照であ" "ることを、コンパイル時に保証します。つまり、あるオブジェクトへの参照が存在し" "ているならば、そのオブジェクトを破壊することはできないということです。" #: src/scope/borrow.md:12 msgid "// This function takes ownership of a box and destroys it\n" msgstr "// この関数はボックスの所有権を奪い、破棄します。\n" #: src/scope/borrow.md:14 msgid "\"Destroying box that contains {}\"" msgstr "\"Destroying box that contains {}\"" #: src/scope/borrow.md:16 msgid "// This function borrows an i32\n" msgstr "// この関数はi32を借用します。\n" #: src/scope/borrow.md:19 msgid "\"This int is: {}\"" msgstr "\"This int is: {}\"" #: src/scope/borrow.md:23 msgid "" "// Create a boxed i32 in the heap, and a i32 on the stack\n" " // Remember: numbers can have arbitrary underscores added for " "readability\n" " // 5_i32 is the same as 5i32\n" msgstr "" #: src/scope/borrow.md:29 msgid "" "// Borrow the contents of the box. Ownership is not taken,\n" " // so the contents can be borrowed again.\n" msgstr "" "// Boxの中身を借用。所有権を奪うわけではないため、\n" " // 直後にもう一度借用できます。\n" #: src/scope/borrow.md:35 msgid "// Take a reference to the data contained inside the box\n" msgstr "// ボックス内の要素に対する参照を取得。\n" #: src/scope/borrow.md:38 msgid "" "// Error!\n" " // Can't destroy `boxed_i32` while the inner value is borrowed later " "in scope.\n" msgstr "" "// エラー!\n" " // ボックス内の要素が借用されているため、`boxed_i32`を破棄する\n" " // ことはできません。\n" #: src/scope/borrow.md:43 msgid "// Attempt to borrow `_ref_to_i32` after inner value is destroyed\n" msgstr "" #: src/scope/borrow.md:45 msgid "// `_ref_to_i32` goes out of scope and is no longer borrowed.\n" msgstr "// ここで`_ref_to_i32`はスコープを抜け、借用もなくなります。\n" #: src/scope/borrow.md:48 msgid "" "// `boxed_i32` can now give up ownership to `eat_box_32` and be destroyed\n" msgstr "" "// ここでようやく、`boxed_i32`は所有権を`eat_box_32`に移譲し、破棄することが" "できます。\n" #: src/scope/borrow/mut.md:3 msgid "" "Mutable data can be mutably borrowed using `&mut T`. This is called a " "_mutable reference_ and gives read/write access to the borrower. In " "contrast, `&T` borrows the data via an immutable reference, and the borrower " "can read the data but not modify it:" msgstr "" "ミュータブルなデータは`&mut T`でミュータブルに（変更可能な形で）借用すること" "ができます。これは *ミュータブルな参照* と呼ばれ、読み込み・書き込みの権限を" "借用者に与えます。対照的に`&T`はデータをイミュータブルな参照を介して借用し、" "借用した側はデータを読み込みはできますが書き込みはできません。" #: src/scope/borrow/mut.md:12 msgid "" "// `&'static str` is a reference to a string allocated in read only memory\n" msgstr "// `&'static str`はread-onlyメモリ上の文字列への参照。\n" #: src/scope/borrow/mut.md:17 msgid "// This function takes a reference to a book\n" msgstr "// この関数はBook型への参照を取ります。\n" #: src/scope/borrow/mut.md:20 msgid "\"I immutably borrowed {} - {} edition\"" msgstr "\"I immutably borrowed {} - {} edition\"" #: src/scope/borrow/mut.md:22 msgid "" "// This function takes a reference to a mutable book and changes `year` to " "2014\n" msgstr "" "// この関数はミュータブルなBook型へのミュータブルな参照を取り、\n" "// `year`を2014へ変更します。\n" #: src/scope/borrow/mut.md:26 msgid "\"I mutably borrowed {} - {} edition\"" msgstr "\"I mutably borrowed {} - {} edition\"" #: src/scope/borrow/mut.md:30 msgid "// Create an immutable Book named `immutabook`\n" msgstr "// `immutabook`という名のイミュータブルなBookを作成。\n" #: src/scope/borrow/mut.md:32 msgid "// string literals have type `&'static str`\n" msgstr "// 文字列リテラルは`&'static str`型になります。\n" #: src/scope/borrow/mut.md:33 msgid "\"Douglas Hofstadter\"" msgstr "\"Douglas Hofstadter\"" #: src/scope/borrow/mut.md:34 msgid "\"Gödel, Escher, Bach\"" msgstr "\"Gödel, Escher, Bach\"" #: src/scope/borrow/mut.md:38 msgid "// Create a mutable copy of `immutabook` and call it `mutabook`\n" msgstr "" "// `immutabook`のミュータブルなコピーを作成し、`mutabook`と名付けます。\n" #: src/scope/borrow/mut.md:41 msgid "// Immutably borrow an immutable object\n" msgstr "// イミュータブルなオブジェクトをイミュータブルに借用します。\n" #: src/scope/borrow/mut.md:44 msgid "// Immutably borrow a mutable object\n" msgstr "// ミュータブルなオブジェクトをイミュータブルに借用します。\n" #: src/scope/borrow/mut.md:47 msgid "// Borrow a mutable object as mutable\n" msgstr "// ミュータブルなオブジェクトをミュータブルに借用します。\n" #: src/scope/borrow/mut.md:50 msgid "// Error! Cannot borrow an immutable object as mutable\n" msgstr "" "// エラー！イミュータブルなオブジェクトをミュータブルに借用できません。\n" #: src/scope/borrow/mut.md:57 msgid "[`static`](../lifetime/static_lifetime.md)" msgstr "[`static`](../lifetime/static_lifetime.md)" #: src/scope/borrow/alias.md:3 msgid "" "Data can be immutably borrowed any number of times, but while immutably " "borrowed, the original data can't be mutably borrowed. On the other hand, " "only _one_ mutable borrow is allowed at a time. The original data can be " "borrowed again only _after_ the mutable reference has been used for the last " "time." msgstr "" "データは一度にいくつでもイミュータブルに借用することができますが、その間オリ" "ジナルのデータをミュータブルに借用することはできません。一方でミュータブルな" "借用は一度に *一つ* しか借用することができません。オリジナルのデータをもう一" "度借用できるのはミュータブルな参照が最後に使われた場所より *あとで* なければ" "いけません。" #: src/scope/borrow/alias.md:17 msgid "// Data can be accessed via the references and the original owner\n" msgstr "// データは元々の持ち主と参照の両方からアクセスすることができます。\n" #: src/scope/borrow/alias.md:18 src/scope/borrow/alias.md:27 #: src/scope/borrow/alias.md:49 msgid "\"Point has coordinates: ({}, {}, {})\"" msgstr "\"Point has coordinates: ({}, {}, {})\"" #: src/scope/borrow/alias.md:21 msgid "" "// Error! Can't borrow `point` as mutable because it's currently\n" " // borrowed as immutable.\n" " // let mutable_borrow = &mut point;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！pointはすでにイミュータブルに借用されているため、\n" " // ミュータブルに借用することができません。\n" " // let mutable_borrow = &mut point;\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/scope/borrow/alias.md:26 msgid "// The borrowed values are used again here\n" msgstr "// 借用された値はここで再び利用されます。\n" #: src/scope/borrow/alias.md:30 msgid "" "// The immutable references are no longer used for the rest of the code so\n" " // it is possible to reborrow with a mutable reference.\n" msgstr "" "// イミュータブルな参照がこれ以降のコードで利用されていないため、\n" " // ミュータブルな参照として再借用できます。\n" #: src/scope/borrow/alias.md:34 msgid "// Change data via mutable reference\n" msgstr "// ミュータブルな参照を介してデータを変更します。\n" #: src/scope/borrow/alias.md:39 msgid "" "// Error! Can't borrow `point` as immutable because it's currently\n" " // borrowed as mutable.\n" " // let y = &point.y;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`point`はすでにミュータブルに借用されているため、\n" " // イミュータブルに借用することはできません。\n" " // let y = &point.y;\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/scope/borrow/alias.md:44 msgid "" "// Error! Can't print because `println!` takes an immutable reference.\n" " // println!(\"Point Z coordinate is {}\", point.z);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`println!`はイミュータブルな参照を取るため、printできません。\n" " // println!(\"Point Z coordinate is {}\", point.z);\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/scope/borrow/alias.md:48 msgid "// Ok! Mutable references can be passed as immutable to `println!`\n" msgstr "" "// OK！ミュータブルな参照は`println!`にイミュータブルな参照として渡せます。\n" #: src/scope/borrow/alias.md:52 msgid "" "// The mutable reference is no longer used for the rest of the code so it\n" " // is possible to reborrow\n" msgstr "" "// ミュータブルな参照がこれ以降のコードで未使用なので、再借用できます。\n" #: src/scope/borrow/alias.md:55 msgid "\"Point now has coordinates: ({}, {}, {})\"" msgstr "\"Point now has coordinates: ({}, {}, {})\"" #: src/scope/borrow/ref.md:3 msgid "" "When doing pattern matching or destructuring via the `let` binding, the " "`ref` keyword can be used to take references to the fields of a struct/" "tuple. The example below shows a few instances where this can be useful:" msgstr "" "`let`を介してデストラクトやパターンマッチングを行う場合、`ref`キーワードを用" "いて構造体・タプルのフィールドへの参照を取得することができます。以下の例では" "これが有用になる例を幾つかお見せします。" #: src/scope/borrow/ref.md:14 msgid "" "// A `ref` borrow on the left side of an assignment is equivalent to\n" " // an `&` borrow on the right side.\n" msgstr "" "// 左辺に`ref`をつけることによる借用と、右辺に`&`をつけることによる借用は等" "価。\n" #: src/scope/borrow/ref.md:19 msgid "\"ref_c1 equals ref_c2: {}\"" msgstr "\"ref_c1 equals ref_c2: {}\"" #: src/scope/borrow/ref.md:23 msgid "// `ref` is also valid when destructuring a struct.\n" msgstr "// `ref`は構造体をデストラクトする際にも有用。\n" #: src/scope/borrow/ref.md:25 msgid "// `ref_to_x` is a reference to the `x` field of `point`.\n" msgstr "// `ref_to_x`は`point`の`x`フィールドへの参照。\n" #: src/scope/borrow/ref.md:28 msgid "// Return a copy of the `x` field of `point`.\n" msgstr "// `point`の`x`フィールドへのコピーを返します。\n" #: src/scope/borrow/ref.md:32 msgid "// A mutable copy of `point`\n" msgstr "// `point`へのミュータブルなコピー\n" #: src/scope/borrow/ref.md:36 msgid "// `ref` can be paired with `mut` to take mutable references.\n" msgstr "" "// `ref`は`mut`とともに使い、ミュータブルな参照を取ることもできます。\n" #: src/scope/borrow/ref.md:39 msgid "// Mutate the `y` field of `mutable_point` via a mutable reference.\n" msgstr "" "// `mutable_point`の`y`というミュータブルなフィールドの値を変更します。\n" #: src/scope/borrow/ref.md:43 msgid "\"point is ({}, {})\"" msgstr "\"point is ({}, {})\"" #: src/scope/borrow/ref.md:44 msgid "\"mutable_point is ({}, {})\"" msgstr "\"mutable_point is ({}, {})\"" #: src/scope/borrow/ref.md:46 msgid "// A mutable tuple that includes a pointer\n" msgstr "// ポインタを含むミュータブルなタプル\n" #: src/scope/borrow/ref.md:50 msgid "// Destructure `mutable_tuple` to change the value of `last`.\n" msgstr "// `mutable_tuple`をデストラクトして、`last`の値を変更。\n" #: src/scope/borrow/ref.md:55 msgid "\"tuple is {:?}\"" msgstr "\"tuple is {:?}\"" #: src/scope/lifetime.md:3 msgid "" "A _lifetime_ is a construct the compiler (or more specifically, its _borrow " "checker_) uses to ensure all borrows are valid. Specifically, a variable's " "lifetime begins when it is created and ends when it is destroyed. While " "lifetimes and scopes are often referred to together, they are not the same." msgstr "" "*ライフタイム* はコンパイラ（借用チェッカーと呼ばれる場合もあります）が、全て" "の借用に問題がないことを確認するために使用する仕組みです。正確にいうと、変数" "のライフタイムは作成時に開始し、破棄された時に終了します。ライフタイムとス" "コープは同時に語られることが多いですが、同じものではありません。" #: src/scope/lifetime.md:8 msgid "" "Take, for example, the case where we borrow a variable via `&`. The borrow " "has a lifetime that is determined by where it is declared. As a result, the " "borrow is valid as long as it ends before the lender is destroyed. However, " "the scope of the borrow is determined by where the reference is used." msgstr "" "例として`&`を用いて変数を借用する場合をあげましょう。借用のライフタイムは宣言" "時に決定し、そこから貸し手が破棄されるまで続きます。しかしながら、借用のス" "コープは参照が使われる際に決定します。" #: src/scope/lifetime.md:13 msgid "" "In the following example and in the rest of this section, we will see how " "lifetimes relate to scopes, as well as how the two differ." msgstr "" "以下の例からこのセクションの残りでは、ライフタイムとスコープの関係、そしてそ" "れらがいかに異なるものであるかを見ていきます。" #: src/scope/lifetime.md:17 msgid "" "// Lifetimes are annotated below with lines denoting the creation\n" "// and destruction of each variable.\n" "// `i` has the longest lifetime because its scope entirely encloses \n" "// both `borrow1` and `borrow2`. The duration of `borrow1` compared \n" "// to `borrow2` is irrelevant since they are disjoint.\n" msgstr "" "// 以下では、変数の作成から破棄までのライフタイムを線で示しています。\n" "// `i`は最長のライフタイムを持ち、そのスコープは`borrow1`および`borrow2`\n" "// のスコープを完全に包含します。\n" "// `borrow1`と`borrow2`の存続期間は一切重なりません。\n" #: src/scope/lifetime.md:23 msgid "" "// Lifetime for `i` starts. ────────────────┐\n" " // │\n" msgstr "" "// `i`のライフタイム開始 ───────────────────┐\n" " // │\n" #: src/scope/lifetime.md:25 src/scope/lifetime.md:32 msgid "// │\n" msgstr "// │\n" #: src/scope/lifetime.md:26 msgid "" "// `borrow1` lifetime starts. ──┐│\n" " // ││\n" msgstr "" "// `borrow1`のライフタイム開始──┐│\n" " // ││\n" #: src/scope/lifetime.md:28 msgid "\"borrow1: {}\"" msgstr "\"borrow1: {}\"" #: src/scope/lifetime.md:28 src/scope/lifetime.md:35 msgid "// ││\n" msgstr "// ││\n" #: src/scope/lifetime.md:29 msgid "" "// `borrow1` ends. ─────────────────────────────────┘│\n" " // │\n" " // │\n" msgstr "" "// `borrow1` 終了 ──────────────────────────────────┘│\n" " // │\n" " // │\n" #: src/scope/lifetime.md:33 msgid "" "// `borrow2` lifetime starts. ──┐│\n" " // ││\n" msgstr "" "// `borrow2`のライフタイム開始──┐│\n" " // ││\n" #: src/scope/lifetime.md:35 msgid "\"borrow2: {}\"" msgstr "\"borrow2: {}\"" #: src/scope/lifetime.md:36 msgid "" "// `borrow2` ends. ─────────────────────────────────┘│\n" " // │\n" msgstr "" "// `borrow2` 終了 ──────────────────────────────────┘│\n" " // │\n" #: src/scope/lifetime.md:38 msgid "// Lifetime ends. ─────────────────────────────────────┘\n" msgstr "// ライフタイム終了 ───────────────────────────────────┘\n" #: src/scope/lifetime.md:41 msgid "" "Note that no names or types are assigned to label lifetimes. This restricts " "how lifetimes will be able to be used as we will see." msgstr "" "ここで、一切の名前や型がライフタイムに代入されていないことに注意しましょう。" "これにより、ライフタイムの使われ方がこれから見ていくようなやり方に制限されま" "す。" #: src/scope/lifetime/explicit.md:3 msgid "" "The borrow checker uses explicit lifetime annotations to determine how long " "references should be valid. In cases where lifetimes are not elided[^1], " "Rust requires explicit annotations to determine what the lifetime of a " "reference should be. The syntax for explicitly annotating a lifetime uses an " "apostrophe character as follows:" msgstr "" "借用チェッカーは参照がどれだけの間有効かを決定するために、明示的なアノテー" "ションを使用します。ライフタイムが省略[^1]されなかった場合、Rustは参照のライ" "フタイムがどのようなものであるか、明示的なアノテーションを必要とします。" #: src/scope/lifetime/explicit.md:10 msgid "// `foo` has a lifetime parameter `'a`\n" msgstr "// `foo`は`'a`というライフタイムパラメータを持ちます。\n" #: src/scope/lifetime/explicit.md:14 msgid "" "Similar to [closures](../../fn/closures/anonymity.md), using lifetimes " "requires generics. Additionally, this lifetime syntax indicates that the " "lifetime of `foo` may not exceed that of `'a`. Explicit annotation of a type " "has the form `&'a T` where `'a` has already been introduced." msgstr "" "[クロージャ](../../fn/closures/anonymity.md)と同様、ライフタイムの使用はジェ" "ネリクスを必要とします。もう少し詳しく言うと、この書き方は「`foo`のライフタイ" "ムは`'a`のそれを超えることはない。」ということを示しており、型を明示した場合" "`'a`は`&'a T`となるということです。" #: src/scope/lifetime/explicit.md:19 msgid "In cases with multiple lifetimes, the syntax is similar:" msgstr "ライフタイムが複数ある場合も、同じような構文になります。" #: src/scope/lifetime/explicit.md:22 msgid "// `foo` has lifetime parameters `'a` and `'b`\n" msgstr "// `foo`は`'a`と`'b`というライフタイムパラメータを持ちます。\n" #: src/scope/lifetime/explicit.md:26 msgid "" "In this case, the lifetime of `foo` cannot exceed that of either `'a` _or_ " "`'b`." msgstr "" "この場合は、`foo`のライフタイムは`'a`、`'b`の *いずれよりも* 長くなってはなり" "ません。" #: src/scope/lifetime/explicit.md:28 msgid "See the following example for explicit lifetime annotation in use:" msgstr "以下はライフタイムを明示的に書く場合の例です。" #: src/scope/lifetime/explicit.md:31 msgid "" "// `print_refs` takes two references to `i32` which have different\n" "// lifetimes `'a` and `'b`. These two lifetimes must both be at\n" "// least as long as the function `print_refs`.\n" msgstr "" "// `print_refs`は`i32`への参照を2つとり、それぞれ`'a`と`'b`という\n" "// ライフタイムを持ちます。これらのライフタイムは最短でも`print_refs`\n" "// 関数と同じになります。\n" #: src/scope/lifetime/explicit.md:35 msgid "\"x is {} and y is {}\"" msgstr "\"x is {} and y is {}\"" #: src/scope/lifetime/explicit.md:37 msgid "" "// A function which takes no arguments, but has a lifetime parameter `'a`.\n" msgstr "// 引数を取らないがライフタイムパラメータ`'a`を持つ関数\n" #: src/scope/lifetime/explicit.md:42 msgid "// ERROR: `_x` does not live long enough\n" msgstr "// エラー：`_x`の寿命が短すぎる。\n" #: src/scope/lifetime/explicit.md:44 msgid "" "// Attempting to use the lifetime `'a` as an explicit type annotation \n" " // inside the function will fail because the lifetime of `&_x` is " "shorter\n" " // than that of `_y`. A short lifetime cannot be coerced into a longer " "one.\n" msgstr "" "// `&_x`のライフタイムは`y`のそれよりも短いため、関数内で`'a`を使用して\n" " // 変数のライフタイムを指定しようとすると失敗します。つまり、短いライフタ" "イム\n" " // を持つ参照をより長いものに強制的に代入することはできません。\n" #: src/scope/lifetime/explicit.md:50 msgid "// Create variables to be borrowed below.\n" msgstr "// 下で借用するための変数を作成。\n" #: src/scope/lifetime/explicit.md:53 msgid "// Borrows (`&`) of both variables are passed into the function.\n" msgstr "// 2つの変数の借用（`&`）が関数に渡されます。\n" #: src/scope/lifetime/explicit.md:55 msgid "" "// Any input which is borrowed must outlive the borrower. \n" " // In other words, the lifetime of `four` and `nine` must \n" " // be longer than that of `print_refs`.\n" msgstr "" "// 借用された変数の寿命は、借り手のそれよりも長くなくてはなりません。\n" " // つまり、`four`、`nine`のライフタイムは`print_refs`のそれよりも\n" " // 長くなくてはなりません。\n" #: src/scope/lifetime/explicit.md:60 msgid "" "// `failed_borrow` contains no references to force `'a` to be \n" " // longer than the lifetime of the function, but `'a` is longer.\n" " // Because the lifetime is never constrained, it defaults to `'static`.\n" msgstr "" "// `failed_borrow`は関数のライフタイムよりも`'a`を長くさせるような\n" " // 参照を持ちませんが、それでも`'a`のほうが長くなります。なぜならそのよう" "な\n" " // 場合`'a`はデフォルトで`'static`になるからです。\n" #: src/scope/lifetime/explicit.md:66 msgid "" "[elision](elision.md) implicitly annotates lifetimes and so is different." msgstr "" "[省略](elision.md) はライフタイムが暗黙のうちに（プログラマから見えない形で）" "アノテートされることを指します。" #: src/scope/lifetime/explicit.md:70 msgid "[generics](../../generics.md) and [closures](../../fn/closures.md)" msgstr "[ジェネリクス](../../generics.md), [クロージャ](../../fn/closures.md)" #: src/scope/lifetime/fn.md:3 msgid "" "Ignoring [elision](elision.md), function signatures with lifetimes have a " "few constraints:" msgstr "" "[省略](elision.md)をしない場合、ライフタイムのシグネチャ（e.g. `<'a>`）を持つ" "関数にはいくつかの制限があります。" #: src/scope/lifetime/fn.md:5 msgid "any reference _must_ have an annotated lifetime." msgstr "全ての参照においてライフタイムを明示しなくてはなりません。" #: src/scope/lifetime/fn.md:6 msgid "" "any reference being returned _must_ have the same lifetime as an input or be " "`static`." msgstr "" "返り値となる参照はすべて引数と同じライフタイムか、`static`ライフタイムを持た" "なくてはなりません" #: src/scope/lifetime/fn.md:9 msgid "" "Additionally, note that returning references without input is banned if it " "would result in returning references to invalid data. The following example " "shows off some valid forms of functions with lifetimes:" msgstr "" "加えて、引数のない関数から参照を返すことは、それが結果的に無効なデータへの参" "照になるならば、禁止されています。ライフタイムを持つ関数の例をいくつか示しま" "す。" #: src/scope/lifetime/fn.md:14 msgid "" "// One input reference with lifetime `'a` which must live\n" "// at least as long as the function.\n" msgstr "" "// 引数として`'a`のライフタイムで参照を一つ取ります。最低でもこの関数\n" "// と同じだけの長さでなくてはなりません。\n" #: src/scope/lifetime/fn.md:17 msgid "\"`print_one`: x is {}\"" msgstr "\"`print_one`: x is {}\"" #: src/scope/lifetime/fn.md:19 msgid "// Mutable references are possible with lifetimes as well.\n" msgstr "// ミュータブルな参照でも同様。\n" #: src/scope/lifetime/fn.md:24 msgid "" "// Multiple elements with different lifetimes. In this case, it\n" "// would be fine for both to have the same lifetime `'a`, but\n" "// in more complex cases, different lifetimes may be required.\n" msgstr "" "// 異なるライフタイムを持つ複数の引数がある場合。\n" "// ここでは1種類のライフタイムでも問題ありませんが、より複雑なケースでは\n" "// 異なるライフタイムが必要になる場合があります。\n" #: src/scope/lifetime/fn.md:29 msgid "\"`print_multi`: x is {}, y is {}\"" msgstr "\"`print_multi`: x is {}, y is {}\"" #: src/scope/lifetime/fn.md:31 msgid "" "// Returning references that have been passed in is acceptable.\n" "// However, the correct lifetime must be returned.\n" msgstr "" "// 受け取った参照をそのまま返すことに問題ありませんが、適切なライフタイム\n" "// でなくてはなりません。\n" #: src/scope/lifetime/fn.md:35 msgid "" "//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n" "// The above is invalid: `'a` must live longer than the function.\n" "// Here, `&String::from(\"foo\")` would create a `String`, followed by a\n" "// reference. Then the data is dropped upon exiting the scope, leaving\n" "// a reference to invalid data to be returned.\n" msgstr "" "// `'a`は関数より長くなくてはならないため上の関数は正しくありません。\n" "// ここでは、`&String::from(\"foo\")`は`String`のデータとそれへの参照を作りま" "す。\n" "// その後データはスコープを抜けるとともに破棄されます。そのため、\n" "// 不適切なデータに対する参照を返すことになってしまいます。\n" #: src/scope/lifetime/fn.md:60 msgid "[Functions](../../fn.md)" msgstr "[関数](../../fn.md)" #: src/scope/lifetime/methods.md:3 msgid "Methods are annotated similarly to functions:" msgstr "メソッドのライフタイムは関数に似ています。" #: src/scope/lifetime/methods.md:9 msgid "// Annotate lifetimes as in a standalone function.\n" msgstr "// 通常の関数と同様にライフタイムを明示。\n" #: src/scope/lifetime/methods.md:12 msgid "\"`print`: {}\"" msgstr "\"`print`: {}\"" #: src/scope/lifetime/methods.md:26 msgid "[methods](../../fn/methods.md)" msgstr "[メソッド](../../fn/methods.md)" #: src/scope/lifetime/struct.md:3 msgid "Annotation of lifetimes in structures are also similar to functions:" msgstr "構造体におけるライフタイムも関数のそれと似ています。" #: src/scope/lifetime/struct.md:6 msgid "" "// A type `Borrowed` which houses a reference to an\n" "// `i32`. The reference to `i32` must outlive `Borrowed`.\n" msgstr "" "// `i32`への参照をメンバに持つ`Borrowed`型。\n" "// 参照は`Borrowed`自体よりも長生きでなくてはなりません。\n" #: src/scope/lifetime/struct.md:10 msgid "// Similarly, both references here must outlive this structure.\n" msgstr "// 同様に、ここでも参照は構造体よりも長生きでなくてはなりません。\n" #: src/scope/lifetime/struct.md:17 msgid "// An enum which is either an `i32` or a reference to one.\n" msgstr "// `i32`、あるいは`i32`への参照のいずれかとなる列挙型\n" #: src/scope/lifetime/struct.md:34 src/scope/lifetime/struct.md:36 msgid "\"x is borrowed in {:?}\"" msgstr "\"x is borrowed in {:?}\"" #: src/scope/lifetime/struct.md:35 msgid "\"x and y are borrowed in {:?}\"" msgstr "\"x and y are borrowed in {:?}\"" #: src/scope/lifetime/struct.md:37 msgid "\"y is *not* borrowed in {:?}\"" msgstr "\"y is *not* borrowed in {:?}\"" #: src/scope/lifetime/struct.md:43 msgid "[`struct`s](../../custom_types/structs.md)" msgstr "[構造体](../../custom_types/structs.md)" #: src/scope/lifetime/trait.md:3 msgid "" "Annotation of lifetimes in trait methods basically are similar to functions. " "Note that `impl` may have annotation of lifetimes too." msgstr "" "トレイトのメソッドにおけるライフタイムのアノテーションは、基本的には関数に似" "ています。`impl`にもライフタイムのアノテーションがあることに注意してくださ" "い。" #: src/scope/lifetime/trait.md:7 msgid "// A struct with annotation of lifetimes.\n" msgstr "// ライフタイムのアノテーションつき構造体\n" #: src/scope/lifetime/trait.md:12 msgid "// Annotate lifetimes to impl.\n" msgstr "// ライフタイムのアノテーションつきimpl\n" #: src/scope/lifetime/trait.md:24 msgid "\"b is {:?}\"" msgstr "\"b is {:?}\"" #: src/scope/lifetime/trait.md:30 msgid "[`trait`s](../../trait.md)" msgstr "[トレイト](../../trait.md)" #: src/scope/lifetime/lifetime_bounds.md:3 msgid "" "Just like generic types can be bounded, lifetimes (themselves generic) use " "bounds as well. The `:` character has a slightly different meaning here, but " "`+` is the same. Note how the following read:" msgstr "" "ジェネリック型に境界を与え、特定のトレイトを実装していることを保証できるのと" "同様、ライフタイム（それ自身ジェネリック型）にも境界を与えることができます。" "`:`は、ここでは多少異なる意味を持ちますが`+`は同じです。以下の構文の意味を" "チェックしてください。" #: src/scope/lifetime/lifetime_bounds.md:7 msgid "`T: 'a`: _All_ references in `T` must outlive lifetime `'a`." msgstr "`T: 'a`：`T`内の *全ての* 参照は`'a`よりも長生きでなくてはなりません。" #: src/scope/lifetime/lifetime_bounds.md:8 msgid "" "`T: Trait + 'a`: Type `T` must implement trait `Trait` and _all_ references " "in `T` must outlive `'a`." msgstr "" "`T: Trait + 'a`：上に加えて`T`は`Trait`という名のトレイトを実装してなくてはな" "りません。" #: src/scope/lifetime/lifetime_bounds.md:11 msgid "" "The example below shows the above syntax in action used after keyword " "`where`:" msgstr "" "上記の構文を実際に動く例で見ていきましょう。`where`キーワードの後に注目してく" "ださい。" #: src/scope/lifetime/lifetime_bounds.md:14 msgid "// Trait to bound with.\n" msgstr "// ライフタイムを紐付けるトレイト\n" #: src/scope/lifetime/lifetime_bounds.md:17 msgid "" "// `Ref` contains a reference to a generic type `T` that has\n" "// an unknown lifetime `'a`. `T` is bounded such that any\n" "// *references* in `T` must outlive `'a`. Additionally, the lifetime\n" "// of `Ref` may not exceed `'a`.\n" msgstr "" "// `Ref`は`'a`というライフタイムを持つジェネリック型`T`に対する参照を持ち、\n" "// `T`の値に対する *参照* は必ず`'a`よりも長生きでなくてはなりません。\n" "// さらに、`Ref`のライフタイムは`'a`を超えてはなりません。\n" #: src/scope/lifetime/lifetime_bounds.md:22 msgid "// A generic function which prints using the `Debug` trait.\n" msgstr "// `Debug`トレイトを利用して出力を行うジェネリック関数\n" #: src/scope/lifetime/lifetime_bounds.md:26 msgid "\"`print`: t is {:?}\"" msgstr "\"`print`: t is {:?}\"" #: src/scope/lifetime/lifetime_bounds.md:28 msgid "" "// Here a reference to `T` is taken where `T` implements\n" "// `Debug` and all *references* in `T` outlive `'a`. In\n" "// addition, `'a` must outlive the function.\n" msgstr "" "// `Debug`を実装している`T`への参照を取りません。`T`への *参照* は\n" "// 必ず`'a`よりも長生きでなくてはなりません。さらに、`'a`は\n" "// 関数自体よりも長生きでなくてはなりません。\n" #: src/scope/lifetime/lifetime_bounds.md:34 msgid "\"`print_ref`: t is {:?}\"" msgstr "\"`print_ref`: t is {:?}\"" #: src/scope/lifetime/lifetime_bounds.md:48 msgid "" "[generics](../../generics.md), [bounds in generics](../../generics/bounds." "md), and [multiple bounds in generics](../../generics/multi_bounds.md)" msgstr "" "[ジェネリクス](../../generics.md), [ジェネリック境界](../../generics/bounds." "md), [複数の境界](../../generics/multi_bounds.md)" #: src/scope/lifetime/lifetime_coercion.md:3 msgid "" "A longer lifetime can be coerced into a shorter one so that it works inside " "a scope it normally wouldn't work in. This comes in the form of inferred " "coercion by the Rust compiler, and also in the form of declaring a lifetime " "difference:" msgstr "" "長いライフタイムは、短いものに圧縮することで、そのままでは動作しないスコープ" "の中でも使用できるようになります。これは、Rustコンパイラが推論の結果として圧" "縮する場合と、複数のライフタイムを比較して圧縮する場合があります。" #: src/scope/lifetime/lifetime_coercion.md:9 msgid "" "// Here, Rust infers a lifetime that is as short as possible.\n" "// The two references are then coerced to that lifetime.\n" msgstr "" "// ここではRustはライフタイムを出来る限り短く見積もり、\n" "// 2つの参照をそのライフタイムに押し込めます。\n" #: src/scope/lifetime/lifetime_coercion.md:14 msgid "" "// `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`.\n" "// Here, we take in an `&'a i32` and return a `&'b i32` as a result of " "coercion.\n" msgstr "" "// `<'a: 'b, 'b>`は「ライフタイム`'a`は最低でも`'b`と同じ長さ」と読めます。\n" "// ここでは、`&'a i32`をとり、`&'b i32`に圧縮して返します。\n" #: src/scope/lifetime/lifetime_coercion.md:22 msgid "// Longer lifetime\n" msgstr "// 長いライフタイム\n" #: src/scope/lifetime/lifetime_coercion.md:25 msgid "// Shorter lifetime\n" msgstr "// 短いライフタイム\n" #: src/scope/lifetime/lifetime_coercion.md:27 msgid "\"The product is {}\"" msgstr "\"The product is {}\"" #: src/scope/lifetime/lifetime_coercion.md:28 msgid "\"{} is the first\"" msgstr "\"{} is the first\"" #: src/scope/lifetime/static_lifetime.md:3 msgid "" "Rust has a few reserved lifetime names. One of those is `'static`. You might " "encounter it in two situations:" msgstr "" "Rustにはいくつかの予約されたライフタイム名があります。その1つが`static`で、2" "つの状況で使用することがあります。" #: src/scope/lifetime/static_lifetime.md:7 msgid "// A reference with 'static lifetime:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:8 msgid "\"hello world\"" msgstr "\"hello world\"" #: src/scope/lifetime/static_lifetime.md:9 msgid "// 'static as part of a trait bound:\n" msgstr "" #: src/scope/lifetime/static_lifetime.md:14 msgid "" "Both are related but subtly different and this is a common source for " "confusion when learning Rust. Here are some examples for each situation:" msgstr "" "2つの状況における`static`は微妙に異なる意味を持っており、Rustを学ぶときの混乱" "の元になっています。いくつかの例とともにそれぞれの使い方を見てみましょう。" #: src/scope/lifetime/static_lifetime.md:17 msgid "Reference lifetime" msgstr "参照のライフタイム" #: src/scope/lifetime/static_lifetime.md:19 msgid "" "As a reference lifetime `'static` indicates that the data pointed to by the " "reference lives for the remaining lifetime of the running program. It can " "still be coerced to a shorter lifetime." msgstr "" "参照のライフタイムが`'static`であることは、参照が指し示す値がプログラムの実行" "中に渡って生き続けることを示します。また、より短いライフタイムに圧縮すること" "も可能です。" #: src/scope/lifetime/static_lifetime.md:23 msgid "" "There are two common ways to make a variable with `'static` lifetime, and " "both are stored in the read-only memory of the binary:" msgstr "" "`'static`ライフタイムを持つ変数を作るには下記の2つ方法があります。どちらの場" "合も、値は読み取り専用のメモリ領域に格納されます。" #: src/scope/lifetime/static_lifetime.md:26 msgid "Make a constant with the `static` declaration." msgstr "`static`宣言とともに定数を作成します。" #: src/scope/lifetime/static_lifetime.md:27 msgid "Make a `string` literal which has type: `&'static str`." msgstr "文字列リテラルで`&'static str`型を持つ変数を作成します。" #: src/scope/lifetime/static_lifetime.md:29 msgid "See the following example for a display of each method:" msgstr "では、それぞれの方法の例を見ていきましょう。" #: src/scope/lifetime/static_lifetime.md:32 msgid "// Make a constant with `'static` lifetime.\n" msgstr "// `'static`ライフタイムを持つ定数を作成。\n" #: src/scope/lifetime/static_lifetime.md:34 msgid "" "// Returns a reference to `NUM` where its `'static`\n" "// lifetime is coerced to that of the input argument.\n" msgstr "" "// `NUM`への参照を返します。ライフタイムは`'static`から引数の\n" "// ライフタイムへと圧縮されています。\n" #: src/scope/lifetime/static_lifetime.md:43 msgid "// Make a `string` literal and print it:\n" msgstr "// 文字列リテラルを用いて変数を作成し、出力します。\n" #: src/scope/lifetime/static_lifetime.md:44 msgid "\"I'm in read-only memory\"" msgstr "\"I'm in read-only memory\"" #: src/scope/lifetime/static_lifetime.md:45 msgid "\"static_string: {}\"" msgstr "\"static_string: {}\"" #: src/scope/lifetime/static_lifetime.md:47 msgid "" "// When `static_string` goes out of scope, the reference\n" " // can no longer be used, but the data remains in the binary.\n" msgstr "" "// `static_string`がスコープから抜けると、参照は使用することが\n" " // できなくなりますが、データはバイナリ中に残ります。\n" #: src/scope/lifetime/static_lifetime.md:52 msgid "// Make an integer to use for `coerce_static`:\n" msgstr "// `coerce_static`関数を呼び出すために、整数を作成。\n" #: src/scope/lifetime/static_lifetime.md:55 msgid "// Coerce `NUM` to lifetime of `lifetime_num`:\n" msgstr "// `NUM`を`lifetime_num`のライフタイムへと圧縮。\n" #: src/scope/lifetime/static_lifetime.md:58 msgid "\"coerced_static: {}\"" msgstr "\"coerced_static: {}\"" #: src/scope/lifetime/static_lifetime.md:61 msgid "\"NUM: {} stays accessible!\"" msgstr "\"NUM: {} stays accessible!\"" #: src/scope/lifetime/static_lifetime.md:65 msgid "" "Since `'static` references only need to be valid for the _remainder_ of a " "program's life, they can be created while the program is executed. Just to " "demonstrate, the below example uses [`Box::leak`](https://doc.rust-lang.org/" "std/boxed/struct.Box.html#method.leak) to dynamically create `'static` " "references. In that case it definitely doesn't live for the entire duration, " "but only for the leaking point onward." msgstr "" #: src/scope/lifetime/static_lifetime.md:90 msgid "Trait bound" msgstr "トレイト境界" #: src/scope/lifetime/static_lifetime.md:92 msgid "" "As a trait bound, it means the type does not contain any non-static " "references. Eg. the receiver can hold on to the type for as long as they " "want and it will never become invalid until they drop it." msgstr "" "トレイト境界としての`'static`は型が非静的な参照を含まないことを意味します。言" "い換えると、レシーバはその型をいくらでも長く保持することができ、意図的にド" "ロップするまでは決して無効になることはないということです。" #: src/scope/lifetime/static_lifetime.md:96 msgid "" "It's important to understand this means that any owned data always passes a " "`'static` lifetime bound, but a reference to that owned data generally does " "not:" msgstr "" "次のポイントを押さえておきましょう。所有権のある値が`'static`ライフタイム境界" "をパスするとしても、その値への参照が`'static`ライフタイム境界をパスするとは限" "りません。" #: src/scope/lifetime/static_lifetime.md:104 msgid "\"'static value passed in is: {:?}\"" msgstr "\"'static value passed in is: {:?}\"" #: src/scope/lifetime/static_lifetime.md:108 msgid "// i is owned and contains no references, thus it's 'static:\n" msgstr "// i は所有されていて、かつ参照を含まないので 'static。\n" #: src/scope/lifetime/static_lifetime.md:112 msgid "" "// oops, &i only has the lifetime defined by the scope of\n" " // main(), so it's not 'static:\n" msgstr "" "// おっと、&i は main() のスコープで定義された\n" " // ライフタイムしかもたないため 'static ではありません。\n" #: src/scope/lifetime/static_lifetime.md:117 msgid "The compiler will tell you:" msgstr "コンパイラのメッセージはこのようになります。" #: src/scope/lifetime/static_lifetime.md:133 msgid "[`'static` constants](../../custom_types/constants.md)" msgstr "[`'static` 定数](../../custom_types/constants.md)" #: src/scope/lifetime/elision.md:3 msgid "" "Some lifetime patterns are overwhelmingly common and so the borrow checker " "will allow you to omit them to save typing and to improve readability. This " "is known as elision. Elision exists in Rust solely because these patterns " "are common." msgstr "" "ライフタイムのパターンのうちのいくつかは、他と比べてあまりにも一般的に使用さ" "れるため、タイプ量を減らし可読性を上げるために省くことができます。これは省略" "として知られており、それらのパターンが一般的であるというだけの理由で存在して" "います。" #: src/scope/lifetime/elision.md:8 msgid "" "The following code shows a few examples of elision. For a more comprehensive " "description of elision, see [lifetime elision](https://doc.rust-lang.org/" "book/ch10-03-lifetime-syntax.html#lifetime-elision) in the book." msgstr "" "以下のコードでは省略の例を幾つかお見せします。より完全な説明を見たい場合は、" "「プログラミング言語Rust」の[ライフタイムの省略](https://doc.rust-lang.org/" "book/ch10-03-lifetime-syntax.html#lifetime-elision)の項を見てください。" #: src/scope/lifetime/elision.md:12 msgid "" "// `elided_input` and `annotated_input` essentially have identical " "signatures\n" "// because the lifetime of `elided_input` is inferred by the compiler:\n" msgstr "" "// `elided_input`のライフタイムはコンパイラによって自動的に付与されるため\n" "// 以下の2つは同一のライフタイムシグネチャを持ちます。\n" #: src/scope/lifetime/elision.md:15 msgid "\"`elided_input`: {}\"" msgstr "\"`elided_input`: {}\"" #: src/scope/lifetime/elision.md:19 msgid "\"`annotated_input`: {}\"" msgstr "\"`annotated_input`: {}\"" #: src/scope/lifetime/elision.md:21 msgid "" "// Similarly, `elided_pass` and `annotated_pass` have identical signatures\n" "// because the lifetime is added implicitly to `elided_pass`:\n" msgstr "" "// 同様に、以下の2つの関数も全く同じライフタイムシグネチャを持ちます。\n" #: src/scope/lifetime/elision.md:34 msgid "\"`elided_pass`: {}\"" msgstr "\"`elided_pass`: {}\"" #: src/scope/lifetime/elision.md:35 msgid "\"`annotated_pass`: {}\"" msgstr "\"`annotated_pass`: {}\"" #: src/scope/lifetime/elision.md:41 msgid "" "[elision](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax." "html#lifetime-elision)" msgstr "" "[省略](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-" "elision)" #: src/trait.md:3 msgid "" "A `trait` is a collection of methods defined for an unknown type: `Self`. " "They can access other methods declared in the same trait." msgstr "" "トレイトとは任意の型となりうる`Self`に対して定義されたメソッドの集合のことで" "す。同じトレイト内で宣言されたメソッド同士はお互いにアクセスすることができま" "す。" #: src/trait.md:6 msgid "" "Traits can be implemented for any data type. In the example below, we define " "`Animal`, a group of methods. The `Animal` `trait` is then implemented for " "the `Sheep` data type, allowing the use of methods from `Animal` with a " "`Sheep`." msgstr "" "トレイトはあらゆるデータ型に実装することができます。以下の例ではまず`Animal`" "というメソッドの集合を定義し、その後`Animal`トレイトを`Sheep`というデータ型に" "対して実装します。これにより`Animal`のメソッドを`Sheep`が使用することが可能に" "なります。" #: src/trait.md:15 msgid "" "// Associated function signature; `Self` refers to the implementor type.\n" msgstr "" "// 関連関数のシグネチャ\n" " // `Self` はこのトレイトを実装している型になります。\n" #: src/trait.md:18 msgid "// Method signatures; these will return a string.\n" msgstr "" "// メソッドのシグネチャ\n" " // これらの関数は文字列を返します。\n" #: src/trait.md:22 msgid "// Traits can provide default method definitions.\n" msgstr "// メソッドのデフォルトの挙動を定義することもできます。\n" #: src/trait.md:24 msgid "\"{} says {}\"" msgstr "\"{} says {}\"" #: src/trait.md:35 msgid "// Implementor methods can use the implementor's trait methods.\n" msgstr "" "// メソッドをある型に実装する際に、その型のトレイトメソッドを\n" " // 使用することができます。\n" #: src/trait.md:36 msgid "\"{} is already naked...\"" msgstr "\"{} is already naked...\"" #: src/trait.md:38 msgid "\"{} gets a haircut!\"" msgstr "\"{} gets a haircut!\"" #: src/trait.md:44 src/trait/dyn.md:17 msgid "// Implement the `Animal` trait for `Sheep`.\n" msgstr "// `Animal`というトレイトを`Sheep`に実装します。\n" #: src/trait.md:47 msgid "// `Self` is the implementor type: `Sheep`.\n" msgstr "// `Self`は実装対象の型：ここでは`Sheep`\n" #: src/trait.md:58 msgid "\"baaaaah?\"" msgstr "\"baaaaah?\"" #: src/trait.md:60 src/trait/dyn.md:21 msgid "\"baaaaah!\"" msgstr "\"baaaaah!\"" #: src/trait.md:64 msgid "// Default trait methods can be overridden.\n" msgstr "// デフォルトのトレイトメソッドはオーバーライドすることができます。\n" #: src/trait.md:66 msgid "// For example, we can add some quiet contemplation.\n" msgstr "// 例えば、静かに熟考させてみます。\n" #: src/trait.md:67 msgid "\"{} pauses briefly... {}\"" msgstr "\"{} pauses briefly... {}\"" #: src/trait.md:72 msgid "// Type annotation is necessary in this case.\n" msgstr "// この場合、型アノテーションが必須。\n" #: src/trait.md:73 msgid "\"Dolly\"" msgstr "\"Dolly\"" #: src/trait.md:74 msgid "// TODO ^ Try removing the type annotations.\n" msgstr "// TODO ^ ここの型アノテーションを消してみましょう。\n" #: src/trait/derive.md:3 msgid "" "The compiler is capable of providing basic implementations for some traits " "via the `#[derive]` [attribute](../attribute.md). These traits can still be " "manually implemented if a more complex behavior is required." msgstr "" "コンパイラには、`#[derive]`[アトリビュート](../attribute.md)を用いることで型" "に対して特定のトレイトの標準的な実装を提供する機能があります。より複雑なこと" "を行わせたい場合には、同名のトレイトを手動で実装することも可能です。" #: src/trait/derive.md:7 msgid "The following is a list of derivable traits:" msgstr "以下はderive可能なトレイトの一覧です。" #: src/trait/derive.md:8 msgid "" "Comparison traits: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), " "[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]" "(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)." msgstr "" "型の比較に関連するトレイト: [`Eq`](https://doc.rust-lang.org/std/cmp/trait." "Eq.html), [`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq." "html), [`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), " "[`PartialOrd`](https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)." #: src/trait/derive.md:10 msgid "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), to create " "`T` from `&T` via a copy." msgstr "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html)：これはコピー" "によって`&T`から`T`を作成するトレイト" #: src/trait/derive.md:11 msgid "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), to give a " "type 'copy semantics' instead of 'move semantics'." msgstr "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html)：これはムーブ" "セマンティクスの代わりにコピーセマンティクスにするためのトレイト" #: src/trait/derive.md:12 msgid "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), to compute a " "hash from `&T`." msgstr "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html)：これは`&T`から" "ハッシュ値を計算するためのトレイト" #: src/trait/derive.md:13 msgid "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), to " "create an empty instance of a data type." msgstr "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html)：これは" "空っぽのインスタンスを作成するためのトレイト" #: src/trait/derive.md:14 msgid "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), to format a " "value using the `{:?}` formatter." msgstr "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html)：これは`{:?}`" "フォーマッタを利用して値をフォーマットするためのトレイト" #: src/trait/derive.md:17 msgid "// `Centimeters`, a tuple struct that can be compared\n" msgstr "// `Centimeters`は比較可能なタプルになります。\n" #: src/trait/derive.md:20 msgid "// `Inches`, a tuple struct that can be printed\n" msgstr "// `Inches`は出力可能なタプルになります。\n" #: src/trait/derive.md:32 msgid "// `Seconds`, a tuple struct with no additional attributes\n" msgstr "// `Seconds`には特にアトリビュートを付け加えません。\n" #: src/trait/derive.md:39 msgid "" "// Error: `Seconds` can't be printed; it doesn't implement the `Debug` " "trait\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー：`Debug`トレイトを実装していないため`Seconds`は出力できません。\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/trait/derive.md:43 msgid "" "// Error: `Seconds` can't be compared; it doesn't implement the `PartialEq` " "trait\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー`PartialEq`トレイトを実装していないため`Seconds`は比較できません。\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/trait/derive.md:49 msgid "\"One foot equals {:?}\"" msgstr "\"One foot equals {:?}\"" #: src/trait/derive.md:55 msgid "\"smaller\"" msgstr "\"smaller\"" #: src/trait/derive.md:57 msgid "\"bigger\"" msgstr "\"bigger\"" #: src/trait/derive.md:60 msgid "\"One foot is {} than one meter.\"" msgstr "\"One foot is {} than one meter.\"" #: src/trait/derive.md:65 msgid "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)" msgstr "[導出](https://doc.rust-lang.org/reference/attributes.html#derive)" #: src/trait/dyn.md:3 msgid "" "The Rust compiler needs to know how much space every function's return type " "requires. This means all your functions have to return a concrete type. " "Unlike other languages, if you have a trait like `Animal`, you can't write a " "function that returns `Animal`, because its different implementations will " "need different amounts of memory." msgstr "" "Rustのコンパイラはあらゆる関数のリターン型に必要なスペースを知っておく必要が" "あります。つまり、すべての関数は具体的な型を返す必要があるのです。他の言語と" "違って、`Animal`のようなトレイトがある場合に、`Animal`を返す関数を書くことは" "できません。なぜなら、そのトレイトの異なる実装はそれぞれ別の量のメモリを必要" "とするからです。" #: src/trait/dyn.md:5 msgid "" "However, there's an easy workaround. Instead of returning a trait object " "directly, our functions return a `Box` which _contains_ some `Animal`. A " "`box` is just a reference to some memory in the heap. Because a reference " "has a statically-known size, and the compiler can guarantee it points to a " "heap-allocated `Animal`, we can return a trait from our function!" msgstr "" "しかし、簡単な回避策があります。直接トレイトオブジェクトを返す代わりに、" "`Animal`を _含む_ `Box`を返すのです。`Box`はヒープ中のメモリへの単なる参照で" "す。参照のサイズは静的に知ることができ、コンパイラは参照がヒープに割り当てら" "れた`Animal`を指していると保証できるので、私たちは関数からトレイトを返すこと" "ができます。" #: src/trait/dyn.md:7 msgid "" "Rust tries to be as explicit as possible whenever it allocates memory on the " "heap. So if your function returns a pointer-to-trait-on-heap in this way, " "you need to write the return type with the `dyn` keyword, e.g. `Box`." msgstr "" "ヒープにメモリを割り当てる際、Rustは可能な限り明示的であろうとします。なの" "で、もしあなたの関数がヒープ上のトレイトへのポインタを返す場合、例えば" "`Box`のように、リターン型に`dyn`キーワードをつける必要がありま" "す。" #: src/trait/dyn.md:14 msgid "// Instance method signature\n" msgstr "// インスタンスメソッドのシグネチャ\n" #: src/trait/dyn.md:24 msgid "// Implement the `Animal` trait for `Cow`.\n" msgstr "// `Cow`に`Animal`トレイトを実装します。\n" #: src/trait/dyn.md:28 msgid "\"moooooo!\"" msgstr "\"moooooo!\"" #: src/trait/dyn.md:31 msgid "" "// Returns some struct that implements Animal, but we don't know which one " "at compile time.\n" msgstr "" "// Animalを実装した何らかの構造体を返します。\n" "// ただし、コンパイル時にはどの実装か分かりません。\n" #: src/trait/dyn.md:44 msgid "\"You've randomly chosen an animal, and it says {}\"" msgstr "\"You've randomly chosen an animal, and it says {}\"" #: src/trait/ops.md:3 msgid "" "In Rust, many of the operators can be overloaded via traits. That is, some " "operators can be used to accomplish different tasks based on their input " "arguments. This is possible because operators are syntactic sugar for method " "calls. For example, the `+` operator in `a + b` calls the `add` method (as " "in `a.add(b)`). This `add` method is part of the `Add` trait. Hence, the `+` " "operator can be used by any implementor of the `Add` trait." msgstr "" "Rustでは、多くの演算子はトレイトによってオーバーロードすることができます。つ" "まり、一部の演算子は引数となる値の型に応じて異なる役割を果たすことができると" "いうことです。これが可能なのは、演算子が実際にはメソッド呼び出しの糖衣構文に" "すぎないからです。例えば`a + b`における`+`演算子は`add`メソッドを（`a.add(b)`" "の形で）呼び出します。この`add`メソッドは`Add`トレイトの一部です。それ故、`+`" "は`Add`トレイトを実装している全ての型に対して有効なのです。" #: src/trait/ops.md:9 msgid "" "A list of the traits, such as `Add`, that overload operators can be found in " "[`core::ops`](https://doc.rust-lang.org/core/ops/)." msgstr "" "`Add`などの、演算子をオーバーロードするトレイトの一覧は[`core::ops`](https://" "doc.rust-lang.org/core/ops/)にあります。" #: src/trait/ops.md:22 msgid "" "// The `std::ops::Add` trait is used to specify the functionality of `+`.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Bar`.\n" "// The following block implements the operation: Foo + Bar = FooBar\n" msgstr "" "// `std::ops::Add`トレイトは`+`の振る舞いを規定するために使用されます。\n" "// ここでは`Foo`に対して`Add`を実装します。これは加算時の右辺が`Bar`型\n" "// の時に呼び出されるトレイトです。\n" "// つまり以下は`Foo + Bar = FooBar`という振る舞いをもたらします。\n" #: src/trait/ops.md:30 msgid "\"> Foo.add(Bar) was called\"" msgstr "\"> Foo.add(Bar) was called\"" #: src/trait/ops.md:35 msgid "" "// By reversing the types, we end up implementing non-commutative addition.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Foo`.\n" "// This block implements the operation: Bar + Foo = BarFoo\n" msgstr "" "// 型を反転することで、非可換の加算を実装できます。ここでは`Bar`に対して\n" "// `Add`を実装します。\n" "// これは加算時の右辺が`Foo`型の時に呼び出されるメソッドです。\n" "// つまり以下は`Bar + Foo = BarFoo`という結果をもたらします。\n" #: src/trait/ops.md:43 msgid "\"> Bar.add(Foo) was called\"" msgstr "\"> Bar.add(Foo) was called\"" #: src/trait/ops.md:50 msgid "\"Foo + Bar = {:?}\"" msgstr "\"Foo + Bar = {:?}\"" #: src/trait/ops.md:51 msgid "\"Bar + Foo = {:?}\"" msgstr "\"Bar + Foo = {:?}\"" #: src/trait/ops.md:55 src/testing.md:16 src/testing/doc_testing.md:104 #: src/testing/dev_dependencies.md:36 msgid "See Also" msgstr "参照" #: src/trait/ops.md:57 msgid "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [Syntax Index]" "(https://doc.rust-lang.org/book/appendix-02-operators.html)" msgstr "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [構文の索引]" "(https://doc.rust-lang.org/book/appendix-02-operators.html)" #: src/trait/drop.md:3 msgid "" "The [`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) trait only " "has one method: `drop`, which is called automatically when an object goes " "out of scope. The main use of the `Drop` trait is to free the resources that " "the implementor instance owns." msgstr "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html)トレイトにはメソッ" "ドが一つだけしかありません。`drop`です。これは、オブジェクトがスコープから抜" "けた時に自動で呼ばれます。`Drop`トレイトの主な使用目的は、インスタンスが所有" "する資源を開放することです。" #: src/trait/drop.md:7 msgid "" "`Box`, `Vec`, `String`, `File`, and `Process` are some examples of types " "that implement the `Drop` trait to free resources. The `Drop` trait can also " "be manually implemented for any custom data type." msgstr "" "`Drop`トレイトを実装している型の例としては`Box`、`Vec`、`String`、`File`、" "`Process`等があげられます。`Drop`トレイトは任意の型に対して手動で実装すること" "ができます。" #: src/trait/drop.md:11 msgid "" "The following example adds a print to console to the `drop` function to " "announce when it is called." msgstr "" "以下の例では`drop`メソッドにコンソールへの出力を追加することで、`drop`が呼ば" "れたタイミングが分かるようにしています。" #: src/trait/drop.md:18 msgid "// This trivial implementation of `drop` adds a print to console.\n" msgstr "// このちょっとした実装で、`drop`にコンソール出力機能がつきます。\n" #: src/trait/drop.md:22 msgid "\"> Dropping {}\"" msgstr "\"> Dropping {}\"" #: src/trait/drop.md:27 src/std_misc/path.md:33 src/std_misc/fs.md:44 #: src/std_misc/fs.md:87 msgid "\"a\"" msgstr "\"a\"" #: src/trait/drop.md:29 msgid "// block A\n" msgstr "" #: src/trait/drop.md:31 src/std_misc/path.md:33 msgid "\"b\"" msgstr "\"b\"" #: src/trait/drop.md:33 msgid "// block B\n" msgstr "" #: src/trait/drop.md:35 src/std_misc/path.md:36 msgid "\"c\"" msgstr "\"c\"" #: src/trait/drop.md:36 msgid "\"d\"" msgstr "\"d\"" #: src/trait/drop.md:38 msgid "\"Exiting block B\"" msgstr "\"Exiting block B\"" #: src/trait/drop.md:40 msgid "\"Just exited block B\"" msgstr "\"Just exited block B\"" #: src/trait/drop.md:42 msgid "\"Exiting block A\"" msgstr "\"Exiting block A\"" #: src/trait/drop.md:44 msgid "\"Just exited block A\"" msgstr "\"Just exited block A\"" #: src/trait/drop.md:46 msgid "// Variable can be manually dropped using the `drop` function\n" msgstr "// `drop`関数を用いて変数を手動で開放することもできます。\n" #: src/trait/drop.md:48 msgid "// TODO ^ Try commenting this line\n" msgstr "// TODO ^ この行をコメントアウトしてみましょう。\n" #: src/trait/drop.md:50 msgid "\"end of the main function\"" msgstr "\"end of the main function\"" #: src/trait/drop.md:52 msgid "" "// `_a` *won't* be `drop`ed again here, because it already has been\n" " // (manually) `drop`ed\n" msgstr "" "// `_a`はここで`drop`されることは *ありません* 。なぜならば、上ですでに\n" " // （手動で）`drop`されているためです。\n" #: src/trait/iter.md:3 msgid "" "The [`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "trait is used to implement iterators over collections such as arrays." msgstr "" "[`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html)トレイト" "は、例えば配列のような、要素の集合に対してイテレータを実装するためのトレイト" "です。" #: src/trait/iter.md:6 msgid "" "The trait requires only a method to be defined for the `next` element, which " "may be manually defined in an `impl` block or automatically defined (as in " "arrays and ranges)." msgstr "" "このトレイトは`next`の要素に相当するものを決定するためのメソッドのみを要求し" "ます。このメソッドは`impl`ブロック内で手動で実装するか、あるいは（配列やrange" "のように）自動で定義されます。" #: src/trait/iter.md:10 msgid "" "As a point of convenience for common situations, the `for` construct turns " "some collections into iterators using the [`.into_iter()`](https://doc.rust-" "lang.org/std/iter/trait.IntoIterator.html) method." msgstr "" "サッとイテレータを使いたい時は、`for`文で集合からイテレータを作成することが良" "くあります。これは[`.into_iter()`](https://doc.rust-lang.org/std/iter/trait." "IntoIterator.html)メソッドを呼び出しています。" #: src/trait/iter.md:18 msgid "" "// Implement `Iterator` for `Fibonacci`.\n" "// The `Iterator` trait only requires a method to be defined for the `next` " "element.\n" msgstr "" "// `Iterator`を`Fibonacci`に対して実装します。\n" "// `Iterator`トレイトは次の要素を取得するメソッドの定義だけを要求します。\n" #: src/trait/iter.md:22 msgid "// We can refer to this type using Self::Item\n" msgstr "" #: src/trait/iter.md:25 msgid "" "// Here, we define the sequence using `.curr` and `.next`.\n" " // The return type is `Option`:\n" " // * When the `Iterator` is finished, `None` is returned.\n" " // * Otherwise, the next value is wrapped in `Some` and returned.\n" " // We use Self::Item in the return type, so we can change\n" " // the type without having to update the function signatures.\n" msgstr "" "// ここではイテレーションの流れを`.curr`と`.next`を使用して定義しています。\n" " // 返り値の型は`Option`で、これは：\n" " // * `Iterator`が終了した時は`None`を返します。\n" " // * そうでなければ`Some`でラップされた値を返します。\n" #: src/trait/iter.md:37 msgid "" "// Since there's no endpoint to a Fibonacci sequence, the `Iterator` \n" " // will never return `None`, and `Some` is always returned.\n" msgstr "" "// フィボナッチ数列には終端がないので、`Iterator`は決して\n" " // `None`を返さず、常に`Some`が返されます。\n" #: src/trait/iter.md:42 msgid "// Returns a Fibonacci sequence generator\n" msgstr "// フィボナッチ数列のジェネレータを返します。\n" #: src/trait/iter.md:49 msgid "// `0..3` is an `Iterator` that generates: 0, 1, and 2.\n" msgstr "// `0..3`は0, 1, 2をジェネレートする`Iterator`。\n" #: src/trait/iter.md:52 msgid "\"Four consecutive `next` calls on 0..3\"" msgstr "\"Four consecutive `next` calls on 0..3\"" #: src/trait/iter.md:53 src/trait/iter.md:54 src/trait/iter.md:55 #: src/trait/iter.md:56 src/std_misc/fs.md:90 msgid "\"> {:?}\"" msgstr "\"> {:?}\"" #: src/trait/iter.md:58 msgid "" "// `for` works through an `Iterator` until it returns `None`.\n" " // Each `Some` value is unwrapped and bound to a variable (here, `i`).\n" msgstr "" "// `for`は`None`を返すまで、イテレータを舐めていき、出てきた`Some`を\n" " // アンラップして変数（ここでは`i`）に束縛します。\n" #: src/trait/iter.md:60 msgid "\"Iterate through 0..3 using `for`\"" msgstr "\"Iterate through 0..3 using `for`\"" #: src/trait/iter.md:62 src/trait/iter.md:68 src/trait/iter.md:74 #: src/trait/iter.md:82 src/std/vec.md:49 src/std/str.md:22 #: src/std_misc/fs.md:82 msgid "\"> {}\"" msgstr "\"> {}\"" #: src/trait/iter.md:65 msgid "// The `take(n)` method reduces an `Iterator` to its first `n` terms.\n" msgstr "" "// `take(n)`メソッドは`Iterator`を先頭から`n`番目の要素までに減らします。\n" #: src/trait/iter.md:66 msgid "\"The first four terms of the Fibonacci sequence are: \"" msgstr "\"The first four terms of the Fibonacci sequence are: \"" #: src/trait/iter.md:71 msgid "" "// The `skip(n)` method shortens an `Iterator` by dropping its first `n` " "terms.\n" msgstr "" "// `skip(n)`メソッドは`Iterator`の先頭から`n`番目までの要素をとばします。\n" #: src/trait/iter.md:72 msgid "\"The next four terms of the Fibonacci sequence are: \"" msgstr "\"The next four terms of the Fibonacci sequence are: \"" #: src/trait/iter.md:79 msgid "// The `iter` method produces an `Iterator` over an array/slice.\n" msgstr "// `iter`メソッドは配列やスライスからイテレータを作成します。\n" #: src/trait/iter.md:80 msgid "\"Iterate the following array {:?}\"" msgstr "\"Iterate the following array {:?}\"" #: src/trait/impl_trait.md:3 msgid "`impl Trait` can be used in two locations:" msgstr "`impl Trait`は2つの利用方法があります：" #: src/trait/impl_trait.md:5 msgid "as an argument type" msgstr "引数の型" #: src/trait/impl_trait.md:6 msgid "as a return type" msgstr "リターン型" #: src/trait/impl_trait.md:8 msgid "As an argument type" msgstr "引数の型" #: src/trait/impl_trait.md:10 msgid "" "If your function is generic over a trait but you don't mind the specific " "type, you can simplify the function declaration using `impl Trait` as the " "type of the argument." msgstr "" "あなたの関数がジェネリックなトレイトを使用していて、特定の型を意識していない" "場合、`impl Trait`を引数の型として利用して、関数宣言をシンプルにできます。" #: src/trait/impl_trait.md:12 msgid "For example, consider the following code:" msgstr "例えば、次のコードを考えてみましょう：" #: src/trait/impl_trait.md:18 src/trait/impl_trait.md:37 msgid "// For each line in the source\n" msgstr "// ソースのそれぞれの行について\n" #: src/trait/impl_trait.md:20 src/trait/impl_trait.md:39 msgid "" "// If the line was read successfully, process it, if not, return the error\n" msgstr "// 行を読み込んだら処理します。そうでなければエラーを返します。\n" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 src/std/str.md:41 msgid "','" msgstr "','" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 msgid "// Split the line separated by commas\n" msgstr "// 行をカンマで分割します。\n" #: src/trait/impl_trait.md:22 src/trait/impl_trait.md:41 msgid "// Remove leading and trailing whitespace\n" msgstr "// 前後の空白を削除します。\n" #: src/trait/impl_trait.md:23 src/trait/impl_trait.md:42 msgid "// Collect all strings in a row into a Vec\n" msgstr "// 各行の全ての文字列をVecに集めます。\n" #: src/trait/impl_trait.md:26 src/trait/impl_trait.md:45 msgid "// Collect all lines into a Vec>\n" msgstr "// 全ての行をVec>に集めます。\n" #: src/trait/impl_trait.md:30 msgid "" "`parse_csv_document` is generic, allowing it to take any type which " "implements BufRead, such as `BufReader` or `[u8]`, but it's not " "important what type `R` is, and `R` is only used to declare the type of " "`src`, so the function can also be written as:" msgstr "" "`parse_csv_document`はジェネリックなので、BufReadを実装する任意の型を取ること" "ができます。例えば、`BufReader`や`[u8]`です。`R`がどんな型かは重要では" "なく、`src`の型宣言に使われているだけなので、この関数は以下のように書くことも" "できます：" #: src/trait/impl_trait.md:49 msgid "" "Note that using `impl Trait` as an argument type means that you cannot " "explicitly state what form of the function you use, i.e. " "`parse_csv_document::(std::io::empty())` will not work with " "the second example." msgstr "" "`impl Trait`を引数の型として利用するということは、どのような形式の関数である" "か明示できないので、注意してください。例えば、`parse_csv_document::(std::io::empty())`は2番目の例では動作しません。" #: src/trait/impl_trait.md:52 msgid "As a return type" msgstr "リターン型" #: src/trait/impl_trait.md:54 msgid "" "If your function returns a type that implements `MyTrait`, you can write its " "return type as `-> impl MyTrait`. This can help simplify your type " "signatures quite a lot!" msgstr "" "あなたの関数が`MyTrait`を実装する型を返す場合、リターン型を`-> impl MyTrait`" "のように書けます。これで型シグネチャをとてもシンプルにできます。" #: src/trait/impl_trait.md:60 msgid "" "// This function combines two `Vec` and returns an iterator over it.\n" "// Look how complicated its return type is!\n" msgstr "" "// この関数は2つの`Vecを組み合わせて、そのイテレータを返します。\n" "// リターン型がとても複雑です！\n" #: src/trait/impl_trait.md:69 msgid "" "// This is the exact same function, but its return type uses `impl Trait`.\n" "// Look how much simpler it is!\n" msgstr "" "// これは全く同じ関数ですが、リターン型に`impl Trait`を使っています。\n" "// とてもシンプルですね！\n" #: src/trait/impl_trait.md:88 msgid "\"all done\"" msgstr "\"all done\"" #: src/trait/impl_trait.md:92 msgid "" "More importantly, some Rust types can't be written out. For example, every " "closure has its own unnamed concrete type. Before `impl Trait` syntax, you " "had to allocate on the heap in order to return a closure. But now you can do " "it all statically, like this:" msgstr "" "より重要なことに、Rustの型には書き表せないものがあるのです。例えば、あらゆる" "クロージャは独自の無名な具象型を持ちます。`impl Trait`構文がない時は、クロー" "ジャを返すにはヒープ上に置かねばなりませんでした。しかし今では次のようにすべ" "て静的に行えます。" #: src/trait/impl_trait.md:98 msgid "// Returns a function that adds `y` to its input\n" msgstr "// 入力に`y`を加える関数を返します。\n" #: src/trait/impl_trait.md:110 msgid "" "You can also use `impl Trait` to return an iterator that uses `map` or " "`filter` closures! This makes using `map` and `filter` easier. Because " "closure types don't have names, you can't write out an explicit return type " "if your function returns iterators with closures. But with `impl Trait` you " "can do this easily:" msgstr "" "`impl Trait`を使って、`map`や`filter`クロージャを使うイテレータを返すこともで" "きます。おかげで`map`や`filter`を簡単に使えます。クロージャ型は名前を持たない" "ので、あなたの関数がクロージャを持つイテレータを返す場合、明示的なリターン型" "を書くことはできません。しかし`impl Trait`を使うことで簡単にできます：" #: src/trait/clone.md:3 msgid "" "When dealing with resources, the default behavior is to transfer them during " "assignments or function calls. However, sometimes we need to make a copy of " "the resource as well." msgstr "" "メモリ上の資源を扱う際、変数束縛や関数呼び出しを介して移動させるのがデフォル" "トの挙動です。しかしながら、場合によっては資源のコピーを作るのが適切なことも" "あります。" #: src/trait/clone.md:7 msgid "" "The [`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) trait " "helps us do exactly this. Most commonly, we can use the `.clone()` method " "defined by the `Clone` trait." msgstr "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html)トレイトはまさ" "にこのためにあります。普通は`Clone`トレイトで定義されている`.clone()`を用いま" "す。" #: src/trait/clone.md:11 msgid "// A unit struct without resources\n" msgstr "// いかなる資源も持たない構造体\n" #: src/trait/clone.md:14 msgid "// A tuple struct with resources that implements the `Clone` trait\n" msgstr "// `Clone`トレイトを実装する型の変数を資源として持つタプル\n" #: src/trait/clone.md:20 msgid "// Instantiate `Unit`\n" msgstr "// `Unit`のインスタンスを作成。\n" #: src/trait/clone.md:22 msgid "// Copy `Unit`, there are no resources to move\n" msgstr "// `Unit`をコピー、移動させる資源は存在しません。\n" #: src/trait/clone.md:25 msgid "// Both `Unit`s can be used independently\n" msgstr "// いずれの`Unit`も独立に使用できます。\n" #: src/trait/clone.md:26 src/trait/clone.md:31 msgid "\"original: {:?}\"" msgstr "\"original: {:?}\"" #: src/trait/clone.md:27 msgid "\"copy: {:?}\"" msgstr "\"copy: {:?}\"" #: src/trait/clone.md:29 msgid "// Instantiate `Pair`\n" msgstr "// `Pair`のインスタンスを作成。\n" #: src/trait/clone.md:33 msgid "// Move `pair` into `moved_pair`, moves resources\n" msgstr "// `pair`を`moved_pair`に移動、資源は移動します。\n" #: src/trait/clone.md:35 msgid "\"moved: {:?}\"" msgstr "\"moved: {:?}\"" #: src/trait/clone.md:37 msgid "" "// Error! `pair` has lost its resources\n" " //println!(\"original: {:?}\", pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`pair`は資源を失っています。\n" " //println!(\"original: {:?}\", pair);\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/trait/clone.md:41 msgid "// Clone `moved_pair` into `cloned_pair` (resources are included)\n" msgstr "" "// `moved_pair`を`cloned_pair`にクローンします。（資源もクローンされま" "す。）\n" #: src/trait/clone.md:43 msgid "// Drop the moved original pair using std::mem::drop\n" msgstr "// std::mem::dropを用いて元のpairをドロップします。\n" #: src/trait/clone.md:46 msgid "" "// Error! `moved_pair` has been dropped\n" " //println!(\"moved and dropped: {:?}\", moved_pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// エラー！`moved_pair`はドロップされています。\n" " //println!(\"moved and dropped: {:?}\", moved_pair);\n" " // TODO ^ この行をアンコメントしてみましょう。\n" #: src/trait/clone.md:50 msgid "// The result from .clone() can still be used!\n" msgstr "// .clone()した値はまだ使用可能！\n" #: src/trait/clone.md:51 msgid "\"clone: {:?}\"" msgstr "\"clone: {:?}\"" #: src/trait/supertraits.md:3 msgid "" "Rust doesn't have \"inheritance\", but you can define a trait as being a " "superset of another trait. For example:" msgstr "" "Rustには\"継承\"はありませんが、あるトレイトを別のトレイトの上位集合として定" "義できます。例えば：" #: src/trait/supertraits.md:10 msgid "" "// Person is a supertrait of Student.\n" "// Implementing Student requires you to also impl Person.\n" msgstr "" "// PersonはStudentのスーパートレイトです。\n" "// Studentを実装するにはPersonも実装する必要があります。\n" #: src/trait/supertraits.md:20 msgid "" "// CompSciStudent (computer science student) is a subtrait of both " "Programmer \n" "// and Student. Implementing CompSciStudent requires you to impl both " "supertraits.\n" msgstr "" "// CompSciStudent（コンピュータサイエンスの学生）はProgrammerとStudent両方の" "サブトレイトです。\n" "// CompSciStudentを実装するには、両方のスーパートレイトを実装する必要がありま" "す。\n" #: src/trait/supertraits.md:29 msgid "" "\"My name is {} and I attend {}. My favorite language is {}. My Git username " "is {}\"" msgstr "" "\"My name is {} and I attend {}. My favorite language is {}. My Git username " "is {}\"" #: src/trait/supertraits.md:42 msgid "" "[The Rust Programming Language chapter on supertraits](https://doc.rust-lang." "org/book/ch19-03-advanced-traits.html#using-supertraits-to-require-one-" "traits-functionality-within-another-trait)" msgstr "" #: src/trait/disambiguating.md:3 msgid "" "A type can implement many different traits. What if two traits both require " "the same name for a function? For example, many traits might have a method " "named `get()`. They might even have different return types!" msgstr "" #: src/trait/disambiguating.md:7 msgid "" "Good news: because each trait implementation gets its own `impl` block, it's " "clear which trait's `get` method you're implementing." msgstr "" #: src/trait/disambiguating.md:10 msgid "" "What about when it comes time to _call_ those methods? To disambiguate " "between them, we have to use Fully Qualified Syntax." msgstr "" #: src/trait/disambiguating.md:15 msgid "// Get the selected username out of this widget\n" msgstr "" #: src/trait/disambiguating.md:20 msgid "// Get the selected age out of this widget\n" msgstr "" #: src/trait/disambiguating.md:23 msgid "// A form with both a UsernameWidget and an AgeWidget\n" msgstr "" #: src/trait/disambiguating.md:44 src/trait/disambiguating.md:54 msgid "\"rustacean\"" msgstr "\"rustacean\"" #: src/trait/disambiguating.md:48 msgid "" "// If you uncomment this line, you'll get an error saying\n" " // \"multiple `get` found\". Because, after all, there are multiple " "methods\n" " // named `get`.\n" " // println!(\"{}\", form.get());\n" msgstr "" #: src/trait/disambiguating.md:62 msgid "" "[The Rust Programming Language chapter on Fully Qualified syntax](https://" "doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-" "for-disambiguation-calling-methods-with-the-same-name)" msgstr "" #: src/macros.md:3 msgid "" "Rust provides a powerful macro system that allows metaprogramming. As you've " "seen in previous chapters, macros look like functions, except that their " "name ends with a bang `!`, but instead of generating a function call, macros " "are expanded into source code that gets compiled with the rest of the " "program. However, unlike macros in C and other languages, Rust macros are " "expanded into abstract syntax trees, rather than string preprocessing, so " "you don't get unexpected precedence bugs." msgstr "" "Rustはメタプログラミングを可能にする、パワフルなマクロシステムを備えていま" "す。これまで見てきたように、マクロは`!`で終わることを除けば関数のように見えま" "す。関数と違うのは関数呼び出しを生成する代わりに、ソースコード中に展開され、" "周囲のプログラムとともにコンパイルされる点です。しかし、Cやその他の言語のマク" "ロが文字列のプリプロセッシングをするのと異なり、Rustのマクロは抽象構文木へと" "展開されるので、予期せぬ演算子の優先順位のバグに出くわすことがありません。" #: src/macros.md:11 msgid "Macros are created using the `macro_rules!` macro." msgstr "マクロを作成するには`macro_rules!`というマクロを使用します。" #: src/macros.md:14 msgid "// This is a simple macro named `say_hello`.\n" msgstr "// `say_hello`という名のシンプルなマクロ\n" #: src/macros.md:16 msgid "// `()` indicates that the macro takes no argument.\n" msgstr "// `()`はマクロが引数をとらないことを示します。\n" #: src/macros.md:18 msgid "// The macro will expand into the contents of this block.\n" msgstr "" "// マクロは（訳注: プリコンパイルの段階で）\n" " // このブロックの内容に展開されます。\n" #: src/macros.md:19 msgid "\"Hello!\"" msgstr "\"Hello!\"" #: src/macros.md:24 msgid "// This call will expand into `println!(\"Hello!\")`\n" msgstr "// この呼び出しは`println!(\"Hello!\");`に置き換えられます。\n" #: src/macros.md:29 msgid "So why are macros useful?" msgstr "ではどうしてマクロは便利なのでしょうか？" #: src/macros.md:31 msgid "" "Don't repeat yourself. There are many cases where you may need similar " "functionality in multiple places but with different types. Often, writing a " "macro is a useful way to avoid repeating code. (More on this later)" msgstr "" "同じことを繰り返し書いてはいけないから。複数の場所で、別の型だけれど似たよう" "な機能が必要な時がよくあります。しばしば、マクロはコードを繰り返し書くのを避" "ける有用な手段なのです（あとで詳述）。" #: src/macros.md:35 msgid "" "Domain-specific languages. Macros allow you to define special syntax for a " "specific purpose. (More on this later)" msgstr "" "ドメイン特化言語であるから。マクロを使うと、特定の目的のための特定の構文を定" "義することができます（あとで詳述）。" #: src/macros.md:38 msgid "" "Variadic interfaces. Sometimes you want to define an interface that takes a " "variable number of arguments. An example is `println!` which could take any " "number of arguments, depending on the format string. (More on this later)" msgstr "" "可変個引数によるインターフェース。取る引数の数が可変であるようなインター" "フェースを定義したくなることもあるでしょう。例えば、`println!`は、フォーマッ" "ト文字列に依存した任意の数の引数を取ることができます（あとで詳述）！" #: src/macros/syntax.md:3 msgid "" "In following subsections, we will show how to define macros in Rust. There " "are three basic ideas:" msgstr "" "以下のサブセクションでは、Rustにおいてマクロを定義する方法を示します。3つの基" "本的な考え方があります：" #: src/macros/syntax.md:6 msgid "[Patterns and Designators](designators.md)" msgstr "[パターンと識別子](designators.md)" #: src/macros/syntax.md:7 msgid "[Overloading](overload.md)" msgstr "[オーバーロード](overload.md)" #: src/macros/syntax.md:8 msgid "[Repetition](repeat.md)" msgstr "[繰り返し](repeat.md)" #: src/macros/designators.md:3 msgid "" "The arguments of a macro are prefixed by a dollar sign `$` and type " "annotated with a _designator_:" msgstr "" "macroの引数は`$`が頭につきます。型は *識別子* でアノテーションされます。" #: src/macros/designators.md:8 msgid "" "// This macro takes an argument of designator `ident` and\n" " // creates a function named `$func_name`.\n" " // The `ident` designator is used for variable/function names.\n" msgstr "" "// このマクロは`ident`識別子に対応する値を引数として取り\n" " // `$func_name`という名の関数を作成します。\n" " // `ident`識別子は関数・変数の名前用の識別子です。\n" #: src/macros/designators.md:13 msgid "// The `stringify!` macro converts an `ident` into a string.\n" msgstr "// `stringify!`というマクロは`ident`を文字列に変えます。\n" #: src/macros/designators.md:14 msgid "\"You called {:?}()\"" msgstr "\"You called {:?}()\"" #: src/macros/designators.md:19 msgid "// Create functions named `foo` and `bar` with the above macro.\n" msgstr "// 上のマクロを利用して`foo`、`bar`という名の関数を作成します。\n" #: src/macros/designators.md:25 msgid "" "// This macro takes an expression of type `expr` and prints\n" " // it as a string along with its result.\n" " // The `expr` designator is used for expressions.\n" msgstr "" "// このマクロは`expr`識別子に対応する値を引数として取り、\n" " // その結果を文字列として出力します。\n" " // `expr`識別子は式に対応します。\n" #: src/macros/designators.md:29 msgid "// `stringify!` will convert the expression *as it is* into a string.\n" msgstr "// `stringify!`は式を *そのままの形で* 文字列に変換します\n" #: src/macros/designators.md:30 msgid "\"{:?} = {:?}\"" msgstr "\"{:?} = {:?}\"" #: src/macros/designators.md:42 msgid "// Recall that blocks are expressions too!\n" msgstr "// ブロックも式の一種であることを思い出しましょう！\n" #: src/macros/designators.md:51 msgid "These are some of the available designators:" msgstr "使用できる識別子には以下のようなものがあります。" #: src/macros/designators.md:53 msgid "`block`" msgstr "`block`" #: src/macros/designators.md:54 msgid "`expr` is used for expressions" msgstr "`expr` 式に使用。" #: src/macros/designators.md:55 msgid "`ident` is used for variable/function names" msgstr "`ident` 関数、変数の名前に使用。" #: src/macros/designators.md:56 msgid "`item`" msgstr "`item`" #: src/macros/designators.md:57 msgid "`literal` is used for literal constants" msgstr "`literal` はリテラル定数。" #: src/macros/designators.md:58 msgid "`pat` (_pattern_)" msgstr "`pat`（*パターン*）" #: src/macros/designators.md:59 msgid "`path`" msgstr "`path`" #: src/macros/designators.md:60 msgid "`stmt` (_statement_)" msgstr "`stmt`（*宣言*）" #: src/macros/designators.md:61 msgid "`tt` (_token tree_)" msgstr "`tt`（*トークンツリー*）" #: src/macros/designators.md:62 msgid "`ty` (_type_)" msgstr "`ty`（*型*）" #: src/macros/designators.md:63 msgid "`vis` (_visibility qualifier_)" msgstr "`vis`（*可視性修飾子*）（訳注：`pub (crate)`とか）" #: src/macros/designators.md:65 msgid "" "For a complete list, see the [Rust Reference](https://doc.rust-lang.org/" "reference/macros-by-example.html)." msgstr "" "完全なリストを見るには、[Rustリファレンス](https://doc.rust-lang.org/" "reference/macros-by-example.html)を読んでください。" #: src/macros/overload.md:3 msgid "" "Macros can be overloaded to accept different combinations of arguments. In " "that regard, `macro_rules!` can work similarly to a match block:" msgstr "" "マクロは異なる引数の組み合わせを取るようにオーバーロードすることができるた" "め、`macro_rules!`はマッチと似たような使い方をすることができます。" #: src/macros/overload.md:7 msgid "" "// `test!` will compare `$left` and `$right`\n" "// in different ways depending on how you invoke it:\n" msgstr "" "// `test!`は`$left`と`$right`を異なる呼び出し方に応じて\n" "// 比較します。\n" #: src/macros/overload.md:10 msgid "" "// Arguments don't need to be separated by a comma.\n" " // Any template can be used!\n" msgstr "" "// 引数はカンマで区切らなくても構いません。\n" " // テンプレートの形態は自由！\n" #: src/macros/overload.md:13 msgid "\"{:?} and {:?} is {:?}\"" msgstr "\"{:?} and {:?} is {:?}\"" #: src/macros/overload.md:18 msgid "// ^ each arm must end with a semicolon.\n" msgstr "// ^ それぞれの`=>`節はセミコロンで終わる必要があります。\n" #: src/macros/overload.md:20 msgid "\"{:?} or {:?} is {:?}\"" msgstr "\"{:?} or {:?} is {:?}\"" #: src/macros/repeat.md:3 msgid "" "Macros can use `+` in the argument list to indicate that an argument may " "repeat at least once, or `*`, to indicate that the argument may repeat zero " "or more times." msgstr "" "マクロは引数のリストの中で`+`を使うことができ、そうすることによって、引数が少" "なくとも1回以上繰り返されるということを示すことができます。同様に`*`の場合" "は、0以上を示します。" #: src/macros/repeat.md:7 msgid "" "In the following example, surrounding the matcher with `$(...),+` will match " "one or more expression, separated by commas. Also note that the semicolon is " "optional on the last case." msgstr "" "以下の例では、マッチ対象を `$(...),+`で囲むことにより、カンマで区切られた1つ" "以上の式とマッチします。最後のセミコロンは必須ではないことに注目しましょう。" #: src/macros/repeat.md:12 msgid "// `find_min!` will calculate the minimum of any number of arguments.\n" msgstr "// `find_min!`は引数として与えられた数字の中の最低の値を計算します。\n" #: src/macros/repeat.md:14 msgid "// Base case:\n" msgstr "// 基本となるケース\n" #: src/macros/repeat.md:16 msgid "// `$x` followed by at least one `$y,`\n" msgstr "// `$x`に少なくとも1つの`$y`が続く場合\n" #: src/macros/repeat.md:18 msgid "// Call `find_min!` on the tail `$y`\n" msgstr "// `find_min!`を残りの`$y`に対して再帰的に適用。\n" #: src/macros/dry.md:3 msgid "" "Macros allow writing DRY code by factoring out the common parts of functions " "and/or test suites. Here is an example that implements and tests the `+=`, " "`*=` and `-=` operators on `Vec`:" msgstr "" "マクロは関数やテストなどにおいて、共通の部分を抽出することでDRYなコードを書く" "のに役立ちます。ここでは`Vec`に`+=`、`*=`、`-=`を実装、テストするにあたっ" "て、マクロがどのように役立つかを見ていきます。" #: src/macros/dry.md:11 msgid "" "// The `tt` (token tree) designator is used for\n" " // operators and tokens.\n" msgstr "// `tt` （トークン木）識別子は演算子とトークン用の識別子です。\n" #: src/macros/dry.md:15 msgid "\"{:?}: dimension mismatch: {:?} {:?} {:?}\"" msgstr "\"{:?}: dimension mismatch: {:?} {:?} {:?}\"" #: src/macros/dry.md:30 msgid "// *x = x.$method(*y);\n" msgstr "// *x = x.$method(*y);\n" #: src/macros/dry.md:35 msgid "// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.\n" msgstr "// `add_assign`、`mul_assign`、`sub_assign`、関数を実装\n" #: src/macros/dry.md:60 msgid "// Test `add_assign`, `mul_assign`, and `sub_assign`.\n" msgstr "// `add_assign`と`mul_assign`と`sub_assign`をテスト\n" #: src/macros/dsl.md:1 msgid "Domain Specific Languages (DSLs)" msgstr "Domain Specific Languages (ドメイン特化言語、DSLs)" #: src/macros/dsl.md:3 msgid "" "A DSL is a mini \"language\" embedded in a Rust macro. It is completely " "valid Rust because the macro system expands into normal Rust constructs, but " "it looks like a small language. This allows you to define concise or " "intuitive syntax for some special functionality (within bounds)." msgstr "" "ここで言うDSLとはRustマクロに埋め込まれた小さな「言語」のことです。マクロ機能" "は通常のRustのプログラムへと展開されるので、これは完全に正当なRustなのです" "が、まるで小さな言語であるかのように見えます。これにより、（一定の条件のもと" "で）なんらかの特定の機能のための簡潔・直感的な構文を定義することができるよう" "になります。" #: src/macros/dsl.md:8 msgid "" "Suppose that I want to define a little calculator API. I would like to " "supply an expression and have the output printed to console." msgstr "" "ちょっとした計算機APIを定義したいとしましょう。式を与えると、出力がコンソール" "に書き出されるようにしたいです。" #: src/macros/dsl.md:15 msgid "// Force types to be unsigned integers\n" msgstr "// 型を整数に制約。\n" #: src/macros/dsl.md:16 src/macros/variadics.md:15 msgid "\"{} = {}\"" msgstr "\"{} = {}\"" #: src/macros/dsl.md:23 msgid "// hehehe `eval` is _not_ a Rust keyword!\n" msgstr "// `eval`はRustのキーワード *じゃない* よね！\n" #: src/macros/dsl.md:32 src/macros/variadics.md:35 msgid "Output:" msgstr "出力はこうなります：" #: src/macros/dsl.md:39 msgid "" "This was a very simple example, but much more complex interfaces have been " "developed, such as [`lazy_static`](https://crates.io/crates/lazy_static) or " "[`clap`](https://crates.io/crates/clap)." msgstr "" "これはとても単純な例ですが、[`lazy_static`](https://crates.io/crates/" "lazy_static)や[`clap`](https://crates.io/crates/clap)のように、もっと複雑なイ" "ンターフェースも開発されています。" #: src/macros/dsl.md:43 msgid "" "Also, note the two pairs of braces in the macro. The outer ones are part of " "the syntax of `macro_rules!`, in addition to `()` or `[]`." msgstr "" "また、マクロの中に2組の括弧があることにも注目してください。外側のは、`()`や" "`[]`に加え、`macro_rules!`の構文の一部です。" #: src/macros/variadics.md:1 msgid "Variadic Interfaces" msgstr "可変個引数によるインターフェース" #: src/macros/variadics.md:3 msgid "" "A _variadic_ interface takes an arbitrary number of arguments. For example, " "`println!` can take an arbitrary number of arguments, as determined by the " "format string." msgstr "" "*可変個引数の*インターフェースとは、任意の数の引数を取るものです。例えば、" "`println!`は、フォーマット文字列の定義に従い、任意の数の引数を取ることができ" "ます。" #: src/macros/variadics.md:7 msgid "" "We can extend our `calculate!` macro from the previous section to be " "variadic:" msgstr "" "前のセクションの`calculate!`マクロを、可変個引数に拡張することができます：" #: src/macros/variadics.md:11 msgid "// The pattern for a single `eval`\n" msgstr "// 単一の`eval`のためのパターン\n" #: src/macros/variadics.md:14 msgid "// Force types to be integers\n" msgstr "// 強制的に型を整数にします。\n" #: src/macros/variadics.md:19 msgid "// Decompose multiple `eval`s recursively\n" msgstr "// 複数の`eval`を再帰的に分解します。\n" #: src/macros/variadics.md:27 msgid "// Look ma! Variadic `calculate!`!\n" msgstr "// ほら！可変な`calculate!`だよ！\n" #: src/error.md:3 msgid "" "Error handling is the process of handling the possibility of failure. For " "example, failing to read a file and then continuing to use that _bad_ input " "would clearly be problematic. Noticing and explicitly managing those errors " "saves the rest of the program from various pitfalls." msgstr "" "エラーハンドリングとは失敗の起きる可能性を扱うプロセスのことです。例えば、" "ファイルを読み込むのに失敗した際、その *誤った* インプットを使い続けるのは明" "らかに問題です。そのようなエラーを通知して明示的に扱うことで、残りのプログラ" "ムに問題が波及することを防ぐことができるようになります。" #: src/error.md:8 msgid "" "There are various ways to deal with errors in Rust, which are described in " "the following subchapters. They all have more or less subtle differences and " "different use cases. As a rule of thumb:" msgstr "" "Rustには、これからこの章で見ていく通り、エラーを処理するための様々な方法が存" "在します。それらは全て僅かに異なり、ユースケースも異なります。経験則として：" #: src/error.md:12 msgid "" "An explicit `panic` is mainly useful for tests and dealing with " "unrecoverable errors. For prototyping it can be useful, for example when " "dealing with functions that haven't been implemented yet, but in those cases " "the more descriptive `unimplemented` is better. In tests `panic` is a " "reasonable way to explicitly fail." msgstr "" "明示的な`panic`はテストや復旧不可能なエラーに対して効果的です。プロトタイプに" "も便利で、例えば未実装の関数を扱う時などに有効ですが、このような場合にはより" "叙述的な`unimplemented`の方が良いでしょう。テストにおいては`panic`は明示的に" "テストを失敗させるための良い手法になるでしょう。" #: src/error.md:17 msgid "" "The `Option` type is for when a value is optional or when the lack of a " "value is not an error condition. For example the parent of a directory - `/` " "and `C:` don't have one. When dealing with `Option`s, `unwrap` is fine for " "prototyping and cases where it's absolutely certain that there is guaranteed " "to be a value. However `expect` is more useful since it lets you specify an " "error message in case something goes wrong anyway." msgstr "" "`Option`型は値があるとは限らない場合や、値が無いことがエラーの条件とならない" "場合に有効です。例えば親ディレクトリ（`/`や`C:`はそれを持ちません）などです。" "`Option`を扱う際は、`unwrap`がプロトタイプや値が確実に存在することが約束され" "るケースに使えます。しかし、`expect`の方が何かが上手くいかなかった際にエラー" "メッセージを指定することができるため、より便利でしょう。" #: src/error.md:24 msgid "" "When there is a chance that things do go wrong and the caller has to deal " "with the problem, use `Result`. You can `unwrap` and `expect` them as well " "(please don't do that unless it's a test or quick prototype)." msgstr "" "何かが上手くいかない可能性があったり、呼び出し元が問題を処理しなければならな" "い時は、`Result`を使いましょう。`unwrap`や`expect`を実行することもできます" "（テストや短期的なプロトタイプ以外では使わないでください）。" #: src/error.md:28 msgid "" "For a more rigorous discussion of error handling, refer to the error " "handling section in the [official book](https://doc.rust-lang.org/book/" "ch09-00-error-handling.html)." msgstr "" "より詳細なエラーハンドリングに関する議論については、[オフィシャルブック]" "(https://doc.rust-lang.org/book/ch09-00-error-handling.html)の該当の章を参考" "にしてください。" #: src/error/panic.md:3 msgid "" "The simplest error handling mechanism we will see is `panic`. It prints an " "error message, starts unwinding the stack, and usually exits the program. " "Here, we explicitly call `panic` on our error condition:" msgstr "" "`panic`は、最もシンプルなエラーハンドリングの仕組みです。エラーメッセージの出" "力、スタックの巻き戻し、そして多くの場合プログラムの終了を実行します。例とし" "て、エラー条件に対して明示的に`panic`を呼び出してみましょう。" #: src/error/panic.md:9 src/error/abort_unwind.md:10 msgid "// You shouldn't drink too much sugary beverages.\n" msgstr "// 甘すぎる飲み物を飲むべきではありません。\n" #: src/error/panic.md:10 src/error/panic.md:17 src/error/abort_unwind.md:11 #: src/error/abort_unwind.md:24 src/error/abort_unwind.md:42 #: src/error/abort_unwind.md:51 src/error/option_unwrap.md:32 #: src/error/option_unwrap.md:43 src/error/option_unwrap.md:50 msgid "\"lemonade\"" msgstr "\"lemonade\"" #: src/error/panic.md:10 src/error/option_unwrap.md:43 msgid "\"AAAaaaaa!!!!\"" msgstr "\"AAAaaaaa!!!!\"" #: src/error/panic.md:12 src/error/abort_unwind.md:18 #: src/error/abort_unwind.md:45 msgid "\"Some refreshing {} is all I need.\"" msgstr "\"Some refreshing {} is all I need.\"" #: src/error/panic.md:16 src/error/abort_unwind.md:23 #: src/error/abort_unwind.md:50 src/error/option_unwrap.md:49 msgid "\"water\"" msgstr "\"water\"" #: src/error/panic.md:18 msgid "\"still water\"" msgstr "\"still water\"" #: src/error/panic.md:22 msgid "" "The first call to `drink` works. The second panics and thus the third is " "never called." msgstr "" #: src/error/abort_unwind.md:1 msgid "`abort` and `unwind`" msgstr "" #: src/error/abort_unwind.md:3 msgid "" "The previous section illustrates the error handling mechanism `panic`. " "Different code paths can be conditionally compiled based on the panic " "setting. The current values available are `unwind` and `abort`." msgstr "" #: src/error/abort_unwind.md:6 msgid "" "Building on the prior lemonade example, we explicitly use the panic strategy " "to exercise different lines of code." msgstr "" #: src/error/abort_unwind.md:12 msgid "\"abort\"" msgstr "\"abort\"" #: src/error/abort_unwind.md:13 src/error/abort_unwind.md:38 msgid "\"This is not your party. Run!!!!\"" msgstr "\"This is not your party. Run!!!!\"" #: src/error/abort_unwind.md:15 src/error/abort_unwind.md:33 msgid "\"Spit it out!!!!\"" msgstr "\"Spit it out!!!!\"" #: src/error/abort_unwind.md:28 msgid "" "Here is another example focusing on rewriting `drink()` and explicitly use " "the `unwind` keyword." msgstr "" #: src/error/abort_unwind.md:31 src/error/abort_unwind.md:36 msgid "\"unwind\"" msgstr "\"unwind\"" #: src/error/abort_unwind.md:55 msgid "" "The panic strategy can be set from the command line by using `abort` or " "`unwind`." msgstr "" #: src/error/option_unwrap.md:3 msgid "" "In the last example, we showed that we can induce program failure at will. " "We told our program to `panic` if we drink a sugary lemonade. But what if we " "expect _some_ drink but don't receive one? That case would be just as bad, " "so it needs to be handled!" msgstr "" "以前の例では、甘いレモネードを飲んだ際に`panic`を呼び出すことによって、自由に" "プログラムの実行を失敗させられることが分かりました。では、何らかの飲み物を期" "待しているにもかかわらず、何も受け取らなかったらどうなるでしょう？これは悲惨" "なケースになるので、エラーハンドリングする必要があります！" #: src/error/option_unwrap.md:8 msgid "" "We _could_ test this against the null string (`\"\"`) as we do with a " "lemonade. Since we're using Rust, let's instead have the compiler point out " "cases where there's no drink." msgstr "" "このケースに対して、レモネードと同じように、空文字列（`\"\"`）と比較すること" "もできますが、せっかくRustを使っているので、その代わりにコンパイラに飲み物が" "ないケースを指摘させてみましょう。" #: src/error/option_unwrap.md:12 msgid "" "An `enum` called `Option` in the `std` library is used when absence is a " "possibility. It manifests itself as one of two \"options\":" msgstr "" "`std`ライブラリの中の、`Option`と呼ばれる`enum`は、任意の型`T`である変数の" "値が存在しない可能性がある場合に用いられます。値の状態によって、下記２つのパ" "ターンのうちの１つとして扱われます。" #: src/error/option_unwrap.md:15 msgid "`Some(T)`: An element of type `T` was found" msgstr "`Some(T)`：型`T`の値がある場合" #: src/error/option_unwrap.md:16 msgid "`None`: No element was found" msgstr "`None`：値が存在しない場合" #: src/error/option_unwrap.md:18 msgid "" "These cases can either be explicitly handled via `match` or implicitly with " "`unwrap`. Implicit handling will either return the inner element or `panic`." msgstr "" "これらは`match`を用いて明示的に扱うこともできますし、`unwrap`で暗黙に処理する" "こともできます。後者は`Some`の中の値を返すか`panic`するかのどちらかです。" #: src/error/option_unwrap.md:21 msgid "" "Note that it's possible to manually customize `panic` with [expect](https://" "doc.rust-lang.org/std/option/enum.Option.html#method.expect), but `unwrap` " "otherwise leaves us with a less meaningful output than explicit handling. In " "the following example, explicit handling yields a more controlled result " "while retaining the option to `panic` if desired." msgstr "" "[expect](https://doc.rust-lang.org/std/option/enum.Option.html#method.expect)" "メソッドを用いて、`panic`を手動でカスタマイズできることに触れておきましょう。" "これは（`unwrap`をそのまま用いた場合よりも）内容が理解しやすいエラーメッセー" "ジを出力するのに役立ちます。次の例では、結果をより明示的に、可能ならいつでも" "`panic`できるように扱っていきます。" #: src/error/option_unwrap.md:27 msgid "" "// The adult has seen it all, and can handle any drink well.\n" "// All drinks are handled explicitly using `match`.\n" msgstr "" "// 大人は経験豊富なので、大体どんな飲み物にも対処できます。\n" "// あらゆる飲み物は`match`を用いて手動で処理されます。\n" #: src/error/option_unwrap.md:30 msgid "// Specify a course of action for each case.\n" msgstr "" #: src/error/option_unwrap.md:32 msgid "\"Yuck! Too sugary.\"" msgstr "\"Yuck! Too sugary.\"" #: src/error/option_unwrap.md:33 msgid "\"{}? How nice.\"" msgstr "\"{}? How nice.\"" #: src/error/option_unwrap.md:34 msgid "\"No drink? Oh well.\"" msgstr "\"No drink? Oh well.\"" #: src/error/option_unwrap.md:37 msgid "" "// Others will `panic` before drinking sugary drinks.\n" "// All drinks are handled implicitly using `unwrap`.\n" msgstr "" "// 他の人たちは甘い飲み物を飲む前に`panic`します。\n" "// 全ての飲み物は`unwrap`を使って暗黙的に処理されます。\n" #: src/error/option_unwrap.md:41 msgid "// `unwrap` returns a `panic` when it receives a `None`.\n" msgstr "// `unwrap`を使用すると値が`None`だった際に`panic`を返します。\n" #: src/error/option_unwrap.md:45 msgid "\"I love {}s!!!!!\"" msgstr "\"I love {}s!!!!!\"" #: src/error/option_unwrap.md:57 msgid "\"coffee\"" msgstr "\"coffee\"" #: src/error/option_unwrap/question_mark.md:3 msgid "" "You can unpack `Option`s by using `match` statements, but it's often easier " "to use the `?` operator. If `x` is an `Option`, then evaluating `x?` will " "return the underlying value if `x` is `Some`, otherwise it will terminate " "whatever function is being executed and return `None`." msgstr "" "`Option`をアンパックするには`match`文を使うこともできますが、`?`を使う方が簡" "単になることが多いでしょう。`Option`の`x`があるとすると、`x?`を評価した値は、" "`x`が`Some`の場合は`x`に格納された値となり、そうでなければ実行中の関数を終了" "させ、`None`を返します。" #: src/error/option_unwrap/question_mark.md:10 msgid "" "// If `current_age` is `None`, this returns `None`.\n" "\t// If `current_age` is `Some`, the inner `u8` value + 1\n" " // gets assigned to `next_age`\n" msgstr "" "// `current_age`が`None`の場合、`None`を返します。\n" " // `current_age`が`Some`の場合、内部の`u8`型の値が`next_age`に代入されま" "す。\n" #: src/error/option_unwrap/question_mark.md:14 msgid "\"Next year I will be {}\"" msgstr "\"Next year I will be {}\"" #: src/error/option_unwrap/question_mark.md:18 msgid "You can chain many `?`s together to make your code much more readable." msgstr "多くの`?`を共に使うことで、リーダブルなコードを書くことができます。" #: src/error/option_unwrap/question_mark.md:38 msgid "" "// Gets the area code of the phone number of the person's job, if it " "exists.\n" msgstr "// その人の市外局番が存在する場合、取得します。\n" #: src/error/option_unwrap/question_mark.md:40 msgid "" "// This would need many nested `match` statements without the `?` operator.\n" " // It would take a lot more code - try writing it yourself and see " "which\n" " // is easier.\n" msgstr "" "// `?`がなければ、多くのネストされた`match`文を必要とするため、\n" " // より長いコードとなります。\n" " // 実際に書いて、どちらの方が簡単か確かめてみましょう。\n" #: src/error/option_unwrap/map.md:3 msgid "" "`match` is a valid method for handling `Option`s. However, you may " "eventually find heavy usage tedious, especially with operations only valid " "with an input. In these cases, [combinators](https://doc.rust-lang.org/" "reference/glossary.html#combinator) can be used to manage control flow in a " "modular fashion." msgstr "" "`match`は`Option`を扱うのに適したメソッドです。しかし、大量にこれを使用してい" "るとじきに億劫になってくるでしょう。引数の値が有効である（訳注: この場合は" "`None`でない）必要がある関数を扱う際には特にそうです。そうした場合には、[コン" "ビネータ](https://doc.rust-lang.org/reference/glossary.html#combinator)を使う" "と、処理の流れをモジュール化されたやり方で管理できます。" #: src/error/option_unwrap/map.md:8 msgid "" "`Option` has a built in method called `map()`, a combinator for the simple " "mapping of `Some -> Some` and `None -> None`. Multiple `map()` calls can be " "chained together for even more flexibility." msgstr "" "`Some -> Some`あるいは`None -> None`の単純な操作を適用する必要がある場合に" "は、`Option`は`map()`というビルトインのメソッドを提供していますので、これを使" "用しましょう。`map()`のフレキシビリティは、複数の`map()`をチェインしなければ" "ならない場合にさらに際立ちます。" #: src/error/option_unwrap/map.md:12 msgid "" "In the following example, `process()` replaces all functions previous to it " "while staying compact." msgstr "" "以下の例では、`process()`が直前の関数全てを用いた場合と同じ機能を、よりコンパ" "クトに果たしているのがわかります。" #: src/error/option_unwrap/map.md:23 msgid "" "// Peeling food. If there isn't any, then return `None`.\n" "// Otherwise, return the peeled food.\n" msgstr "" "// 食べ物の皮をむく。存在しない場合は単純に`None`を返します。\n" "// そうでなければ皮を向いた食べ物を返します。\n" #: src/error/option_unwrap/map.md:32 msgid "" "// Chopping food. If there isn't any, then return `None`.\n" "// Otherwise, return the chopped food.\n" msgstr "" "// 上と同じように、食べ物を切る前に、皮を向いた食べ物の有無を知る必要がありま" "す。\n" #: src/error/option_unwrap/map.md:41 msgid "" "// Cooking food. Here, we showcase `map()` instead of `match` for case " "handling.\n" msgstr "" "// 上のチェックと同様ですが`match`の代わりに`map()`を使用しています。\n" #: src/error/option_unwrap/map.md:46 msgid "" "// A function to peel, chop, and cook food all in sequence.\n" "// We chain multiple uses of `map()` to simplify the code.\n" msgstr "" "// 複数の`map()`をチェインさせて、上のプロセスをシンプルにすることもできま" "す。\n" #: src/error/option_unwrap/map.md:54 msgid "// Check whether there's food or not before trying to eat it!\n" msgstr "// 食べる前に、食べ物の有無をチェックするのは大事ですよね!\n" #: src/error/option_unwrap/map.md:58 msgid "\"Mmm. I love {:?}\"" msgstr "\"Mmm. I love {:?}\"" #: src/error/option_unwrap/map.md:59 msgid "\"Oh no! It wasn't edible.\"" msgstr "\"Oh no! It wasn't edible.\"" #: src/error/option_unwrap/map.md:70 msgid "// Let's try the simpler looking `process()` now.\n" msgstr "// よりシンプルな見た目の`process()`を使用しましょう。\n" #: src/error/option_unwrap/map.md:81 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" msgstr "" "[クロージャ](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" #: src/error/option_unwrap/and_then.md:3 msgid "" "`map()` was described as a chainable way to simplify `match` statements. " "However, using `map()` on a function that returns an `Option` results in " "the nested `Option>`. Chaining multiple calls together can then " "become confusing. That's where another combinator called `and_then()`, known " "in some languages as flatmap, comes in." msgstr "" "先ほどは`map()`を、チェイン構文を用いて`match`文を単純化する物として説明しま" "した。しかし`Option`を返す関数に対しての`map()`の使用はネストした" "`Option>`を生じさせます。ですので、複数の関数呼び出しをチェインさせ" "ることは混乱を招く場合があります。そんな時こそ`and_then()`の出番です。他の言" "語ではflatmapと呼ばれることもあります。" #: src/error/option_unwrap/and_then.md:9 msgid "" "`and_then()` calls its function input with the wrapped value and returns the " "result. If the `Option` is `None`, then it returns `None` instead." msgstr "" "`and_then()`は引数として与えられた関数にラップされた値を渡しますが、その値が" "`None`だった場合は`None`を返します。" #: src/error/option_unwrap/and_then.md:11 msgid "" "In the following example, `cookable_v3()` results in an `Option`. " "Using `map()` instead of `and_then()` would have given an " "`Option>`, which is an invalid type for `eat()`." msgstr "" "以下の例では`cookable_v3()`は`Option`を返すため、`and_then()`ではなく" "`map()`を使用すると最終的に`Option>`になります。これは`eat()`に" "は不適切な型です。" #: src/error/option_unwrap/and_then.md:20 msgid "// We don't have the ingredients to make Sushi.\n" msgstr "// 我々は寿司の材料を持っていません。\n" #: src/error/option_unwrap/and_then.md:28 msgid "// We have the recipe for everything except Cordon Bleu.\n" msgstr "// コルドン・ブルーのレシピも持っていません。\n" #: src/error/option_unwrap/and_then.md:36 msgid "" "// To make a dish, we need both the recipe and the ingredients.\n" "// We can represent the logic with a chain of `match`es:\n" msgstr "" "// 料理を作るためには、材料とレシピの両方が必要。\n" "// ロジックの流れを`match`のチェインで表します。\n" #: src/error/option_unwrap/and_then.md:45 msgid "" "// This can conveniently be rewritten more compactly with `and_then()`:\n" msgstr "" "// `and_then()`を用いることで、同じことをよりコンパクトに表現できます。\n" #: src/error/option_unwrap/and_then.md:50 msgid "" "// Otherwise we'd need to `flatten()` an `Option>`\n" "// to get an `Option`:\n" msgstr "" #: src/error/option_unwrap/and_then.md:59 msgid "\"Yay! On {:?} we get to eat {:?}.\"" msgstr "\"Yay! On {:?} we get to eat {:?}.\"" #: src/error/option_unwrap/and_then.md:60 msgid "\"Oh no. We don't get to eat on {:?}?\"" msgstr "\"Oh no. We don't get to eat on {:?}?\"" #: src/error/option_unwrap/and_then.md:75 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then), and [`Option::flatten()`]" "(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" msgstr "" "[クロージャ](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then), [`Option::flatten()`](https://" "doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" #: src/error/option_unwrap/defaults.md:1 msgid "Unpacking options and defaults" msgstr "" #: src/error/option_unwrap/defaults.md:3 msgid "" "There is more than one way to unpack an `Option` and fall back on a default " "if it is `None`. To choose the one that meets our needs, we need to consider " "the following:" msgstr "" #: src/error/option_unwrap/defaults.md:4 msgid "do we need eager or lazy evaluation?" msgstr "" #: src/error/option_unwrap/defaults.md:5 msgid "" "do we need to keep the original empty value intact, or modify it in place?" msgstr "" #: src/error/option_unwrap/defaults.md:7 msgid "`or()` is chainable, evaluates eagerly, keeps empty value intact" msgstr "" #: src/error/option_unwrap/defaults.md:9 msgid "" "`or()`is chainable and eagerly evaluates its argument, as is shown in the " "following example. Note that because `or`'s arguments are evaluated eagerly, " "the variable passed to `or` is moved." msgstr "" #: src/error/option_unwrap/defaults.md:21 #: src/error/option_unwrap/defaults.md:54 msgid "\"first_available_fruit: {:?}\"" msgstr "\"first_available_fruit: {:?}\"" #: src/error/option_unwrap/defaults.md:22 msgid "// first_available_fruit: Some(Orange)\n" msgstr "" #: src/error/option_unwrap/defaults.md:24 msgid "" "// `or` moves its argument.\n" " // In the example above, `or(orange)` returned a `Some`, so `or(apple)` " "was not invoked.\n" " // But the variable named `apple` has been moved regardless, and cannot " "be used anymore.\n" " // println!(\"Variable apple was moved, so this line won't compile: " "{:?}\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" #: src/error/option_unwrap/defaults.md:32 msgid "`or_else()` is chainable, evaluates lazily, keeps empty value intact" msgstr "" #: src/error/option_unwrap/defaults.md:34 msgid "" "Another alternative is to use `or_else`, which is also chainable, and " "evaluates lazily, as is shown in the following example:" msgstr "" #: src/error/option_unwrap/defaults.md:43 msgid "\"Providing kiwi as fallback\"" msgstr "\"Providing kiwi as fallback\"" #: src/error/option_unwrap/defaults.md:47 #: src/error/option_unwrap/defaults.md:91 msgid "\"Providing lemon as fallback\"" msgstr "\"Providing lemon as fallback\"" #: src/error/option_unwrap/defaults.md:55 msgid "" "// Providing kiwi as fallback\n" " // first_available_fruit: Some(Kiwi)\n" msgstr "" #: src/error/option_unwrap/defaults.md:60 msgid "`get_or_insert()` evaluates eagerly, modifies empty value in place" msgstr "" #: src/error/option_unwrap/defaults.md:62 msgid "" "To make sure that an `Option` contains a value, we can use `get_or_insert` " "to modify it in place with a fallback value, as is shown in the following " "example. Note that `get_or_insert` eagerly evaluates its parameter, so " "variable `apple` is moved:" msgstr "" #: src/error/option_unwrap/defaults.md:72 #: src/error/option_unwrap/defaults.md:96 msgid "\"first_available_fruit is: {:?}\"" msgstr "\"first_available_fruit is: {:?}\"" #: src/error/option_unwrap/defaults.md:73 #: src/error/option_unwrap/defaults.md:97 msgid "\"my_fruit is: {:?}\"" msgstr "\"my_fruit is: {:?}\"" #: src/error/option_unwrap/defaults.md:74 msgid "" "// first_available_fruit is: Apple\n" " // my_fruit is: Some(Apple)\n" " //println!(\"Variable named `apple` is moved: {:?}\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" #: src/error/option_unwrap/defaults.md:81 msgid "`get_or_insert_with()` evaluates lazily, modifies empty value in place" msgstr "" #: src/error/option_unwrap/defaults.md:83 msgid "" "Instead of explicitly providing a value to fall back on, we can pass a " "closure to `get_or_insert_with`, as follows:" msgstr "" #: src/error/option_unwrap/defaults.md:98 msgid "" "// Providing lemon as fallback\n" " // first_available_fruit is: Lemon\n" " // my_fruit is: Some(Lemon)\n" msgstr "" #: src/error/option_unwrap/defaults.md:102 msgid "" "// If the Option has a value, it is left unchanged, and the closure is not " "invoked\n" msgstr "" #: src/error/option_unwrap/defaults.md:105 msgid "\"should_be_apple is: {:?}\"" msgstr "\"should_be_apple is: {:?}\"" #: src/error/option_unwrap/defaults.md:106 msgid "\"my_apple is unchanged: {:?}\"" msgstr "\"my_apple is unchanged: {:?}\"" #: src/error/option_unwrap/defaults.md:107 msgid "" "// The output is a follows. Note that the closure `get_lemon_as_fallback` is " "not invoked\n" " // should_be_apple is: Apple\n" " // my_apple is unchanged: Some(Apple)\n" msgstr "" #: src/error/option_unwrap/defaults.md:115 msgid "" "[`closures`](https://doc.rust-lang.org/book/ch13-01-closures.html), " "[`get_or_insert`](https://doc.rust-lang.org/core/option/enum.Option." "html#method.get_or_insert), [`get_or_insert_with`](https://doc.rust-lang.org/" "core/option/enum.Option.html#method.get_or_insert_with), [`moved variables`]" "(https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html), " "[`or`](https://doc.rust-lang.org/core/option/enum.Option.html#method.or), " "[`or_else`](https://doc.rust-lang.org/core/option/enum.Option.html#method." "or_else)" msgstr "" #: src/error/result.md:3 msgid "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) is a " "richer version of the [`Option`](https://doc.rust-lang.org/std/option/enum." "Option.html) type that describes possible _error_ instead of possible " "_absence_." msgstr "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)は、リッチな" "バージョンの[`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" "型で*値の不在*の可能性の代わりに*エラー*の可能性を示します。" #: src/error/result.md:6 msgid "That is, `Result` could have one of two outcomes:" msgstr "つまり、`Result`は以下の２つの結果を持ちます。" #: src/error/result.md:8 msgid "`Ok(T)`: An element `T` was found" msgstr "`Ok`：要素`T`が見つかった場合" #: src/error/result.md:9 msgid "`Err(E)`: An error was found with element `E`" msgstr "`Err`：要素`E`とともにエラーが見つかった場合" #: src/error/result.md:11 msgid "" "By convention, the expected outcome is `Ok` while the unexpected outcome is " "`Err`." msgstr "慣例により、`Ok`が期待される結果であり、`Err`は期待されない結果です。" #: src/error/result.md:13 msgid "" "Like `Option`, `Result` has many methods associated with it. `unwrap()`, for " "example, either yields the element `T` or `panic`s. For case handling, there " "are many combinators between `Result` and `Option` that overlap." msgstr "" "`Option`と同様、`Result`は多くのメソッドを持ちます。例えば`unwrap()`は、`T`も" "しくは`panic`をもたらします。エラーハンドリングでは、`Result`と`Option`で重複" "するコンビネータが多くあります。" #: src/error/result.md:17 msgid "" "In working with Rust, you will likely encounter methods that return the " "`Result` type, such as the [`parse()`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) method. It might not always be possible to " "parse a string into the other type, so `parse()` returns a `Result` " "indicating possible failure." msgstr "" "Rustを書いていく中で、[`parse()`](https://doc.rust-lang.org/std/primitive." "str.html#method.parse)メソッドなど、`Result`型を返すメソッドを目にするでしょ" "う。文字列を他の型にパースすることは必ずしも成功する訳ではないため、`Result`" "を返すことで失敗するケースについてもカバーできるのです。" #: src/error/result.md:22 msgid "" "Let's see what happens when we successfully and unsuccessfully `parse()` a " "string:" msgstr "早速、文字列を`parse()`した場合の成功例と失敗例を見てみましょう。" #: src/error/result.md:26 msgid "// Let's try using `unwrap()` to get the number out. Will it bite us?\n" msgstr "// `unwrap()`で数字を取り出してみましょう。痛い目を見るでしょうか？\n" #: src/error/result.md:33 src/error/result.md:36 #: src/error/result/result_map.md:42 src/error/result/result_map.md:46 #: src/error/result/result_map.md:75 src/error/result/result_map.md:79 #: src/error/result/result_alias.md:36 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:36 src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:67 #: src/error/result/enter_question_mark.md:68 msgid "\"2\"" msgstr "\"2\"" #: src/error/result.md:34 src/error/result.md:37 msgid "\"double is {}\"" msgstr "\"double is {}\"" #: src/error/result.md:36 src/error/result/result_map.md:46 #: src/error/result/result_map.md:79 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:68 msgid "\"t\"" msgstr "\"t\"" #: src/error/result.md:41 msgid "" "In the unsuccessful case, `parse()` leaves us with an error for `unwrap()` " "to `panic` on. Additionally, the `panic` exits our program and provides an " "unpleasant error message." msgstr "" "失敗例では、`parse()`がエラーを返すため`unwrap()`がパニックします。そして、" "`panic`はプログラムを終了させて不快なエラーメッセージを出力します。" #: src/error/result.md:45 msgid "" "To improve the quality of our error message, we should be more specific " "about the return type and consider explicitly handling the error." msgstr "" "エラーメッセージを改善するために、リターン型に対してもっと明確になるべきで、" "またエラーを明示的に処理することを考えるべきです。" #: src/error/result.md:48 msgid "Using `Result` in `main`" msgstr "`main`内で使う`Result`" #: src/error/result.md:50 msgid "" "The `Result` type can also be the return type of the `main` function if " "specified explicitly. Typically the `main` function will be of the form:" msgstr "" "`Result`型は、明示的な指定により`main`関数のリターン型にもなります。一般に、" "`main`関数は以下のような形になるでしょう。" #: src/error/result.md:59 msgid "" "However `main` is also able to have a return type of `Result`. If an error " "occurs within the `main` function it will return an error code and print a " "debug representation of the error (using the [`Debug`](https://doc.rust-lang." "org/std/fmt/trait.Debug.html) trait). The following example shows such a " "scenario and touches on aspects covered in [the following section](result/" "early_returns.md)." msgstr "" "一方`main`で`Result`をリターン型とすることも可能です。エラーが`main`関数内で" "発生した時、エラーコードを返し、エラーに関するデバッグ表記を（[`Debug`]" "(https://doc.rust-lang.org/std/fmt/trait.Debug.html)トレイトを使って）出力し" "ます。以下の例ではそのようなシナリオを示し、[この先の節](result/" "early_returns.md)でカバーする内容に触れていきます。" #: src/error/result/result_map.md:3 msgid "" "Panicking in the previous example's `multiply` does not make for robust " "code. Generally, we want to return the error to the caller so it can decide " "what is the right way to respond to errors." msgstr "" "前の例で見た`multiply`でのパニックは、コードを強固にするためには書きません。" "一般に、呼び出した側がエラーをどのように対処するべきかを自由に決められるよう" "に、エラーを呼び出した場所に返すのが好ましいです。" #: src/error/result/result_map.md:7 msgid "" "We first need to know what kind of error type we are dealing with. To " "determine the `Err` type, we look to [`parse()`](https://doc.rust-lang.org/" "std/primitive.str.html#method.parse), which is implemented with the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "[`i32`](https://doc.rust-lang.org/std/primitive.i32.html). As a result, the " "`Err` type is specified as [`ParseIntError`](https://doc.rust-lang.org/std/" "num/struct.ParseIntError.html)." msgstr "" "まずは、どのようなエラー型を扱っているのかを知る必要があります。`Err`型を定め" "るために、[`i32`](https://doc.rust-lang.org/std/primitive.i32.html)に対し" "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html)トレイトを" "使って実装された[`parse()`](https://doc.rust-lang.org/std/primitive.str." "html#method.parse)を見てみましょう。結果、`Err`型は[`ParseIntError`](https://" "doc.rust-lang.org/std/num/struct.ParseIntError.html)というものであることが分" "かります。" #: src/error/result/result_map.md:12 msgid "" "In the example below, the straightforward `match` statement leads to code " "that is overall more cumbersome." msgstr "" "以下の例では、単純な`match`文が全体として扱いづらいコードにしています。" #: src/error/result/result_map.md:17 msgid "" "// With the return type rewritten, we use pattern matching without " "`unwrap()`.\n" msgstr "" "// リターン型を再度記述することで、パターンマッチングを`unwrap()`なしで行いま" "す。\n" #: src/error/result/result_map.md:35 src/error/result/result_map.md:68 #: src/error/result/result_alias.md:30 src/error/result/early_returns.md:30 #: src/error/result/enter_question_mark.md:28 #: src/error/result/enter_question_mark.md:61 msgid "\"n is {}\"" msgstr "\"n is {}\"" #: src/error/result/result_map.md:36 src/error/result/result_map.md:69 #: src/error/result/result_alias.md:31 src/error/result/early_returns.md:31 #: src/error/result/enter_question_mark.md:29 #: src/error/result/enter_question_mark.md:62 #: src/error/multiple_error_types/define_error_type.md:55 #: src/error/multiple_error_types/boxing_errors.md:42 #: src/error/multiple_error_types/reenter_question_mark.md:54 #: src/error/multiple_error_types/wrap_error.md:68 msgid "\"Error: {}\"" msgstr "\"Error: {}\"" #: src/error/result/result_map.md:41 src/error/result/result_map.md:74 msgid "// This still presents a reasonable answer.\n" msgstr "// ここは以前と変わらず、妥当な解を与えます。\n" #: src/error/result/result_map.md:45 src/error/result/result_map.md:78 msgid "// The following now provides a much more helpful error message.\n" msgstr "// こちらは今度は有益なエラーメッセージを与えます。\n" #: src/error/result/result_map.md:51 msgid "" "Luckily, `Option`'s `map`, `and_then`, and many other combinators are also " "implemented for `Result`. [`Result`](https://doc.rust-lang.org/std/result/" "enum.Result.html) contains a complete listing." msgstr "" "幸運にも、`Option`の`map`、`and_then`、その他多くのコンビネータも`Result`のた" "めに実装されています。[`Result`](https://doc.rust-lang.org/std/result/enum." "Result.html)に全てのリストが記載されています。" #: src/error/result/result_map.md:56 msgid "" "// As with `Option`, we can use combinators such as `map()`.\n" "// This function is otherwise identical to the one above and reads:\n" "// Multiply if both values can be parsed from str, otherwise pass on the " "error.\n" msgstr "" "// `Option`と同様、`map()`などのコンビネータを使うことができます。\n" "// この関数は`map()`を使っている点以外は上記の関数と同じで、\n" "// 両方の値がstrからパース可能であればそれらを乗算し、無効であればエラーをそ" "のまま見送ります。\n" #: src/error/result/result_alias.md:3 msgid "" "How about when we want to reuse a specific `Result` type many times? Recall " "that Rust allows us to create [aliases](../../types/alias.md). Conveniently, " "we can define one for the specific `Result` in question." msgstr "" "特定の`Result`型を何度も使いたくなるのはどんな時でしょう？Rustは[エイリアス]" "(../../types/alias.md)の作成をサポートしていたことを思い出してください。便利" "なことに、特定の`Result`型に対しても定義することができます。" #: src/error/result/result_alias.md:7 msgid "" "At a module level, creating aliases can be particularly helpful. Errors " "found in a specific module often have the same `Err` type, so a single alias " "can succinctly define _all_ associated `Results`. This is so useful that the " "`std` library even supplies one: [`io::Result`](https://doc.rust-lang.org/" "std/io/type.Result.html)!" msgstr "" "モジュールレベルでは、エイリアスの作成は非常に役に立ちます。特定のモジュール" "で見られるエラーは同じ`Err`型を持つため、単一のエイリアスで簡潔に`Results`に" "関わる*全て*を定義できます。`std`ライブラリが提供するもの（[`io::Result`]" "(https://doc.rust-lang.org/std/io/type.Result.html)）もあるほど有益なのです！" #: src/error/result/result_alias.md:12 msgid "Here's a quick example to show off the syntax:" msgstr "簡単な例で構文を見てみましょう。" #: src/error/result/result_alias.md:16 msgid "" "// Define a generic alias for a `Result` with the error type " "`ParseIntError`.\n" msgstr "" "// `ParseIntError`を`Err`の型として持つ全ての`Result`のジェネリックエイリア" "ス\n" #: src/error/result/result_alias.md:19 msgid "// Use the above alias to refer to our specific `Result` type.\n" msgstr "// 上で定義したエイリアス（この場所特有の`Result`型）を使用。\n" #: src/error/result/result_alias.md:26 msgid "// Here, the alias again allows us to save some space.\n" msgstr "// もう一度使用。エイリアスによって再度明記する必要性がありません。\n" #: src/error/result/result_alias.md:43 msgid "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" msgstr "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" #: src/error/result/early_returns.md:3 msgid "" "In the previous example, we explicitly handled the errors using combinators. " "Another way to deal with this case analysis is to use a combination of " "`match` statements and _early returns_." msgstr "" "前の例では、コンビネータの活用によりエラーを明示的に処理しました。場合分けに" "対する別の対処法として、`match`文と早期リターンを組み合わせて使うこともできま" "す。" #: src/error/result/early_returns.md:7 msgid "" "That is, we can simply stop executing the function and return the error if " "one occurs. For some, this form of code can be easier to both read and " "write. Consider this version of the previous example, rewritten using early " "returns:" msgstr "" "つまり、エラーが発生した時点で関数の実行を止め、エラーを返してしまうという単" "純な方法が使えるということです。この方法の方がより読みやすく書きやすい場合が" "あります。早期リターンを使って実装された、前の例の新たなバージョンを考えてみ" "ましょう。" #: src/error/result/early_returns.md:41 msgid "" "At this point, we've learned to explicitly handle errors using combinators " "and early returns. While we generally want to avoid panicking, explicitly " "handling all of our errors is cumbersome." msgstr "" "ここまでで、コンビネータと早期リターンによる明示的なエラーハンドリングについ" "て学びました。しかし、パニックは一般に避けたいですが、全てのエラーを明示的に" "処理するのも厄介でしょう。" #: src/error/result/early_returns.md:45 msgid "" "In the next section, we'll introduce `?` for the cases where we simply need " "to `unwrap` without possibly inducing `panic`." msgstr "" "次の節では、`panic`を発生させずに`unwrap`する必要があるケースのための`?`につ" "いて紹介していきます。" #: src/error/result/enter_question_mark.md:3 msgid "" "Sometimes we just want the simplicity of `unwrap` without the possibility of " "a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when " "what we really wanted was to get the variable _out_. This is exactly the " "purpose of `?`." msgstr "" "時には`panic`の可能性を無視して、`unwrap`のシンプルさを活用したいこともあるで" "しょう。今までの`unwrap`は、値を*取り出す*ためだけであろうとも、ネストを深く" "書くことを要求しました。そして、これがまさに`?`の目的です。" #: src/error/result/enter_question_mark.md:7 msgid "Upon finding an `Err`, there are two valid actions to take:" msgstr "`Err`を見つけるにあたり、２つのとるべき行動があります。" #: src/error/result/enter_question_mark.md:9 msgid "`panic!` which we already decided to try to avoid if possible" msgstr "可能な限り避けたいと決めた`panic!`" #: src/error/result/enter_question_mark.md:10 msgid "`return` because an `Err` means it cannot be handled" msgstr "`Err`は処理できないことを意味するため`return`" #: src/error/result/enter_question_mark.md:12 msgid "" "`?` is _almost_[^†] exactly equivalent to an `unwrap` which `return`s " "instead of `panic`king on `Err`s. Let's see how we can simplify the earlier " "example that used combinators:" msgstr "" "`?`は*ほぼ*[^†]まさしく、`Err`に対して`panic`するより`return`するという点で" "`unwrap`と同等です。コンビネータを使った以前の例をどれだけ簡潔に書けるか見て" "みましょう。" #: src/error/result/enter_question_mark.md:39 msgid "The `try!` macro" msgstr "`try!`マクロ" #: src/error/result/enter_question_mark.md:41 msgid "" "Before there was `?`, the same functionality was achieved with the `try!` " "macro. The `?` operator is now recommended, but you may still find `try!` " "when looking at older code. The same `multiply` function from the previous " "example would look like this using `try!`:" msgstr "" "`?`ができる前、同様の動作を`try!`マクロによって行うことができました。現在は`?" "`演算子が推奨されていますが、古いコードでは`try!`に出会うこともあります。" "`try!`を使って前の例と同じ`multiply`関数を実装すると、以下のようになるでしょ" "う。" #: src/error/result/enter_question_mark.md:47 msgid "" "// To compile and run this example without errors, while using Cargo, change " "the value \n" "// of the `edition` field, in the `[package]` section of the `Cargo.toml` " "file, to \"2015\".\n" msgstr "" "// Cargoを使いながらこの例をエラーなくコンパイル、及び実行する場合、\n" "// `Cargo.toml`ファイル内、`[package]`セクションの`edition`の値を\"2015\"に変" "更してください。\n" #: src/error/result/enter_question_mark.md:73 msgid "" "See [re-enter ?](../multiple_error_types/reenter_question_mark.md) for more " "details." msgstr "" "詳細は[re-enter ?](../multiple_error_types/reenter_question_mark.md)を参照。" #: src/error/multiple_error_types.md:3 msgid "" "The previous examples have always been very convenient; `Result`s interact " "with other `Result`s and `Option`s interact with other `Option`s." msgstr "" "`Result`が他の`Result`と連携したり、`Option`が他の`Option`と連携するなど、今" "までの例はとても便利な物でした。" #: src/error/multiple_error_types.md:6 msgid "" "Sometimes an `Option` needs to interact with a `Result`, or a `Result` needs to interact with a `Result`. In those cases, we " "want to manage our different error types in a way that makes them composable " "and easy to interact with." msgstr "" "時には`Option`が`Result`と連携したり、`Result`が`Result`と連携する必要もあるでしょう。そのような場面では、異なるエラー型を構" "成しやすく、かつ連携しやすく管理したいです。" #: src/error/multiple_error_types.md:11 msgid "" "In the following code, two instances of `unwrap` generate different error " "types. `Vec::first` returns an `Option`, while `parse::` returns a " "`Result`:" msgstr "" "以下のコードは`unwrap`の２つのインスタンスが異なるエラー型を生成します。" "`Vec::first`は`Option`を返し、一方で`parse::`は`Result`を返しています。" #: src/error/multiple_error_types.md:17 msgid "// Generate error 1\n" msgstr "// エラー１の生成\n" #: src/error/multiple_error_types.md:18 msgid "// Generate error 2\n" msgstr "// エラー２の生成\n" #: src/error/multiple_error_types.md:22 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:46 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/wrap_error.md:77 src/error/iter_result.md:40 msgid "\"42\"" msgstr "\"42\"" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:46 #: src/error/multiple_error_types/option_result.md:48 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"93\"" msgstr "\"93\"" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:46 #: src/error/multiple_error_types/option_result.md:48 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"18\"" msgstr "\"18\"" #: src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:48 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"tofu\"" msgstr "\"tofu\"" #: src/error/multiple_error_types.md:26 src/error/multiple_error_types.md:28 #: src/error/multiple_error_types.md:31 #: src/error/multiple_error_types/define_error_type.md:54 #: src/error/multiple_error_types/boxing_errors.md:41 #: src/error/multiple_error_types/reenter_question_mark.md:53 #: src/error/multiple_error_types/wrap_error.md:66 msgid "\"The first doubled is {}\"" msgstr "\"The first doubled is {}\"" #: src/error/multiple_error_types.md:29 #: src/error/multiple_error_types/option_result.md:23 msgid "// Error 1: the input vector is empty\n" msgstr "// エラー１：入力が空ベクタ\n" #: src/error/multiple_error_types.md:32 #: src/error/multiple_error_types/option_result.md:26 msgid "// Error 2: the element doesn't parse to a number\n" msgstr "// エラー２：要素が数字としてパースできない。\n" #: src/error/multiple_error_types.md:36 msgid "" "Over the next sections, we'll see several strategies for handling these kind " "of problems." msgstr "この先の節では、これらの問題を処理する方法について見ていきます。" #: src/error/multiple_error_types/option_result.md:3 msgid "" "The most basic way of handling mixed error types is to just embed them in " "each other." msgstr "" "混在するエラー型に対する最も基本的な対処法は、単にお互いを埋め込んでしまうこ" "とです。" #: src/error/multiple_error_types/option_result.md:20 #: src/error/multiple_error_types/option_result.md:22 #: src/error/multiple_error_types/option_result.md:25 #: src/error/multiple_error_types/option_result.md:50 #: src/error/multiple_error_types/option_result.md:51 #: src/error/multiple_error_types/option_result.md:52 msgid "\"The first doubled is {:?}\"" msgstr "\"The first doubled is {:?}\"" #: src/error/multiple_error_types/option_result.md:30 msgid "" "There are times when we'll want to stop processing on errors (like with [`?`]" "(../result/enter_question_mark.md)) but keep going when the `Option` is " "`None`. A couple of combinators come in handy to swap the `Result` and " "`Option`." msgstr "" "中には、`Option`の中身が`None`の場合はそのまま処理を進め、エラーの検出に限り" "実行を止めたいという場合もあるでしょう（[`?`](../result/enter_question_mark." "md)を使った時のように）。いくつかのコンビネータによって簡単に`Result`と" "`Option`をスワップすることができます。" #: src/error/multiple_error_types/define_error_type.md:3 msgid "" "Sometimes it simplifies the code to mask all of the different errors with a " "single type of error. We'll show this with a custom error." msgstr "" "異なるエラー型をマスクし単一のエラー型として扱えるようにすると、コードがシン" "プルになる場合があります。ここでは自前のエラー型でそれを示してみます。" #: src/error/multiple_error_types/define_error_type.md:6 msgid "" "Rust allows us to define our own error types. In general, a \"good\" error " "type:" msgstr "" "Rustはユーザーによる新たなエラー型の定義をサポートします。一般に「良い」エ" "ラー型は、" #: src/error/multiple_error_types/define_error_type.md:8 msgid "Represents different errors with the same type" msgstr "異なるエラーをまとめて同じ型として扱う。" #: src/error/multiple_error_types/define_error_type.md:9 msgid "Presents nice error messages to the user" msgstr "ユーザーに優しいエラーメッセージを提供する。" #: src/error/multiple_error_types/define_error_type.md:10 msgid "Is easy to compare with other types" msgstr "他の型との比較を楽にする。" #: src/error/multiple_error_types/define_error_type.md:11 msgid "Good: `Err(EmptyVec)`" msgstr "良い例：`Err(EmptyVec)`" #: src/error/multiple_error_types/define_error_type.md:12 msgid "" "Bad: `Err(\"Please use a vector with at least one element\".to_owned())`" msgstr "" "悪い例：`Err(\"Please use a vector with at least one element\".to_owned())`" #: src/error/multiple_error_types/define_error_type.md:13 msgid "Can hold information about the error" msgstr "エラーについての情報を保持できる。" #: src/error/multiple_error_types/define_error_type.md:14 msgid "Good: `Err(BadChar(c, position))`" msgstr "良い例：`Err(BadChar(c, position))`" #: src/error/multiple_error_types/define_error_type.md:15 msgid "Bad: `Err(\"+ cannot be used here\".to_owned())`" msgstr "悪い例：`Err(\"+ cannot be used here\".to_owned())`" #: src/error/multiple_error_types/define_error_type.md:16 msgid "Composes well with other errors" msgstr "他のエラーと問題なく連携できる。" #: src/error/multiple_error_types/define_error_type.md:22 msgid "" "// Define our error types. These may be customized for our error handling " "cases.\n" "// Now we will be able to write our own errors, defer to an underlying " "error\n" "// implementation, or do something in between.\n" msgstr "" "// 自前のエラー型の定義。エラーハンドリングのケースの応じてカスタマイズできま" "す。\n" "// ここで新たなエラーを書くことができ、元のエラーの実装に処理を委譲したり、\n" "// その手前で何らかの処理を挟むことができます。\n" #: src/error/multiple_error_types/define_error_type.md:28 msgid "" "// Generation of an error is completely separate from how it is displayed.\n" "// There's no need to be concerned about cluttering complex logic with the " "display style.\n" "//\n" "// Note that we don't store any extra info about the errors. This means we " "can't state\n" "// which string failed to parse without modifying our types to carry that " "information.\n" msgstr "" "// エラーの生成は、それがどのように表示されるかとは別物です。\n" "// そのため、エラーの表示スタイルに関する複雑なロジックを煩雑になる\n" "// などと気にする必要はありません。\n" "//\n" "// エラーに関する余分な情報を持たせていないことに注意してください。\n" "// どの文字列がパースに失敗したかなどを出力することは、\n" "// その情報を保持させるようにエラーの定義を修正しない限りできません。\n" #: src/error/multiple_error_types/define_error_type.md:36 #: src/error/multiple_error_types/boxing_errors.md:23 #: src/error/multiple_error_types/reenter_question_mark.md:37 msgid "\"invalid first item to double\"" msgstr "\"invalid first item to double\"" #: src/error/multiple_error_types/define_error_type.md:42 msgid "// Change the error to our new type.\n" msgstr "// エラーを新たな型に変更します。\n" #: src/error/multiple_error_types/define_error_type.md:46 msgid "// Update to the new error type here also.\n" msgstr "// ここでも新たなエラー型に更新します。\n" #: src/error/multiple_error_types/boxing_errors.md:3 msgid "" "A way to write simple code while preserving the original errors is to [`Box`]" "(https://doc.rust-lang.org/std/boxed/struct.Box.html) them. The drawback is " "that the underlying error type is only known at runtime and not [statically " "determined](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-" "objects-perform-dynamic-dispatch)." msgstr "" "元のエラーを維持しながらシンプルなコードを書くには、[`Box`](https://doc.rust-" "lang.org/std/boxed/struct.Box.html)してしまうと良いでしょう。欠点として、元の" "エラー型はランタイムまで判明せず、[静的に決定](https://doc.rust-lang.org/" "book/ch17-02-trait-objects.html#trait-objects-perform-dynamic-dispatch)されな" "いことが挙げられます。" #: src/error/multiple_error_types/boxing_errors.md:7 msgid "" "The stdlib helps in boxing our errors by having `Box` implement conversion " "from any type that implements the `Error` trait into the trait object " "`Box`, via [`From`](https://doc.rust-lang.org/std/convert/trait.From." "html)." msgstr "" "標準ライブラリは`Box`に、[`From`](https://doc.rust-lang.org/std/convert/" "trait.From.html)を介してあらゆる`Error`トレイトを実装した型から`Box`ト" "レイトオブジェクトへの変換を実装させることで、エラーをboxしやすくしてくれま" "す。" #: src/error/multiple_error_types/boxing_errors.md:14 #: src/error/multiple_error_types/reenter_question_mark.md:28 msgid "// Change the alias to use `Box`.\n" msgstr "// エイリアスを`Box`に変更します。\n" #: src/error/multiple_error_types/boxing_errors.md:31 #: src/error/multiple_error_types/boxing_errors.md:34 msgid "// Converts to Box\n" msgstr "// Boxに変換。\n" #: src/error/multiple_error_types/boxing_errors.md:59 msgid "" "[Dynamic dispatch](https://doc.rust-lang.org/book/ch17-02-trait-objects." "html#trait-objects-perform-dynamic-dispatch) and [`Error` trait](https://doc." "rust-lang.org/std/error/trait.Error.html)" msgstr "" "[動的ディスパッチ](https://doc.rust-lang.org/book/ch17-02-trait-objects." "html#trait-objects-perform-dynamic-dispatch), [`Error` トレイト](https://doc." "rust-lang.org/std/error/trait.Error.html)" #: src/error/multiple_error_types/reenter_question_mark.md:3 msgid "" "Notice in the previous example that our immediate reaction to calling " "`parse` is to `map` the error from a library error into a boxed error:" msgstr "" "以前の例では`parse`の呼び出しに対するその場での対応として、エラーをライブラリ" "のエラーからboxされたエラーへと`map`していました。" #: src/error/multiple_error_types/reenter_question_mark.md:12 msgid "" "Since this is a simple and common operation, it would be convenient if it " "could be elided. Alas, because `and_then` is not sufficiently flexible, it " "cannot. However, we can instead use `?`." msgstr "" "簡単でよくあるオペレーションのため、可能なら省略してしまえると便利だったで" "しょう。でも残念、`and_then`が十分にフレキシブルでないため、それはできませ" "ん。ただその代わり、`?`なら使えます。" #: src/error/multiple_error_types/reenter_question_mark.md:16 msgid "" "`?` was previously explained as either `unwrap` or `return Err(err)`. This " "is only mostly true. It actually means `unwrap` or `return Err(From::" "from(err))`. Since `From::from` is a conversion utility between different " "types, this means that if you `?` where the error is convertible to the " "return type, it will convert automatically." msgstr "" "`?`の挙動は、`unwrap`または`return Err(err)`として説明されていました。これは" "ほぼ正解で、本当は`unwrap`、もしくは`return Err(From::from(err))`という意味が" "あります。`From::from`は異なる型の間での変換ユーティリティであることから、エ" "ラーがリターン型に変換可能な場合に`?`を使うことで、その変換を自動的に行ってく" "れます。" #: src/error/multiple_error_types/reenter_question_mark.md:22 msgid "" "Here, we rewrite the previous example using `?`. As a result, the `map_err` " "will go away when `From::from` is implemented for our error type:" msgstr "" "前の例を`?`を使ったものに書き換えてみましょう。その結果、`From::from`がエラー" "型に実装されている時`map_err`は消えてなくなります。" #: src/error/multiple_error_types/reenter_question_mark.md:42 msgid "" "// The same structure as before but rather than chain all `Results`\n" "// and `Options` along, we `?` to get the inner value out immediately.\n" msgstr "" "// 前と同じ構造ですが、`Results`と`Option`を繋げていく代わりに、\n" "// `?`で内部の値をその場で取得します。\n" #: src/error/multiple_error_types/reenter_question_mark.md:69 msgid "" "This is actually fairly clean now. Compared with the original `panic`, it is " "very similar to replacing the `unwrap` calls with `?` except that the return " "types are `Result`. As a result, they must be destructured at the top level." msgstr "" "これでかなり綺麗になりました。元の`panic`と比べ、リターン型が`Result`であるこ" "とを除けば、`unwrap`の呼び出しを`?`で置き換えたものに非常に似ています。結果、" "その`Result`は上のレベルで分解されなければなりません。" #: src/error/multiple_error_types/reenter_question_mark.md:76 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`?" "`](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" msgstr "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html), [`?`]" "(https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" #: src/error/multiple_error_types/wrap_error.md:3 msgid "An alternative to boxing errors is to wrap them in your own error type." msgstr "" "Boxする方法の代替として、エラーを自前のエラー型としてラップする方法もありま" "す。" #: src/error/multiple_error_types/wrap_error.md:16 msgid "" "// We will defer to the parse error implementation for their error.\n" " // Supplying extra info requires adding more data to the type.\n" msgstr "" "// パースエラーの実装まで処理を委譲します。\n" " // 追加の情報を提供するには、型により多くのデータを追加する必要がありま" "す。\n" #: src/error/multiple_error_types/wrap_error.md:25 msgid "\"please use a vector with at least one element\"" msgstr "\"please use a vector with at least one element\"" #: src/error/multiple_error_types/wrap_error.md:26 msgid "" "// The wrapped error contains additional information and is available\n" " // via the source() method.\n" msgstr "" "// ラップされたエラーは追加情報を含み、\n" " // source メソッドから取り出すことができます。\n" #: src/error/multiple_error_types/wrap_error.md:29 msgid "\"the provided string could not be parsed as int\"" msgstr "\"the provided string could not be parsed as int\"" #: src/error/multiple_error_types/wrap_error.md:38 msgid "" "// The cause is the underlying implementation error type. Is implicitly\n" " // cast to the trait object `&error::Error`. This works because " "the\n" " // underlying type already implements the `Error` trait.\n" msgstr "" "// 元の実装のエラー型が原因。\n" " // `&error::Error`トレイトオブジェクトに暗にキャストされます。\n" " // 元となる型が`Error`トレイトをすでに実装しているため問題ありま" "せん。\n" #: src/error/multiple_error_types/wrap_error.md:45 msgid "" "// Implement the conversion from `ParseIntError` to `DoubleError`.\n" "// This will be automatically called by `?` if a `ParseIntError`\n" "// needs to be converted into a `DoubleError`.\n" msgstr "" "// `ParseIntError`から`DoubleError`への変換の実装。\n" "// `ParseIntError`が`DoubleError`に変換される必要がある時、\n" "// 自動的に`?`から呼び出されます。\n" #: src/error/multiple_error_types/wrap_error.md:57 msgid "" "// Here we implicitly use the `ParseIntError` implementation of `From` " "(which\n" " // we defined above) in order to create a `DoubleError`.\n" msgstr "" #: src/error/multiple_error_types/wrap_error.md:70 msgid "\" Caused by: {}\"" msgstr "\" Caused by: {}\"" #: src/error/multiple_error_types/wrap_error.md:87 msgid "" "This adds a bit more boilerplate for handling errors and might not be needed " "in all applications. There are some libraries that can take care of the " "boilerplate for you." msgstr "" "これはエラーの処理のボイラープレートを増やしてしまい、全てのアプリケーション" "で必要になる訳では無いでしょう。これらのボイラープレートの処理を代わりにやっ" "てくれるようなライブラリもあります。" #: src/error/multiple_error_types/wrap_error.md:93 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Enums`](../../custom_types/enum.md)" msgstr "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html), [列挙" "型](../../custom_types/enum.md)" #: src/error/multiple_error_types/wrap_error.md:96 msgid "" "[`Crates for handling errors`](https://crates.io/keywords/error-handling)" msgstr "" #: src/error/iter_result.md:3 msgid "An `Iter::map` operation might fail, for example:" msgstr "`Iter::map`オペレーションは失敗することもあります。例えば、" #: src/error/iter_result.md:12 src/error/iter_result.md:29 #: src/error/iter_result.md:65 msgid "\"Results: {:?}\"" msgstr "\"Results: {:?}\"" #: src/error/iter_result.md:16 msgid "Let's step through strategies for handling this." msgstr "ここでは、この対処法についてみてみましょう。" #: src/error/iter_result.md:18 msgid "Ignore the failed items with `filter_map()`" msgstr "`filter_map()`を使って失敗した要素のみを無視する" #: src/error/iter_result.md:20 msgid "" "`filter_map` calls a function and filters out the results that are `None`." msgstr "`filter_map`は関数を呼び出し、結果が`None`になるものだけ取り除きます。" #: src/error/iter_result.md:33 msgid "Collect the failed items with `map_err()` and `filter_map()`" msgstr "" #: src/error/iter_result.md:35 msgid "" "`map_err` calls a function with the error, so by adding that to the previous " "`filter_map` solution we can save them off to the side while iterating." msgstr "" #: src/error/iter_result.md:40 msgid "\"999\"" msgstr "\"999\"" #: src/error/iter_result.md:47 src/error/iter_result.md:80 #: src/error/iter_result.md:97 msgid "\"Numbers: {:?}\"" msgstr "\"Numbers: {:?}\"" #: src/error/iter_result.md:48 src/error/iter_result.md:81 #: src/error/iter_result.md:98 msgid "\"Errors: {:?}\"" msgstr "\"Errors: {:?}\"" #: src/error/iter_result.md:52 msgid "Fail the entire operation with `collect()`" msgstr "`collect()`で処理全体を失敗させる" #: src/error/iter_result.md:54 msgid "" "`Result` implements `FromIterator` so that a vector of results " "(`Vec>`) can be turned into a result with a vector " "(`Result, E>`). Once an `Result::Err` is found, the iteration will " "terminate." msgstr "" "`Result`は、それらのベクタ(`Vec>`)からベクタのそれ" "(`Result, E>`)へと変換できるようにするため、`FromIterator`を実装しま" "す。`Result::Err`が見つかり次第、イテレーションは終了します。" #: src/error/iter_result.md:69 msgid "This same technique can be used with `Option`." msgstr "同じテクニックは、`Option`を用いて行うこともできます。" #: src/error/iter_result.md:71 msgid "Collect all valid values and failures with `partition()`" msgstr "`partition()`を使って全ての正常な値と失敗をまとめる" #: src/error/iter_result.md:85 msgid "" "When you look at the results, you'll note that everything is still wrapped " "in `Result`. A little more boilerplate is needed for this." msgstr "" "結果を見てみると、まだ全て`Result`にラップされていることに気づくでしょう。も" "う少しのボイラープレートが必要です。" #: src/std.md:3 msgid "" "The `std` library provides many custom types which expands drastically on " "the `primitives`. Some of these include:" msgstr "" "`std`ライブラリは、基本データ型を劇的に拡張するカスタム型を数多く提供します。" "例えば以下です。" #: src/std.md:6 msgid "growable `String`s like: `\"hello world\"`" msgstr "拡張可能な文字列である`String`。例えば：`\"hello world\"`" #: src/std.md:7 msgid "growable vectors: `[1, 2, 3]`" msgstr "" #: src/std.md:8 msgid "optional types: `Option`" msgstr "オプション型：`Option`" #: src/std.md:9 msgid "error handling types: `Result`" msgstr "エラーハンドリング用の`Result`" #: src/std.md:10 msgid "heap allocated pointers: `Box`" msgstr "ヒープ上の資源へのポインタ：`Box`" #: src/std.md:14 src/std_misc.md:14 msgid "" "[primitives](primitives.md) and [the std library](https://doc.rust-lang.org/" "std/)" msgstr "" "[基本データ型](primitives.md), [`std` ライブラリ](https://doc.rust-lang.org/" "std/)" #: src/std/box.md:3 msgid "" "All values in Rust are stack allocated by default. Values can be _boxed_ " "(allocated on the heap) by creating a `Box`. A box is a smart pointer to " "a heap allocated value of type `T`. When a box goes out of scope, its " "destructor is called, the inner object is destroyed, and the memory on the " "heap is freed." msgstr "" "Rustにおいて、すべての値はデフォルトでスタックに割り当てられます。`Box`を" "作成することで、値を *ボックス化* 、すなわちヒープ上に割り当てることができま" "す。ボックスとは正確にはヒープ上におかれた`T`の値へのスマートポインタです。" "ボックスがスコープを抜けると、デストラクタが呼ばれて内包するオブジェクトが破" "棄され、ヒープメモリが解放されます。" #: src/std/box.md:8 msgid "" "Boxed values can be dereferenced using the `*` operator; this removes one " "layer of indirection." msgstr "" "ボックス化された値は`*`演算子を用いてデリファレンスすることができます。これに" "より一段と直接的な操作が可能になります。" #: src/std/box.md:20 msgid "" "// A Rectangle can be specified by where its top left and bottom right \n" "// corners are in space\n" msgstr "// 長方形は左上の角と右下の角がどこにあるかによって特定できます。\n" #: src/std/box.md:34 msgid "// Allocate this point on the heap, and return a pointer to it\n" msgstr "// このPointをヒープ上に割り当て、ポインタを返します。\n" #: src/std/box.md:39 msgid "" "// (all the type annotations are superfluous)\n" " // Stack allocated variables\n" msgstr "" "// （以下では型を全て明示していますが、必須ではありません。）\n" " // この変数ははすべてスタック上に割り当てられます。\n" #: src/std/box.md:47 msgid "// Heap allocated rectangle\n" msgstr "// ヒープ上に割り当てられたRectangle\n" #: src/std/box.md:53 msgid "// The output of functions can be boxed\n" msgstr "// 関数の返り値をボックス化。\n" #: src/std/box.md:56 msgid "// Double indirection\n" msgstr "// 間にもう一つポインタを挟みます。\n" #: src/std/box.md:59 msgid "\"Point occupies {} bytes on the stack\"" msgstr "\"Point occupies {} bytes on the stack\"" #: src/std/box.md:61 msgid "\"Rectangle occupies {} bytes on the stack\"" msgstr "\"Rectangle occupies {} bytes on the stack\"" #: src/std/box.md:64 msgid "// box size == pointer size\n" msgstr "// ボックスのサイズはポインタのサイズに等しい。\n" #: src/std/box.md:65 msgid "\"Boxed point occupies {} bytes on the stack\"" msgstr "\"Boxed point occupies {} bytes on the stack\"" #: src/std/box.md:67 msgid "\"Boxed rectangle occupies {} bytes on the stack\"" msgstr "\"Boxed rectangle occupies {} bytes on the stack\"" #: src/std/box.md:69 msgid "\"Boxed box occupies {} bytes on the stack\"" msgstr "\"Boxed box occupies {} bytes on the stack\"" #: src/std/box.md:72 msgid "// Copy the data contained in `boxed_point` into `unboxed_point`\n" msgstr "// `boxed_point`の保持するデータを`unboxed_point`にコピーします。\n" #: src/std/box.md:74 msgid "\"Unboxed point occupies {} bytes on the stack\"" msgstr "\"Unboxed point occupies {} bytes on the stack\"" #: src/std/vec.md:3 msgid "" "Vectors are re-sizable arrays. Like slices, their size is not known at " "compile time, but they can grow or shrink at any time. A vector is " "represented using 3 parameters:" msgstr "" "「ベクタ」はサイズを変更可能な配列です。スライスと同様、そのサイズはコンパイ" "ル時には不定ですが、いつでも要素を追加したり削除したりすることができます。ベ" "クタは3つの要素で、その特徴が完全に決まります。" #: src/std/vec.md:6 msgid "pointer to the data" msgstr "データへのポインタ" #: src/std/vec.md:7 msgid "length" msgstr "長さ" #: src/std/vec.md:8 msgid "capacity" msgstr "容量" #: src/std/vec.md:10 msgid "" "The capacity indicates how much memory is reserved for the vector. The " "vector can grow as long as the length is smaller than the capacity. When " "this threshold needs to be surpassed, the vector is reallocated with a " "larger capacity." msgstr "" "ベクタはその容量を超えない限りにおいて長くしていくことができます。超えた場合" "には、より大きな容量を持つように割り当てなおされます。" #: src/std/vec.md:16 msgid "// Iterators can be collected into vectors\n" msgstr "// イテレータは要素を収集してベクタにすることができます。\n" #: src/std/vec.md:18 msgid "\"Collected (0..10) into: {:?}\"" msgstr "\"Collected (0..10) into: {:?}\"" #: src/std/vec.md:20 msgid "// The `vec!` macro can be used to initialize a vector\n" msgstr "// ベクタの初期化には`vec!`マクロが使用できます。\n" #: src/std/vec.md:22 msgid "\"Initial vector: {:?}\"" msgstr "\"Initial vector: {:?}\"" #: src/std/vec.md:24 msgid "// Insert new element at the end of the vector\n" msgstr "// 新しい要素をベクタの最後に挿入することができます。\n" #: src/std/vec.md:25 msgid "\"Push 4 into the vector\"" msgstr "\"Push 4 into the vector\"" #: src/std/vec.md:27 msgid "\"Vector: {:?}\"" msgstr "\"Vector: {:?}\"" #: src/std/vec.md:29 msgid "// Error! Immutable vectors can't grow\n" msgstr "// エラー！イミュータブルなベクタは成長できません\n" #: src/std/vec.md:33 msgid "" "// The `len` method yields the number of elements currently stored in a " "vector\n" msgstr "// `len`メソッドは現在のベクタのサイズを返します。\n" #: src/std/vec.md:34 msgid "\"Vector length: {}\"" msgstr "\"Vector length: {}\"" #: src/std/vec.md:36 msgid "// Indexing is done using the square brackets (indexing starts at 0)\n" msgstr "" "// 鍵括弧を用いてインデックスによる要素へのアクセスができます。\n" " // （インデックスは0から開始する）\n" #: src/std/vec.md:37 msgid "\"Second element: {}\"" msgstr "\"Second element: {}\"" #: src/std/vec.md:39 msgid "// `pop` removes the last element from the vector and returns it\n" msgstr "// `pop`はベクタの最後の要素を削除すると同時に返します。\n" #: src/std/vec.md:40 msgid "\"Pop last element: {:?}\"" msgstr "\"Pop last element: {:?}\"" #: src/std/vec.md:42 msgid "// Out of bounds indexing yields a panic\n" msgstr "// 不正なインデックスアクセスはpanicを引き起こします。\n" #: src/std/vec.md:43 msgid "\"Fourth element: {}\"" msgstr "\"Fourth element: {}\"" #: src/std/vec.md:46 msgid "// `Vector`s can be easily iterated over\n" msgstr "// `Vector`は簡単にイテレートできます。\n" #: src/std/vec.md:47 msgid "\"Contents of xs:\"" msgstr "\"Contents of xs:\"" #: src/std/vec.md:52 msgid "" "// A `Vector` can also be iterated over while the iteration\n" " // count is enumerated in a separate variable (`i`)\n" msgstr "" "// `Vector`をイテレートしながら、\n" " // イテレーションの回数を別の変数（`i`）に列挙することもできます。\n" #: src/std/vec.md:55 msgid "\"In position {} we have value {}\"" msgstr "\"In position {} we have value {}\"" #: src/std/vec.md:58 msgid "" "// Thanks to `iter_mut`, mutable `Vector`s can also be iterated\n" " // over in a way that allows modifying each value\n" msgstr "" "// `iter_mut`を使うと、ミュータブルな`Vector`をイテレートし、\n" " // それぞれの値を修正することができます。\n" #: src/std/vec.md:63 msgid "\"Updated vector: {:?}\"" msgstr "\"Updated vector: {:?}\"" #: src/std/vec.md:67 msgid "" "More `Vec` methods can be found under the [std::vec](https://doc.rust-lang." "org/std/vec/) module" msgstr "" "`Vec`型のメソッドの一覧は[std::vec](https://doc.rust-lang.org/std/vec/)モ" "ジュールを見てください。" #: src/std/str.md:3 msgid "The two most used string types in Rust are `String` and `&str`." msgstr "Rustには文字列を扱う型が2つあります。`String`と`&str`です。" #: src/std/str.md:5 msgid "" "A `String` is stored as a vector of bytes (`Vec`), but guaranteed to " "always be a valid UTF-8 sequence. `String` is heap allocated, growable and " "not null terminated." msgstr "" "`String`は有効なUTF-8の配列であることを保証されたバイトのベクタ(`Vec`)と" "して保持されます。ヒープ上に保持され、伸長可能で、末端にnull文字を含みませ" "ん。" #: src/std/str.md:9 msgid "" "`&str` is a slice (`&[u8]`) that always points to a valid UTF-8 sequence, " "and can be used to view into a `String`, just like `&[T]` is a view into " "`Vec`." msgstr "" "`&str`は有効なUTF-8の配列のスライス（`&[u8]`）で、いつでも`String`に変換する" "ことができます。`&[T]`がいつでも`Vec`に変換できるのと同様です。" #: src/std/str.md:14 msgid "" "// (all the type annotations are superfluous)\n" " // A reference to a string allocated in read only memory\n" msgstr "" "// （以下の例では型を明示していますが、これらは必須ではありません。）\n" " // read only memory上に割り当てられた文字列への参照\n" #: src/std/str.md:16 msgid "\"the quick brown fox jumps over the lazy dog\"" msgstr "\"the quick brown fox jumps over the lazy dog\"" #: src/std/str.md:17 msgid "\"Pangram: {}\"" msgstr "\"Pangram: {}\"" #: src/std/str.md:19 msgid "// Iterate over words in reverse, no new string is allocated\n" msgstr "" "// 単語を逆順にイテレートします。新しい文字列の割り当ては起こりません。\n" #: src/std/str.md:20 msgid "\"Words in reverse\"" msgstr "\"Words in reverse\"" #: src/std/str.md:25 msgid "// Copy chars into a vector, sort and remove duplicates\n" msgstr "// 文字をベクタにコピー。ソートして重複を除去。\n" #: src/std/str.md:30 msgid "// Create an empty and growable `String`\n" msgstr "// 中身が空で、伸長可能な`String`を作成。\n" #: src/std/str.md:33 msgid "// Insert a char at the end of string\n" msgstr "// 文字を文字列の末端に挿入。\n" #: src/std/str.md:35 msgid "// Insert a string at the end of string\n" msgstr "// 文字列を文字列の末端に挿入。\n" #: src/std/str.md:39 msgid "" "// The trimmed string is a slice to the original string, hence no new\n" " // allocation is performed\n" msgstr "" "// 文字列のトリミング（特定文字種の除去）はオリジナルの文字列のスライスを\n" " // 返すので、新規のメモリ割り当ては発生しません。\n" #: src/std/str.md:43 msgid "\"Used characters: {}\"" msgstr "\"Used characters: {}\"" #: src/std/str.md:45 msgid "// Heap allocate a string\n" msgstr "// 文字列をヒープに割り当てます。\n" #: src/std/str.md:46 msgid "\"I like dogs\"" msgstr "\"I like dogs\"" #: src/std/str.md:47 msgid "// Allocate new memory and store the modified string there\n" msgstr "// 新しくメモリを確保し、変更を加えた文字列をそこに割り当てます。\n" #: src/std/str.md:48 msgid "\"dog\"" msgstr "\"dog\"" #: src/std/str.md:48 msgid "\"cat\"" msgstr "\"cat\"" #: src/std/str.md:50 msgid "\"Alice says: {}\"" msgstr "\"Alice says: {}\"" #: src/std/str.md:51 msgid "\"Bob says: {}\"" msgstr "\"Bob says: {}\"" #: src/std/str.md:55 msgid "" "More `str`/`String` methods can be found under the [std::str](https://doc." "rust-lang.org/std/str/) and [std::string](https://doc.rust-lang.org/std/" "string/) modules" msgstr "" "`str`/`String`のメソッドをもっと見たい場合は[std::str](https://doc.rust-lang." "org/std/str/)、[std::string](https://doc.rust-lang.org/std/string/)モジュール" "を参照してください。" #: src/std/str.md:60 msgid "Literals and escapes" msgstr "" #: src/std/str.md:62 msgid "" "There are multiple ways to write string literals with special characters in " "them. All result in a similar `&str` so it's best to use the form that is " "the most convenient to write. Similarly there are multiple ways to write " "byte string literals, which all result in `&[u8; N]`." msgstr "" #: src/std/str.md:67 msgid "" "Generally special characters are escaped with a backslash character: `\\`. " "This way you can add any character to your string, even unprintable ones and " "ones that you don't know how to type. If you want a literal backslash, " "escape it with another one: `\\\\`" msgstr "" #: src/std/str.md:72 msgid "" "String or character literal delimiters occurring within a literal must be " "escaped: `\"\\\"\"`, `'\\''`." msgstr "" #: src/std/str.md:76 msgid "// You can use escapes to write bytes by their hexadecimal values...\n" msgstr "" #: src/std/str.md:77 msgid "\"I'm writing \\x52\\x75\\x73\\x74!\"" msgstr "\"I'm writing \\x52\\x75\\x73\\x74!\"" #: src/std/str.md:78 msgid "\"What are you doing\\x3F (\\\\x3F means ?) {}\"" msgstr "\"What are you doing\\x3F (\\\\x3F means ?) {}\"" #: src/std/str.md:80 msgid "// ...or Unicode code points.\n" msgstr "" #: src/std/str.md:81 msgid "\"\\u{211D}\"" msgstr "\"\\u{211D}\"" #: src/std/str.md:82 msgid "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\"" msgstr "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\"" #: src/std/str.md:84 msgid "\"Unicode character {} (U+211D) is called {}\"" msgstr "\"Unicode character {} (U+211D) is called {}\"" #: src/std/str.md:88 msgid "" "\"String literals\n" " can span multiple lines.\n" " The linebreak and indentation here ->\\\n" " <- can be escaped too!\"" msgstr "" "\"String literals\n" " can span multiple lines.\n" " The linebreak and indentation here ->\\\n" " <- can be escaped too!\"" #: src/std/str.md:96 msgid "" "Sometimes there are just too many characters that need to be escaped or it's " "just much more convenient to write a string out as-is. This is where raw " "string literals come into play." msgstr "" #: src/std/str.md:101 msgid "r\"Escapes don't work here: \\x3F \\u{211D}\"" msgstr "r\"Escapes don't work here: \\x3F \\u{211D}\"" #: src/std/str.md:104 msgid "// If you need quotes in a raw string, add a pair of #s\n" msgstr "" #: src/std/str.md:105 msgid "r#\"And then I said: \"There is no escape!\"\"#" msgstr "r#\"And then I said: \"There is no escape!\"\"#" #: src/std/str.md:108 msgid "" "// If you need \"# in your string, just use more #s in the delimiter.\n" " // You can use up to 255 #s.\n" msgstr "" #: src/std/str.md:110 msgid "r###\"A string with \"# in it. And even \"##!\"###" msgstr "r###\"A string with \"# in it. And even \"##!\"###" #: src/std/str.md:115 msgid "" "Want a string that's not UTF-8? (Remember, `str` and `String` must be valid " "UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings " "to the rescue!" msgstr "" #: src/std/str.md:122 msgid "// Note that this is not actually a `&str`\n" msgstr "" #: src/std/str.md:123 msgid "b\"this is a byte string\"" msgstr "b\"this is a byte string\"" #: src/std/str.md:125 msgid "" "// Byte arrays don't have the `Display` trait, so printing them is a bit " "limited\n" msgstr "" #: src/std/str.md:126 msgid "\"A byte string: {:?}\"" msgstr "\"A byte string: {:?}\"" #: src/std/str.md:128 msgid "// Byte strings can have byte escapes...\n" msgstr "" #: src/std/str.md:129 msgid "b\"\\x52\\x75\\x73\\x74 as bytes\"" msgstr "b\"\\x52\\x75\\x73\\x74 as bytes\"" #: src/std/str.md:130 msgid "" "// ...but no unicode escapes\n" " // let escaped = b\"\\u{211D} is not allowed\";\n" msgstr "" #: src/std/str.md:132 msgid "\"Some escaped bytes: {:?}\"" msgstr "\"Some escaped bytes: {:?}\"" #: src/std/str.md:135 msgid "// Raw byte strings work just like raw strings\n" msgstr "" #: src/std/str.md:136 msgid "br\"\\u{211D} is not escaped here\"" msgstr "br\"\\u{211D} is not escaped here\"" #: src/std/str.md:139 msgid "// Converting a byte array to `str` can fail\n" msgstr "" #: src/std/str.md:141 msgid "\"And the same as text: '{}'\"" msgstr "\"And the same as text: '{}'\"" #: src/std/str.md:144 msgid "" "br#\"You can also use \"fancier\" formatting, \\\n" " like with normal raw strings\"#" msgstr "" "br#\"You can also use \"fancier\" formatting, \\\n" " like with normal raw strings\"#" #: src/std/str.md:147 msgid "// Byte strings don't have to be UTF-8\n" msgstr "" #: src/std/str.md:148 msgid "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" msgstr "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" #: src/std/str.md:148 msgid "// \"ようこそ\" in SHIFT-JIS\n" msgstr "" #: src/std/str.md:150 msgid "// But then they can't always be converted to `str`\n" msgstr "" #: src/std/str.md:152 msgid "\"Conversion successful: '{}'\"" msgstr "\"Conversion successful: '{}'\"" #: src/std/str.md:153 msgid "\"Conversion failed: {:?}\"" msgstr "\"Conversion failed: {:?}\"" #: src/std/str.md:158 msgid "" "For conversions between character encodings check out the [encoding](https://" "crates.io/crates/encoding) crate." msgstr "" #: src/std/str.md:160 msgid "" "A more detailed listing of the ways to write string literals and escape " "characters is given in the ['Tokens' chapter](https://doc.rust-lang.org/" "reference/tokens.html) of the Rust Reference." msgstr "" #: src/std/option.md:3 msgid "" "Sometimes it's desirable to catch the failure of some parts of a program " "instead of calling `panic!`; this can be accomplished using the `Option` " "enum." msgstr "" "プログラムの一部が失敗した際、`panic!`するよりも、エラーを捕捉する方が望まし" "い場合があります。これは`Option`という列挙型を用いることで可能になります。" #: src/std/option.md:6 msgid "The `Option` enum has two variants:" msgstr "列挙型`Option`には2つの値があります。" #: src/std/option.md:8 msgid "`None`, to indicate failure or lack of value, and" msgstr "`None`、これは実行の失敗か値の欠如を示します。" #: src/std/option.md:9 msgid "`Some(value)`, a tuple struct that wraps a `value` with type `T`." msgstr "`Some(value)`、型`T`の`value`をラップするタプルです。" #: src/std/option.md:12 msgid "// An integer division that doesn't `panic!`\n" msgstr "// `panic!`を起こさない整数の割り算\n" #: src/std/option.md:15 msgid "// Failure is represented as the `None` variant\n" msgstr "// 失敗は`None`としてあらわされます。\n" #: src/std/option.md:18 msgid "// Result is wrapped in a `Some` variant\n" msgstr "// 結果は`Some`にラップされます。\n" #: src/std/option.md:22 msgid "// This function handles a division that may not succeed\n" msgstr "// この関数は失敗する割り算を扱うことができます。\n" #: src/std/option.md:25 msgid "// `Option` values can be pattern matched, just like other enums\n" msgstr "" "// `Option` の値は、他のあらゆる列挙型と同様パターンマッチに使用できます。\n" #: src/std/option.md:27 msgid "\"{} / {} failed!\"" msgstr "\"{} / {} failed!\"" #: src/std/option.md:29 msgid "\"{} / {} = {}\"" msgstr "\"{} / {} = {}\"" #: src/std/option.md:38 msgid "// Binding `None` to a variable needs to be type annotated\n" msgstr "// `None`を変数に代入する際は、型を明示しなくてはなりません。\n" #: src/std/option.md:44 msgid "// Unwrapping a `Some` variant will extract the value wrapped.\n" msgstr "// `Some`をアンラップすると中の値を取得できます。\n" #: src/std/option.md:45 src/std/option.md:48 msgid "\"{:?} unwraps to {:?}\"" msgstr "\"{:?} unwraps to {:?}\"" #: src/std/option.md:47 msgid "// Unwrapping a `None` variant will `panic!`\n" msgstr "// `None`をアンラップしようとすると`panic!`します。\n" #: src/std/result.md:3 msgid "" "We've seen that the `Option` enum can be used as a return value from " "functions that may fail, where `None` can be returned to indicate failure. " "However, sometimes it is important to express _why_ an operation failed. To " "do this we have the `Result` enum." msgstr "" "これまでの例で、失敗する可能性のある関数の返り値として、列挙型`Option`が使用" "でき、失敗時の返り値には`None`を用いることを見てきました。しかし、時には **な" "ぜ** そのオペレーションが失敗したのかを明示することが重要な場合があります。そ" "のためには`Result`列挙型を使用します。" #: src/std/result.md:8 msgid "The `Result` enum has two variants:" msgstr "列挙型`Result`は2つの値をとりえます。" #: src/std/result.md:10 msgid "" "`Ok(value)` which indicates that the operation succeeded, and wraps the " "`value` returned by the operation. (`value` has type `T`)" msgstr "" "`Ok(value)` ... これはオペレーションが成功したことを意味し、返り値`value`を" "ラップします。（`value`は型`T`を持ちます。）" #: src/std/result.md:12 msgid "" "`Err(why)`, which indicates that the operation failed, and wraps `why`, " "which (hopefully) explains the cause of the failure. (`why` has type `E`)" msgstr "" "`Err(why)` ... これはオペレーションの失敗を意味します。`why`をラップしてお" "り、ここには失敗した理由が（必ずではありませんが）書かれています。（`why`の型" "は`E`です。）" #: src/std/result.md:17 msgid "// Mathematical \"errors\" we want to catch\n" msgstr "// 捕捉対象としたい、数学的な「エラー」\n" #: src/std/result.md:29 msgid "" "// This operation would `fail`, instead let's return the reason of\n" " // the failure wrapped in `Err`\n" msgstr "" "// 分母が0なので、このオペレーションは普通に行えば失敗します。\n" " // 代わりに`Err`でラップされた失敗の理由を返しましょう。\n" #: src/std/result.md:33 msgid "// This operation is valid, return the result wrapped in `Ok`\n" msgstr "" "// このオペレーションは問題がないので、\n" " // 結果を`Ok`でラップして返しましょう。\n" #: src/std/result.md:54 msgid "// `op(x, y)` === `sqrt(ln(x / y))`\n" msgstr "// `op(x, y)` === `sqrt(ln(x / y))`\n" #: src/std/result.md:57 msgid "// This is a three level match pyramid!\n" msgstr "// 3段階の`match`ピラミッド！\n" #: src/std/result.md:71 msgid "// Will this fail?\n" msgstr "// これは失敗するでしょうか？\n" #: src/std/result/question_mark.md:3 msgid "" "Chaining results using match can get pretty untidy; luckily, the `?` " "operator can be used to make things pretty again. `?` is used at the end of " "an expression returning a `Result`, and is equivalent to a match expression, " "where the `Err(err)` branch expands to an early `return Err(From::" "from(err))`, and the `Ok(ok)` branch expands to an `ok` expression." msgstr "" "マッチを利用して結果をチェインするのは中々面倒です。幸いなことに、`?`マクロを" "使用すればイケてるコードに戻すことができます。`?`は`Result`を返す式の末尾で使" "います。`Err(err)`の分岐が`return Err(From::from(err))`という早期リターンに展" "開され、`Ok(ok)`の分岐が`ok`の式に展開されるようなマッチ式と等価です。" #: src/std/result/question_mark.md:44 msgid "// Intermediate function\n" msgstr "// 中間関数\n" #: src/std/result/question_mark.md:46 msgid "// if `div` \"fails\", then `DivisionByZero` will be `return`ed\n" msgstr "// `div`が\"失敗\"したら、`DivisionByZero`が`return`されます。\n" #: src/std/result/question_mark.md:49 msgid "// if `ln` \"fails\", then `NonPositiveLogarithm` will be `return`ed\n" msgstr "" "// もし`ln`が\"失敗\"したら、`NonPositiveLogarithm`が`return`されます。\n" #: src/std/result/question_mark.md:59 msgid "\"logarithm of non-positive number\"" msgstr "\"logarithm of non-positive number\"" #: src/std/result/question_mark.md:61 src/std/panic.md:15 msgid "\"division by zero\"" msgstr "\"division by zero\"" #: src/std/result/question_mark.md:63 msgid "\"square root of negative number\"" msgstr "\"square root of negative number\"" #: src/std/result/question_mark.md:75 msgid "" "Be sure to check the [documentation](https://doc.rust-lang.org/std/result/" "index.html), as there are many methods to map/compose `Result`." msgstr "" "[公式ドキュメント](https://doc.rust-lang.org/std/result/index.html)をチェック" "することをオススメします。`Result`型を扱う関数や`Result`型のメソッドが多く挙" "げられています。" #: src/std/panic.md:3 msgid "" "The `panic!` macro can be used to generate a panic and start unwinding its " "stack. While unwinding, the runtime will take care of freeing all the " "resources _owned_ by the thread by calling the destructor of all its objects." msgstr "" "`panic!`マクロはパニックを生成し、スタックの巻き戻しを開始するために使用する" "ことができます。巻き戻しの間、ランタイムは、（訳注: panicを起こした）スレッド" "が **所有権を持つ** 全ての資源のデストラクタを呼び出し、メモリ上から解放しま" "す。" #: src/std/panic.md:7 msgid "" "Since we are dealing with programs with only one thread, `panic!` will cause " "the program to report the panic message and exit." msgstr "" "今回はシングルスレッドのプログラムを実行しているので、`panic!`はプログラムに" "パニックメッセージを表示させ、exitします。" #: src/std/panic.md:11 msgid "// Re-implementation of integer division (/)\n" msgstr "// 整数の除法(/)の再実装\n" #: src/std/panic.md:14 msgid "// Division by zero triggers a panic\n" msgstr "// ゼロによる除算はパニックを引き起こします。\n" #: src/std/panic.md:20 msgid "// The `main` task\n" msgstr "// `main`のタスク\n" #: src/std/panic.md:23 msgid "// Heap allocated integer\n" msgstr "// ヒープ上の整数\n" #: src/std/panic.md:26 msgid "// This operation will trigger a task failure\n" msgstr "// このオペレーションはタスクの失敗を引き起こします。\n" #: src/std/panic.md:29 msgid "\"This point won't be reached!\"" msgstr "\"This point won't be reached!\"" #: src/std/panic.md:31 msgid "// `_x` should get destroyed at this point\n" msgstr "// `_x`はここに到達する前に破棄されます。\n" #: src/std/panic.md:35 msgid "Let's check that `panic!` doesn't leak memory." msgstr "`panic!`がメモリリークを引き起こさないことを確認しましょう。" #: src/std/hash.md:3 msgid "" "Where vectors store values by an integer index, `HashMap`s store values by " "key. `HashMap` keys can be booleans, integers, strings, or any other type " "that implements the `Eq` and `Hash` traits. More on this in the next section." msgstr "" "ベクタ型が値を整数のインデックスで保持するのに対し、`HashMap`ではキーで保持し" "ます。`HashMap`のキーはブーリアン、整数、文字列等の`Eq`と`Hash`トレイトを保持" "する型なら何でもOKです。次のセクションでより詳しく見ていきます。" #: src/std/hash.md:8 msgid "" "Like vectors, `HashMap`s are growable, but HashMaps can also shrink " "themselves when they have excess space. You can create a HashMap with a " "certain starting capacity using `HashMap::with_capacity(uint)`, or use " "`HashMap::new()` to get a HashMap with a default initial capacity " "(recommended)." msgstr "" "ベクタ型と同様、伸長可能ですが、`HashMap`の場合さらに、スペースが余っていると" "きには小さくすることも可能です。`HashMap`を一定の容量のエリアに作成するときは" "`HashMap::with_capacity(uint)`を、デフォルトの容量で作成するときは`HashMap::" "new()`を用います。後者が推奨されています。" #: src/std/hash.md:19 src/std/hash.md:30 msgid "\"798-1364\"" msgstr "\"798-1364\"" #: src/std/hash.md:19 msgid "" "\"We're sorry, the call cannot be completed as dialed. \n" " Please hang up and try again.\"" msgstr "" "\"We're sorry, the call cannot be completed as dialed. \n" " Please hang up and try again.\"" #: src/std/hash.md:21 src/std/hash.md:31 msgid "\"645-7689\"" msgstr "\"645-7689\"" #: src/std/hash.md:21 msgid "" "\"Hello, this is Mr. Awesome's Pizza. My name is Fred.\n" " What can I get for you today?\"" msgstr "" "\"Hello, this is Mr. Awesome's Pizza. My name is Fred.\n" " What can I get for you today?\"" #: src/std/hash.md:23 msgid "\"Hi! Who is this again?\"" msgstr "\"Hi! Who is this again?\"" #: src/std/hash.md:30 src/std/hash.md:36 src/std/hash.md:43 msgid "\"Daniel\"" msgstr "\"Daniel\"" #: src/std/hash.md:31 src/std/hash.md:45 src/std/hash.md:50 msgid "\"Ashley\"" msgstr "\"Ashley\"" #: src/std/hash.md:32 msgid "\"Katie\"" msgstr "\"Katie\"" #: src/std/hash.md:32 msgid "\"435-8291\"" msgstr "\"435-8291\"" #: src/std/hash.md:33 msgid "\"Robert\"" msgstr "\"Robert\"" #: src/std/hash.md:33 msgid "\"956-1745\"" msgstr "\"956-1745\"" #: src/std/hash.md:35 msgid "// Takes a reference and returns Option<&V>\n" msgstr "// 参照をとり、Option<&V>を返します。\n" #: src/std/hash.md:37 msgid "\"Calling Daniel: {}\"" msgstr "\"Calling Daniel: {}\"" #: src/std/hash.md:38 msgid "\"Don't have Daniel's number.\"" msgstr "\"Don't have Daniel's number.\"" #: src/std/hash.md:41 msgid "" "// `HashMap::insert()` returns `None`\n" " // if the inserted value is new, `Some(value)` otherwise\n" msgstr "" "// `HashMap::insert()`は\n" " // insertされた値が新しい場合は`None`を\n" " // そうでなければ`Some(value)`を返します。\n" #: src/std/hash.md:43 msgid "\"164-6743\"" msgstr "\"164-6743\"" #: src/std/hash.md:46 msgid "\"Calling Ashley: {}\"" msgstr "\"Calling Ashley: {}\"" #: src/std/hash.md:47 msgid "\"Don't have Ashley's number.\"" msgstr "\"Don't have Ashley's number.\"" #: src/std/hash.md:52 msgid "" "// `HashMap::iter()` returns an iterator that yields \n" " // (&'a key, &'a value) pairs in arbitrary order.\n" msgstr "" "// `HashMap::iter()`は(&'a key, &'a value)\n" " // のペアを順不同で産出するイテレータを返します。\n" #: src/std/hash.md:55 msgid "\"Calling {}: {}\"" msgstr "\"Calling {}: {}\"" #: src/std/hash.md:60 msgid "" "For more information on how hashing and hash maps (sometimes called hash " "tables) work, have a look at [Hash Table Wikipedia](https://en.wikipedia.org/" "wiki/Hash_table)" msgstr "" "ハッシングやハッシュマップ（ハッシュテーブルと呼ばれることもあります）の仕組" "みについて、より詳しく知りたい場合は[Wikipediaのハッシュテーブルのページ]" "(https://en.wikipedia.org/wiki/Hash_table)を見てください。" #: src/std/hash/alt_key_types.md:3 msgid "" "Any type that implements the `Eq` and `Hash` traits can be a key in " "`HashMap`. This includes:" msgstr "" "`Eq`と`Hash`トレイトを実装している型ならば、なんでも`HashMap`のキーになること" "ができます。例えば以下です。" #: src/std/hash/alt_key_types.md:6 msgid "`bool` (though not very useful since there are only two possible keys)" msgstr "`bool` （キーになりうる値が2つしかないので実用的ではないですが…）" #: src/std/hash/alt_key_types.md:7 msgid "`int`, `uint`, and all variations thereof" msgstr "`int`、`uint`、あるいは他の整数型" #: src/std/hash/alt_key_types.md:8 msgid "" "`String` and `&str` (protip: you can have a `HashMap` keyed by `String` and " "call `.get()` with an `&str`)" msgstr "" "`String`と`&str`（Tips：`String`をキーにしたハッシュマップを作製した場合、`." "get()`メソッドの引数に`&str`を与えて値を取得することができます。）" #: src/std/hash/alt_key_types.md:11 msgid "" "Note that `f32` and `f64` do _not_ implement `Hash`, likely because " "[floating-point precision errors](https://en.wikipedia.org/wiki/" "Floating_point#Accuracy_problems) would make using them as hashmap keys " "horribly error-prone." msgstr "" "`f32`と`f64`は`Hash`を実装して **いない** ことに注意しましょう。おそらくこれ" "は[浮動小数点演算時に誤差が発生する](https://en.wikipedia.org/wiki/" "Floating_point#Accuracy_problems)ため、キーとして使用すると、恐ろしいほどエ" "ラーの元となるためです。" #: src/std/hash/alt_key_types.md:15 msgid "" "All collection classes implement `Eq` and `Hash` if their contained type " "also respectively implements `Eq` and `Hash`. For example, `Vec` will " "implement `Hash` if `T` implements `Hash`." msgstr "" "集合型は、その要素となっている全ての型が`Eq`を、あるいは`Hash`を実装している" "場合、必ず同じトレイトを実装しています。例えば、`Vec`は`T`が`Hash`を実装し" "ている場合、`Hash`を実装します。" #: src/std/hash/alt_key_types.md:19 msgid "" "You can easily implement `Eq` and `Hash` for a custom type with just one " "line: `#[derive(PartialEq, Eq, Hash)]`" msgstr "" "独自の型に`Eq`あるいは`Hash`を実装するのは簡単です。以下の一行で済みます。" "`#[derive(PartialEq, Eq, Hash)]`" #: src/std/hash/alt_key_types.md:22 msgid "" "The compiler will do the rest. If you want more control over the details, " "you can implement `Eq` and/or `Hash` yourself. This guide will not cover the " "specifics of implementing `Hash`." msgstr "" "後はコンパイラがよしなにしてくれます。これらのトレイトの詳細をコントロールし" "たい場合、`Eq`や`Hash`を自分で実装することもできます。この文書では`Hash`トレ" "イトを実装する方法の詳細については触れません。" #: src/std/hash/alt_key_types.md:26 msgid "" "To play around with using a `struct` in `HashMap`, let's try making a very " "simple user logon system:" msgstr "" "`struct`を`HashMap`で扱う際の例として、とてもシンプルなユーザーログインシステ" "ムを作成してみましょう。" #: src/std/hash/alt_key_types.md:31 msgid "// Eq requires that you derive PartialEq on the type.\n" msgstr "// Eqトレイトを使用する時は、PartialEqをderiveする必要があります。\n" #: src/std/hash/alt_key_types.md:48 msgid "\"Username: {}\"" msgstr "\"Username: {}\"" #: src/std/hash/alt_key_types.md:49 msgid "\"Password: {}\"" msgstr "\"Password: {}\"" #: src/std/hash/alt_key_types.md:50 msgid "\"Attempting logon...\"" msgstr "\"Attempting logon...\"" #: src/std/hash/alt_key_types.md:59 msgid "\"Successful logon!\"" msgstr "\"Successful logon!\"" #: src/std/hash/alt_key_types.md:60 msgid "\"Name: {}\"" msgstr "\"Name: {}\"" #: src/std/hash/alt_key_types.md:61 msgid "\"Email: {}\"" msgstr "\"Email: {}\"" #: src/std/hash/alt_key_types.md:63 msgid "\"Login failed!\"" msgstr "\"Login failed!\"" #: src/std/hash/alt_key_types.md:71 src/std/hash/alt_key_types.md:82 #: src/std/hash/alt_key_types.md:84 msgid "\"j.everyman\"" msgstr "\"j.everyman\"" #: src/std/hash/alt_key_types.md:72 src/std/hash/alt_key_types.md:84 msgid "\"password123\"" msgstr "\"password123\"" #: src/std/hash/alt_key_types.md:76 msgid "\"John Everyman\"" msgstr "\"John Everyman\"" #: src/std/hash/alt_key_types.md:77 msgid "\"j.everyman@email.com\"" msgstr "\"j.everyman@email.com\"" #: src/std/hash/alt_key_types.md:82 msgid "\"psasword123\"" msgstr "\"psasword123\"" #: src/std/hash/hashset.md:3 msgid "" "Consider a `HashSet` as a `HashMap` where we just care about the keys " "( `HashSet` is, in actuality, just a wrapper around `HashMap`)." msgstr "" "値がなく、キーだけの`HashMap`を想像してみてください。これはハッシュ集合" "（`HashSet`）と呼ばれるものです。（`HashSet`は、実際には`HashMap`の" "ラッパーです。）" #: src/std/hash/hashset.md:6 msgid "" "\"What's the point of that?\" you ask. \"I could just store the keys in a " "`Vec`.\"" msgstr "" "「何の意味があるの？フツーにキーを`Vec`に入れればいいじゃん」そう思いました" "ね？" #: src/std/hash/hashset.md:8 msgid "" "A `HashSet`'s unique feature is that it is guaranteed to not have duplicate " "elements. That's the contract that any set collection fulfills. `HashSet` is " "just one implementation. (see also: [`BTreeSet`](https://doc.rust-lang.org/" "std/collections/struct.BTreeSet.html))" msgstr "" "それは、`HashSet`独自の機能として、要素に重複がないということが保証されるため" "です。これは全ての集合型がもつ機能です。`HashSet`はその実装の1つであり、他に" "は[`BTreeSet`](https://doc.rust-lang.org/std/collections/struct.BTreeSet." "html)等があります。" #: src/std/hash/hashset.md:13 msgid "" "If you insert a value that is already present in the `HashSet`, (i.e. the " "new value is equal to the existing and they both have the same hash), then " "the new value will replace the old." msgstr "" "`HashSet`に、すでに存在する値を加えようとすると、（すなわち、加えようとしてい" "る値のハッシュ値と、要素中のいずれかの値のハッシュ値が等しい場合、）新しい値" "によって古い値が上書きされます。" #: src/std/hash/hashset.md:17 msgid "" "This is great for when you never want more than one of something, or when " "you want to know if you've already got something." msgstr "" "これは、同じ値を2つ以上欲しくない場合や、すでにある値を持っているか知りたい場" "合にとても有効です。" #: src/std/hash/hashset.md:20 msgid "But sets can do more than that." msgstr "しかし、集合型の機能はそれだけではありません。" #: src/std/hash/hashset.md:22 msgid "" "Sets have 4 primary operations (all of the following calls return an " "iterator):" msgstr "集合型には4つの主要なメソッドがあり、（すべてイテレータを返します。）" #: src/std/hash/hashset.md:24 msgid "`union`: get all the unique elements in both sets." msgstr "`union`：2つの集合型のどちらか一方にある値を全て取得。" #: src/std/hash/hashset.md:26 msgid "" "`difference`: get all the elements that are in the first set but not the " "second." msgstr "`difference`：1つ目の集合にあり、かつ2つ目には存在しない値を全て取得。" #: src/std/hash/hashset.md:28 msgid "`intersection`: get all the elements that are only in _both_ sets." msgstr "`intersection`：両方の集合にある値のみを取得。" #: src/std/hash/hashset.md:30 msgid "" "`symmetric_difference`: get all the elements that are in one set or the " "other, but _not_ both." msgstr "" "`symmetric_difference`：どちらか一方の集合には存在するが、両方には **ない** " "値を取得。" #: src/std/hash/hashset.md:33 msgid "Try all of these in the following example:" msgstr "以下の例でこれらをすべて見ていきましょう。" #: src/std/hash/hashset.md:45 msgid "" "// `HashSet::insert()` returns false if\n" " // there was a value already present.\n" msgstr "" "// 既に存在する値を追加しようとすると\n" " // `HashSet::insert()`はfalseを返します。\n" #: src/std/hash/hashset.md:47 msgid "\"Value 4 is already in set B!\"" msgstr "\"Value 4 is already in set B!\"" #: src/std/hash/hashset.md:52 msgid "" "// If a collection's element type implements `Debug`,\n" " // then the collection implements `Debug`.\n" " // It usually prints its elements in the format `[elem1, elem2, ...]`\n" msgstr "" "// 集合の要素が、`Debug`を実装している型の場合、\n" " // 集合そのものも`Debug`を実装します。\n" " // 通常は`[elem1, elem2, ...]`のように要素を出力します。\n" #: src/std/hash/hashset.md:55 msgid "\"A: {:?}\"" msgstr "\"A: {:?}\"" #: src/std/hash/hashset.md:56 msgid "\"B: {:?}\"" msgstr "\"B: {:?}\"" #: src/std/hash/hashset.md:58 msgid "// Print [1, 2, 3, 4, 5] in arbitrary order\n" msgstr "// [1, 2, 3, 4, 5]を順不同に出力。\n" #: src/std/hash/hashset.md:59 msgid "\"Union: {:?}\"" msgstr "\"Union: {:?}\"" #: src/std/hash/hashset.md:61 msgid "// This should print [1]\n" msgstr "// これは[1]を出力。\n" #: src/std/hash/hashset.md:62 msgid "\"Difference: {:?}\"" msgstr "\"Difference: {:?}\"" #: src/std/hash/hashset.md:64 msgid "// Print [2, 3, 4] in arbitrary order.\n" msgstr "// [2, 3, 4]を順不同に出力。\n" #: src/std/hash/hashset.md:65 msgid "\"Intersection: {:?}\"" msgstr "\"Intersection: {:?}\"" #: src/std/hash/hashset.md:67 msgid "// Print [1, 5]\n" msgstr "// [1, 5]を出力。\n" #: src/std/hash/hashset.md:68 msgid "\"Symmetric Difference: {:?}\"" msgstr "\"Symmetric Difference: {:?}\"" #: src/std/hash/hashset.md:73 msgid "" "(Examples are adapted from the [documentation.](https://doc.rust-lang.org/" "std/collections/struct.HashSet.html#method.difference))" msgstr "" "例は[公式ドキュメント](https://doc.rust-lang.org/std/collections/struct." "HashSet.html#method.difference)から持ってきています。" #: src/std/rc.md:3 msgid "" "When multiple ownership is needed, `Rc`(Reference Counting) can be used. " "`Rc` keeps track of the number of the references which means the number of " "owners of the value wrapped inside an `Rc`." msgstr "" #: src/std/rc.md:5 msgid "" "Reference count of an `Rc` increases by 1 whenever an `Rc` is cloned, and " "decreases by 1 whenever one cloned `Rc` is dropped out of the scope. When an " "`Rc`'s reference count becomes zero (which means there are no remaining " "owners), both the `Rc` and the value are all dropped." msgstr "" #: src/std/rc.md:7 msgid "" "Cloning an `Rc` never performs a deep copy. Cloning creates just another " "pointer to the wrapped value, and increments the count." msgstr "" #: src/std/rc.md:13 msgid "\"Rc examples\"" msgstr "\"Rc examples\"" #: src/std/rc.md:15 msgid "\"--- rc_a is created ---\"" msgstr "\"--- rc_a is created ---\"" #: src/std/rc.md:18 src/std/rc.md:25 src/std/rc.md:37 msgid "\"Reference Count of rc_a: {}\"" msgstr "\"Reference Count of rc_a: {}\"" #: src/std/rc.md:21 msgid "\"--- rc_a is cloned to rc_b ---\"" msgstr "\"--- rc_a is cloned to rc_b ---\"" #: src/std/rc.md:24 msgid "\"Reference Count of rc_b: {}\"" msgstr "\"Reference Count of rc_b: {}\"" #: src/std/rc.md:27 msgid "// Two `Rc`s are equal if their inner values are equal\n" msgstr "" #: src/std/rc.md:28 msgid "\"rc_a and rc_b are equal: {}\"" msgstr "\"rc_a and rc_b are equal: {}\"" #: src/std/rc.md:30 msgid "// We can use methods of a value directly\n" msgstr "" #: src/std/rc.md:31 msgid "\"Length of the value inside rc_a: {}\"" msgstr "\"Length of the value inside rc_a: {}\"" #: src/std/rc.md:32 msgid "\"Value of rc_b: {}\"" msgstr "\"Value of rc_b: {}\"" #: src/std/rc.md:34 msgid "\"--- rc_b is dropped out of scope ---\"" msgstr "\"--- rc_b is dropped out of scope ---\"" #: src/std/rc.md:39 msgid "\"--- rc_a is dropped out of scope ---\"" msgstr "\"--- rc_a is dropped out of scope ---\"" #: src/std/rc.md:42 msgid "" "// Error! `rc_examples` already moved into `rc_a`\n" " // And when `rc_a` is dropped, `rc_examples` is dropped together\n" " // println!(\"rc_examples: {}\", rc_examples);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" #: src/std/rc.md:51 msgid "" "[std::rc](https://doc.rust-lang.org/std/rc/index.html) and [std::sync::arc]" "(https://doc.rust-lang.org/std/sync/struct.Arc.html)." msgstr "" #: src/std/arc.md:1 msgid "Arc" msgstr "" #: src/std/arc.md:3 msgid "" "When shared ownership between threads is needed, `Arc`(Atomically Reference " "Counted) can be used. This struct, via the `Clone` implementation can create " "a reference pointer for the location of a value in the memory heap while " "increasing the reference counter. As it shares ownership between threads, " "when the last reference pointer to a value is out of scope, the variable is " "dropped." msgstr "" #: src/std/arc.md:15 msgid "// This variable declaration is where its value is specified.\n" msgstr "" #: src/std/arc.md:16 msgid "\"the same apple\"" msgstr "\"the same apple\"" #: src/std/arc.md:19 msgid "" "// Here there is no value specification as it is a pointer to a\n" " // reference in the memory heap.\n" msgstr "" #: src/std/arc.md:24 msgid "" "// As Arc was used, threads can be spawned using the value allocated\n" " // in the Arc variable pointer's location.\n" msgstr "" #: src/std/arc.md:30 msgid "// Make sure all Arc instances are printed from spawned threads.\n" msgstr "" #: src/std_misc.md:3 msgid "" "Many other types are provided by the std library to support things such as:" msgstr "" "他にも、様々な型がstdライブラリの中で提供されています。例えば以下の機能を果た" "すための物があります。" #: src/std_misc.md:10 msgid "These expand beyond what the [primitives](primitives.md) provide." msgstr "" "これらにより[基本データ型](primitives.md)の提供する機能よりも遥かに豊かなこと" "が実現できます。" #: src/std_misc/threads.md:3 msgid "" "Rust provides a mechanism for spawning native OS threads via the `spawn` " "function, the argument of this function is a moving closure." msgstr "" "Rustは`spawn`関数を用いてOSのネイティブスレッドを開始することができます。この" "関数の引数はmoveクロージャ（訳注: 参照ではなく値を取るクロージャ）です。" #: src/std_misc/threads.md:10 src/std_misc/threads/testcase_mapreduce.md:28 msgid "// This is the `main` thread\n" msgstr "// この関数は`main`スレッドで実行されます。\n" #: src/std_misc/threads.md:13 msgid "// Make a vector to hold the children which are spawned.\n" msgstr "// spawnされるクロージャを保持するためのベクタ\n" #: src/std_misc/threads.md:17 msgid "// Spin up another thread\n" msgstr "// 新しいスレッドを起動。\n" #: src/std_misc/threads.md:19 msgid "\"this is thread number {}\"" msgstr "\"this is thread number {}\"" #: src/std_misc/threads.md:24 msgid "// Wait for the thread to finish. Returns a result.\n" msgstr "// 子スレッドが終了するのを待ち、結果を返します。\n" #: src/std_misc/threads.md:30 msgid "These threads will be scheduled by the OS." msgstr "これらのスレッドのスケジューリングはOSによって行われます。" #: src/std_misc/threads/testcase_mapreduce.md:3 msgid "" "Rust makes it very easy to parallelise data processing, without many of the " "headaches traditionally associated with such an attempt." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:5 msgid "" "The standard library provides great threading primitives out of the box. " "These, combined with Rust's concept of Ownership and aliasing rules, " "automatically prevent data races." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:9 msgid "" "The aliasing rules (one writable reference XOR many readable references) " "automatically prevent you from manipulating state that is visible to other " "threads. (Where synchronisation is needed, there are synchronisation " "primitives like `Mutex`es or `Channel`s.)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:14 msgid "" "In this example, we will calculate the sum of all digits in a block of " "numbers. We will do this by parcelling out chunks of the block into " "different threads. Each thread will sum its tiny block of digits, and " "subsequently we will sum the intermediate sums produced by each thread." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:19 msgid "" "Note that, although we're passing references across thread boundaries, Rust " "understands that we're only passing read-only references, and that thus no " "unsafety or data races can occur. Also because the references we're passing " "have `'static` lifetimes, Rust understands that our data won't be destroyed " "while these threads are still running. (When you need to share non-`static` " "data between threads, you can use a smart pointer like `Arc` to keep the " "data alive and avoid non-`static` lifetimes.)" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:32 msgid "" "// This is our data to process.\n" " // We will calculate the sum of all digits via a threaded map-reduce " "algorithm.\n" " // Each whitespace separated chunk will be handled in a different " "thread.\n" " //\n" " // TODO: see what happens to the output if you insert spaces!\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:37 msgid "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" msgstr "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" #: src/std_misc/threads/testcase_mapreduce.md:46 msgid "// Make a vector to hold the child-threads which we will spawn.\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:49 msgid "" "/*************************************************************************\n" " * \"Map\" phase\n" " *\n" " * Divide our data into segments, and apply initial processing\n" " ************************************************************************/" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:55 msgid "" "// split our data into segments for individual calculation\n" " // each chunk will be a reference (&str) into the actual data\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:59 msgid "" "// Iterate over the data segments.\n" " // .enumerate() adds the current loop index to whatever is iterated\n" " // the resulting tuple \"(index, element)\" is then immediately\n" " // \"destructured\" into two variables, \"i\" and \"data_segment\" with " "a\n" " // \"destructuring assignment\"\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:65 msgid "\"data segment {} is \\\"{}\\\"\"" msgstr "\"data segment {} is \\\"{}\\\"\"" #: src/std_misc/threads/testcase_mapreduce.md:67 msgid "" "// Process each data segment in a separate thread\n" " //\n" " // spawn() returns a handle to the new thread,\n" " // which we MUST keep to access the returned value\n" " //\n" " // 'move || -> u32' is syntax for a closure that:\n" " // * takes no arguments ('||')\n" " // * takes ownership of its captured variables ('move') and\n" " // * returns an unsigned 32-bit integer ('-> u32')\n" " //\n" " // Rust is smart enough to infer the '-> u32' from\n" " // the closure itself so we could have left that out.\n" " //\n" " // TODO: try removing the 'move' and see what happens\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:82 msgid "// Calculate the intermediate sum of this segment:\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:84 msgid "// iterate over the characters of our segment..\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:86 msgid "// .. convert text-characters to their number value..\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:87 msgid "\"should be a digit\"" msgstr "\"should be a digit\"" #: src/std_misc/threads/testcase_mapreduce.md:88 msgid "// .. and sum the resulting iterator of numbers\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:91 msgid "// println! locks stdout, so no text-interleaving occurs\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:92 msgid "\"processed segment {}, result={}\"" msgstr "\"processed segment {}, result={}\"" #: src/std_misc/threads/testcase_mapreduce.md:94 msgid "" "// \"return\" not needed, because Rust is an \"expression language\", the\n" " // last evaluated expression in each block is automatically its " "value.\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:102 msgid "" "/*************************************************************************\n" " * \"Reduce\" phase\n" " *\n" " * Collect our intermediate results, and combine them into a final " "result\n" " ************************************************************************/" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:108 msgid "" "// combine each thread's intermediate results into a single final sum.\n" " //\n" " // we use the \"turbofish\" ::<> to provide sum() with a type hint.\n" " //\n" " // TODO: try without the turbofish, by instead explicitly\n" " // specifying the type of final_result\n" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:116 msgid "\"Final sum result: {}\"" msgstr "\"Final sum result: {}\"" #: src/std_misc/threads/testcase_mapreduce.md:122 msgid "Assignments" msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:123 msgid "" "It is not wise to let our number of threads depend on user inputted data. " "What if the user decides to insert a lot of spaces? Do we _really_ want to " "spawn 2,000 threads? Modify the program so that the data is always chunked " "into a limited number of chunks, defined by a static constant at the " "beginning of the program." msgstr "" #: src/std_misc/threads/testcase_mapreduce.md:129 msgid "[Threads](../threads.md)" msgstr "[スレッド](../threads.md)" #: src/std_misc/threads/testcase_mapreduce.md:130 msgid "[vectors](../../std/vec.md) and [iterators](../../trait/iter.md)" msgstr "[ベクタ型](../../std/vec.md), [イテレータ](../../trait/iter.md)" #: src/std_misc/threads/testcase_mapreduce.md:131 msgid "" "[closures](../../fn/closures.md), [move](../../scope/move.md) semantics and " "[`move` closures](https://doc.rust-lang.org/book/ch13-01-closures." "html#closures-can-capture-their-environment)" msgstr "" "[クロージャ](../../fn/closures.md), [move](../../scope/move.md) semantics " "and [`move` クロージャ](https://doc.rust-lang.org/book/ch13-01-closures." "html#closures-can-capture-their-environment)" #: src/std_misc/threads/testcase_mapreduce.md:132 msgid "" "[destructuring](https://doc.rust-lang.org/book/ch18-03-pattern-syntax." "html#destructuring-to-break-apart-values) assignments" msgstr "" "[デストラクト](https://doc.rust-lang.org/book/ch18-03-pattern-syntax." "html#destructuring-to-break-apart-values) 代入" #: src/std_misc/threads/testcase_mapreduce.md:133 msgid "" "[turbofish notation](https://doc.rust-lang.org/book/appendix-02-operators." "html?highlight=turbofish) to help type inference" msgstr "" "型推論を補助する [ターボフィッシュ記法](https://doc.rust-lang.org/book/" "appendix-02-operators.html?highlight=turbofish)" #: src/std_misc/threads/testcase_mapreduce.md:134 msgid "[unwrap vs. expect](../../error/option_unwrap.md)" msgstr "[unwrap と expect](../../error/option_unwrap.md)" #: src/std_misc/threads/testcase_mapreduce.md:135 msgid "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" msgstr "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" #: src/std_misc/channels.md:3 msgid "" "Rust provides asynchronous `channels` for communication between threads. " "Channels allow a unidirectional flow of information between two end-points: " "the `Sender` and the `Receiver`." msgstr "" "Rustは、スレッド間のコミュニケーションのために、非同期のチャネルを提供してい" "ます。チャネルは2つのエンドポイント、すなわち送信者と受信者を介して、情報の一" "方向への流れを作り出すことを可能にしています。" #: src/std_misc/channels.md:15 msgid "" "// Channels have two endpoints: the `Sender` and the `Receiver`,\n" " // where `T` is the type of the message to be transferred\n" " // (type annotation is superfluous)\n" msgstr "" "// チャネルには`Sender`と`Receiver`という2つのエンドポイントがありま" "す。\n" " // ここで、`T`は送信されるメッセージの型です。\n" " // （型アノテーションは必須ではありません。）\n" #: src/std_misc/channels.md:22 msgid "// The sender endpoint can be copied\n" msgstr "// 送信者エンドポイントはコピーすることができます。\n" #: src/std_misc/channels.md:25 msgid "// Each thread will send its id via the channel\n" msgstr "// ここでは、それぞれのスレッドが自身のIDを送信しています。\n" #: src/std_misc/channels.md:27 msgid "" "// The thread takes ownership over `thread_tx`\n" " // Each thread queues a message in the channel\n" msgstr "" "// スレッドは`thread_tx`の所有権をとり、それぞれのスレッドは\n" " // メッセージをチャネルにキューイングします。\n" #: src/std_misc/channels.md:31 msgid "" "// Sending is a non-blocking operation, the thread will continue\n" " // immediately after sending its message\n" msgstr "" "// 送信はノンブロッキングなオペレーションなので、\n" " // メッセージを送信した後もすぐに実行を継続します。\n" #: src/std_misc/channels.md:33 msgid "\"thread {} finished\"" msgstr "\"thread {} finished\"" #: src/std_misc/channels.md:39 msgid "// Here, all the messages are collected\n" msgstr "// ここで、全てのメッセージが収集されます。\n" #: src/std_misc/channels.md:42 msgid "" "// The `recv` method picks a message from the channel\n" " // `recv` will block the current thread if there are no messages " "available\n" msgstr "" "// `recv`メソッドはチャネルからメッセージを取り出します。\n" " // もし取り出せるメッセージが存在しない場合、`recv`は\n" " // 現在のスレッドをブロックします。\n" #: src/std_misc/channels.md:47 msgid "// Wait for the threads to complete any remaining work\n" msgstr "" #: src/std_misc/channels.md:49 msgid "\"oops! the child thread panicked\"" msgstr "\"oops! the child thread panicked\"" #: src/std_misc/channels.md:52 msgid "// Show the order in which the messages were sent\n" msgstr "// メッセージが送信された順番を表示。\n" #: src/std_misc/path.md:3 msgid "" "The `Path` struct represents file paths in the underlying filesystem. There " "are two flavors of `Path`: `posix::Path`, for UNIX-like systems, and " "`windows::Path`, for Windows. The prelude exports the appropriate platform-" "specific `Path` variant." msgstr "" "構造体`Path`は、ファイルシステム中のパスを表します。`Path`には2つの変種があり" "ます。UNIXライクなファイルシステムのための`posix::Path`と、Windows用の" "`windows::Path`です。それぞれプラットフォームに対応した`Path`をエクスポートし" "ます。" #: src/std_misc/path.md:8 msgid "" "A `Path` can be created from an `OsStr`, and provides several methods to get " "information from the file/directory the path points to." msgstr "" "`Path`は`OsStr`から作ることができます。そうすればそのパスが指すファイル・ディ" "レクトリの情報を取得するためのメソッドがいくつか使えるようになります。" #: src/std_misc/path.md:11 msgid "" "A `Path` is immutable. The owned version of `Path` is `PathBuf`. The " "relation between `Path` and `PathBuf` is similar to that of `str` and " "`String`: a `PathBuf` can be mutated in-place, and can be dereferenced to a " "`Path`." msgstr "" "`Path`はイミュータブルです。`Path`の所有権ありのバージョンが`PathBuf`です。" "`Path`と`PathBuf`の関係は、`str`と`String`の関係に似ています。`PathBuf`はその" "まま変更でき、`Path`にデリファレンスすることができます。" #: src/std_misc/path.md:15 msgid "" "Note that a `Path` is _not_ internally represented as an UTF-8 string, but " "instead is stored as an `OsString`. Therefore, converting a `Path` to a " "`&str` is _not_ free and may fail (an `Option` is returned). However, a " "`Path` can be freely converted to an `OsString` or `&OsStr` using " "`into_os_string` and `as_os_str`, respectively." msgstr "" "`Path`の実態はUTF-8の文字列 **ではなく** 、`OsString`であることに注意しましょ" "う。したがって、`Path`を`&str`に変換するのは無条件 **ではなく** 、失敗する可" "能性があります。それゆえ`Option`型が返されます。しかし`Path`から`OsString`あ" "るいは`&OsStr`への変換はそれぞれ`into_os_string`と`as_os_str`によって無条件で" "できます。" #: src/std_misc/path.md:25 msgid "// Create a `Path` from an `&'static str`\n" msgstr "// `&'static str`から`Path`を作成。\n" #: src/std_misc/path.md:26 msgid "\".\"" msgstr "\".\"" #: src/std_misc/path.md:28 msgid "// The `display` method returns a `Display`able structure\n" msgstr "// `display`メソッドは`Display`可能な構造体を返します。\n" #: src/std_misc/path.md:31 msgid "" "// `join` merges a path with a byte container using the OS specific\n" " // separator, and returns a `PathBuf`\n" msgstr "" "// `join`はOS固有のセパレータによってバイトのコンテナ型であるパス\n" " // を結合し、`PathBuf`を返します。\n" #: src/std_misc/path.md:35 msgid "// `push` extends the `PathBuf` with a `&Path`\n" msgstr "// `push`は`PathBuf`を`&Path`で拡張します。\n" #: src/std_misc/path.md:37 msgid "\"myfile.tar.gz\"" msgstr "\"myfile.tar.gz\"" #: src/std_misc/path.md:39 msgid "// `set_file_name` updates the file name of the `PathBuf`\n" msgstr "// `set_file_name`は`PathBuf`のファイル名を更新します。\n" #: src/std_misc/path.md:40 msgid "\"package.tgz\"" msgstr "\"package.tgz\"" #: src/std_misc/path.md:42 msgid "// Convert the `PathBuf` into a string slice\n" msgstr "// `PathBuf`を文字列のスライスに変換します。\n" #: src/std_misc/path.md:44 msgid "\"new path is not a valid UTF-8 sequence\"" msgstr "\"new path is not a valid UTF-8 sequence\"" #: src/std_misc/path.md:45 msgid "\"new path is {}\"" msgstr "\"new path is {}\"" #: src/std_misc/path.md:51 msgid "" "Be sure to check at other `Path` methods (`posix::Path` or `windows::Path`) " "and the `Metadata` struct." msgstr "" "他の`Path`メソッド（`posix::Path`と`windows::Path`）をチェックするのを忘れず" "に！それと`Metadata`構造体も見ておくことをオススメします。" #: src/std_misc/path.md:56 msgid "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) and [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)." msgstr "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html), [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)." #: src/std_misc/file.md:3 msgid "" "The `File` struct represents a file that has been opened (it wraps a file " "descriptor), and gives read and/or write access to the underlying file." msgstr "" "`File`構造体は開かれたファイルを表し（実際にはファイルディスクリプタのラッ" "パーです）、読み込み・書き込み権限のどちらか一方、あるいは両方を提供します。" #: src/std_misc/file.md:6 msgid "" "Since many things can go wrong when doing file I/O, all the `File` methods " "return the `io::Result` type, which is an alias for `Result`." msgstr "" #: src/std_misc/file.md:9 msgid "" "This makes the failure of all I/O operations _explicit_. Thanks to this, the " "programmer can see all the failure paths, and is encouraged to handle them " "in a proactive manner." msgstr "" "これはI/Oに関するオペレーションの失敗をより明瞭にします。このおかげでプログラ" "マは直面した失敗を全て見ることができ、より生産的な方法でそれらを扱うことが可" "能になります。" #: src/std_misc/file/open.md:3 msgid "The `open` function can be used to open a file in read-only mode." msgstr "" "`open`関数を用いることで読み込み専用モードでファイルを開くことが可能です。" #: src/std_misc/file/open.md:5 msgid "" "A `File` owns a resource, the file descriptor and takes care of closing the " "file when it is `drop`ed." msgstr "" "`File`はファイルディスクリプタという資源を保持しており、`drop`時にはファイル" "を閉じるところまで面倒を見てくれます。" #: src/std_misc/file/open.md:14 msgid "// Create a path to the desired file\n" msgstr "// 目的ファイルに対する`Path`を作成\n" #: src/std_misc/file/open.md:15 msgid "\"hello.txt\"" msgstr "\"hello.txt\"" #: src/std_misc/file/open.md:18 msgid "// Open the path in read-only mode, returns `io::Result`\n" msgstr "" "// pathを読み込み専用モードで開きます。これは`io::Result`を返します。\n" #: src/std_misc/file/open.md:20 msgid "\"couldn't open {}: {}\"" msgstr "\"couldn't open {}: {}\"" #: src/std_misc/file/open.md:24 msgid "// Read the file contents into a string, returns `io::Result`\n" msgstr "" "// ファイルの中身を文字列に読み込みます。`io::Result`を返します。\n" #: src/std_misc/file/open.md:27 msgid "\"couldn't read {}: {}\"" msgstr "\"couldn't read {}: {}\"" #: src/std_misc/file/open.md:28 msgid "\"{} contains:\\n{}\"" msgstr "\"{} contains:\\n{}\"" #: src/std_misc/file/open.md:31 msgid "// `file` goes out of scope, and the \"hello.txt\" file gets closed\n" msgstr "// `file`がスコープから抜け、\"hello.txt\"が閉じられます。\n" #: src/std_misc/file/open.md:35 src/std_misc/file/create.md:39 #: src/std_misc/fs.md:109 msgid "Here's the expected successful output:" msgstr "以下が成功時に期待されるアウトプットです。" #: src/std_misc/file/open.md:37 msgid "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt contains:\n" "Hello World!\n" "```" msgstr "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt contains:\n" "Hello World!\n" "```" #: src/std_misc/file/open.md:44 msgid "" "(You are encouraged to test the previous example under different failure " "conditions: `hello.txt` doesn't exist, or `hello.txt` is not readable, etc.)" msgstr "" "（気が向いたなら、上記の例を様々な形で失敗させてみましょう。例えば`hello.txt`" "が存在しないとか、読み込み権限がないとか、そういった状況で実行してみてくださ" "い。）" #: src/std_misc/file/create.md:3 msgid "" "The `create` function opens a file in write-only mode. If the file already " "existed, the old content is destroyed. Otherwise, a new file is created." msgstr "" "`create`関数はファイルを書き込み専用モードで開きます。すでにファイルが存在し" "ている場合、破棄して新しい物を作成します。" #: src/std_misc/file/create.md:9 msgid "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" msgstr "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" #: src/std_misc/file/create.md:22 msgid "\"lorem_ipsum.txt\"" msgstr "\"lorem_ipsum.txt\"" #: src/std_misc/file/create.md:25 msgid "// Open a file in write-only mode, returns `io::Result`\n" msgstr "" "// ファイルを書き込み専用モードで開きます。返り値は`io::Result`。\n" #: src/std_misc/file/create.md:27 msgid "\"couldn't create {}: {}\"" msgstr "\"couldn't create {}: {}\"" #: src/std_misc/file/create.md:31 msgid "// Write the `LOREM_IPSUM` string to `file`, returns `io::Result<()>`\n" msgstr "" "// `LOREM_IPSUM`の文字列を`file`に書き込みます。返り値は`io::Result<()>`。\n" #: src/std_misc/file/create.md:33 msgid "\"couldn't write to {}: {}\"" msgstr "\"couldn't write to {}: {}\"" #: src/std_misc/file/create.md:34 msgid "\"successfully wrote to {}\"" msgstr "\"successfully wrote to {}\"" #: src/std_misc/file/create.md:53 msgid "" "(As in the previous example, you are encouraged to test this example under " "failure conditions.)" msgstr "" "前項の例と同じように、様々な失敗パターンをためしてみることをオススメします。" #: src/std_misc/file/create.md:56 msgid "" "The [`OpenOptions`](https://doc.rust-lang.org/std/fs/struct.OpenOptions." "html) struct can be used to configure how a file is opened." msgstr "" "[`OpenOptions`](https://doc.rust-lang.org/std/fs/struct.OpenOptions.html)構造" "体を利用して、ファイルの開き方を設定できます。" #: src/std_misc/file/read_lines.md:3 msgid "A naive approach" msgstr "単純なやり方" #: src/std_misc/file/read_lines.md:5 msgid "" "This might be a reasonable first attempt for a beginner's first " "implementation for reading lines from a file." msgstr "" "テキストファイルの行を読み込むのを、初心者が初めて実装した場合、以下のように" "なるでしょう。" #: src/std_misc/file/read_lines.md:22 msgid "" "Since the method `lines()` returns an iterator over the lines in the file, " "we can also perform a map inline and collect the results, yielding a more " "concise and fluent expression." msgstr "" "`lines()`メソッドはファイルの各行のイテレータを返すので、インラインでマップを" "実行し結果を収集することもできます。そうすると、より簡潔で読みやすい表現とな" "ります。" #: src/std_misc/file/read_lines.md:31 msgid "// panic on possible file-reading errors\n" msgstr "// ファイル読み込みエラーの場合はパニックします。\n" #: src/std_misc/file/read_lines.md:32 msgid "// split the string into an iterator of string slices\n" msgstr "// 文字列のスライスのイテレータに分割します。\n" #: src/std_misc/file/read_lines.md:33 msgid "// make each slice into a string\n" msgstr "// スライスを文字列に変換します。\n" #: src/std_misc/file/read_lines.md:34 msgid "// gather them together into a vector\n" msgstr "// ベクタにまとめます。\n" #: src/std_misc/file/read_lines.md:38 msgid "" "Note that in both examples above, we must convert the `&str` reference " "returned from `lines()` to the owned type `String`, using `.to_string()` and " "`String::from` respectively." msgstr "" "上の例では、`lines()`から返された`&str`をそれぞれ`to_string()`と`String::" "from`を使って、所有権のある`String`型に変換しなければならない点に注意してくだ" "さい。" #: src/std_misc/file/read_lines.md:42 msgid "A more efficient approach" msgstr "より効率的なやり方" #: src/std_misc/file/read_lines.md:44 msgid "" "Here we pass ownership of the open `File` to a `BufReader` struct. " "`BufReader` uses an internal buffer to reduce intermediate allocations." msgstr "" "ここでは、開いた`File`の所有権を`BufReader`構造体に渡します。`BufReader`は内" "部的なバッファを使い、中間のメモリ割り当てを削減します。" #: src/std_misc/file/read_lines.md:47 msgid "" "We also update `read_lines` to return an iterator instead of allocating new " "`String` objects in memory for each line." msgstr "" "`read_lines`を更新して、それぞれの行に対してメモリ上に新しい`String`オブジェ" "クトを割り当てるのではなく、イテレータを返すようにします。" #: src/std_misc/file/read_lines.md:56 msgid "// File hosts.txt must exist in the current path\n" msgstr "// hosts.txtファイルは現在のパスに存在しなければなりません。\n" #: src/std_misc/file/read_lines.md:57 msgid "\"./hosts.txt\"" msgstr "\"./hosts.txt\"" #: src/std_misc/file/read_lines.md:58 msgid "// Consumes the iterator, returns an (Optional) String\n" msgstr "// イテレータを消費し、Option型のStringを返します。\n" #: src/std_misc/file/read_lines.md:64 msgid "" "// The output is wrapped in a Result to allow matching on errors.\n" "// Returns an Iterator to the Reader of the lines of the file.\n" msgstr "" "// 出力はResult型にラップされ、エラーをマッチできるようになります。\n" "// ファイルの各行のReaderへのイテレータを返します。\n" #: src/std_misc/file/read_lines.md:74 msgid "Running this program simply prints the lines individually." msgstr "このプログラムを実行すると、単に各行を出力します。" #: src/std_misc/file/read_lines.md:75 msgid "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" msgstr "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" #: src/std_misc/file/read_lines.md:82 msgid "" "(Note that since `File::open` expects a generic `AsRef` as argument, " "we define our generic `read_lines()` method with the same generic " "constraint, using the `where` keyword.)" msgstr "" "`File::open`はジェネリックな`AsRef`を引数にとるので、ジェネリックな" "`read_lines`メソッドも、`where`キーワードを使って、同じジェネリックな制約を持" "たせています。" #: src/std_misc/file/read_lines.md:85 msgid "" "This process is more efficient than creating a `String` in memory with all " "of the file's contents. This can especially cause performance issues when " "working with larger files." msgstr "" "この処理は、ファイルの中身全てをメモリ上の`String`にするよりも効率的です。メ" "モリ上に`String`を作ると、より大きなファイルを取り扱う際に、パフォーマンスの" "問題につながります。" #: src/std_misc/process.md:3 msgid "" "The `process::Output` struct represents the output of a finished child " "process, and the `process::Command` struct is a process builder." msgstr "" "`process::Output`構造体は終了したプロセスのアウトプットを表し、`process::" "Command`構造体はプロセスの作成を行います。" #: src/std_misc/process.md:10 msgid "\"rustc\"" msgstr "\"rustc\"" #: src/std_misc/process.md:11 msgid "\"--version\"" msgstr "\"--version\"" #: src/std_misc/process.md:13 msgid "\"failed to execute process: {}\"" msgstr "\"failed to execute process: {}\"" #: src/std_misc/process.md:19 msgid "\"rustc succeeded and stdout was:\\n{}\"" msgstr "\"rustc succeeded and stdout was:\\n{}\"" #: src/std_misc/process.md:23 msgid "\"rustc failed and stderr was:\\n{}\"" msgstr "\"rustc failed and stderr was:\\n{}\"" #: src/std_misc/process.md:28 msgid "" "(You are encouraged to try the previous example with an incorrect flag " "passed to `rustc`)" msgstr "" "（余裕があれば、上の例で`rustc`に不正なフラグを渡し、どうなるか見てみましょ" "う）" #: src/std_misc/process/pipe.md:3 msgid "" "The `std::Child` struct represents a running child process, and exposes the " "`stdin`, `stdout` and `stderr` handles for interaction with the underlying " "process via pipes." msgstr "" "`std::Child`構造体は実行中の子プロセスを表します。`stdin`、`stdout`、`stderr`" "を介して表面化のプロセスとのやり取りを仲介します。" #: src/std_misc/process/pipe.md:11 msgid "\"the quick brown fox jumps over the lazy dog\\n\"" msgstr "\"the quick brown fox jumps over the lazy dog\\n\"" #: src/std_misc/process/pipe.md:15 msgid "// Spawn the `wc` command\n" msgstr "// `wc`コマンドを起動します。\n" #: src/std_misc/process/pipe.md:16 src/std_misc/fs.md:12 src/std_misc/fs.md:73 #: src/std_misc/ffi.md:11 msgid "\"windows\"" msgstr "\"windows\"" #: src/std_misc/process/pipe.md:17 msgid "\"powershell\"" msgstr "\"powershell\"" #: src/std_misc/process/pipe.md:18 msgid "\"-Command\"" msgstr "\"-Command\"" #: src/std_misc/process/pipe.md:18 msgid "\"$input | Measure-Object -Line -Word -Character\"" msgstr "\"$input | Measure-Object -Line -Word -Character\"" #: src/std_misc/process/pipe.md:21 msgid "\"wc\"" msgstr "\"wc\"" #: src/std_misc/process/pipe.md:27 msgid "\"couldn't spawn wc: {}\"" msgstr "\"couldn't spawn wc: {}\"" #: src/std_misc/process/pipe.md:31 msgid "" "// Write a string to the `stdin` of `wc`.\n" " //\n" " // `stdin` has type `Option`, but since we know this " "instance\n" " // must have one, we can directly `unwrap` it.\n" msgstr "" "// `wc`の`stdin`に文字列を書き込みます。\n" " //\n" " // `stdin`は`Option`型を持ちますが、今回は値を持っていること" "が\n" " // 確かなので、いきなり`unwrap`してしまって構いません。\n" #: src/std_misc/process/pipe.md:36 msgid "\"couldn't write to wc stdin: {}\"" msgstr "\"couldn't write to wc stdin: {}\"" #: src/std_misc/process/pipe.md:37 msgid "\"sent pangram to wc\"" msgstr "\"sent pangram to wc\"" #: src/std_misc/process/pipe.md:40 msgid "" "// Because `stdin` does not live after the above calls, it is `drop`ed,\n" " // and the pipe is closed.\n" " //\n" " // This is very important, otherwise `wc` wouldn't start processing the\n" " // input we just sent.\n" msgstr "" "// `stdin`は上のプロセスコールのあとには有効でないので、`drop`され、\n" " // パイプはcloseされます。\n" " //\n" " // これは非常に重要です。というのもcloseしないと`wc`は\n" " // 送った値の処理を開始しないからです。\n" #: src/std_misc/process/pipe.md:46 msgid "" "// The `stdout` field also has type `Option` so must be " "unwrapped.\n" msgstr "" "// `stdout`フィールドも`Option`型なのでアンラップする必要があり" "ます\n" #: src/std_misc/process/pipe.md:49 msgid "\"couldn't read wc stdout: {}\"" msgstr "\"couldn't read wc stdout: {}\"" #: src/std_misc/process/pipe.md:50 msgid "\"wc responded with:\\n{}\"" msgstr "\"wc responded with:\\n{}\"" #: src/std_misc/process/wait.md:3 msgid "" "If you'd like to wait for a `process::Child` to finish, you must call " "`Child::wait`, which will return a `process::ExitStatus`." msgstr "" "`process::Child`が終了するのを待ちたい場合は、`process::ExitStatus`を返す" "`Child::wait`を呼び出さなくてはなりません。" #: src/std_misc/process/wait.md:10 msgid "\"sleep\"" msgstr "\"sleep\"" #: src/std_misc/process/wait.md:13 msgid "\"reached end of main\"" msgstr "\"reached end of main\"" #: src/std_misc/process/wait.md:18 msgid "" "# `wait` keeps running for 5 seconds until the `sleep 5` command finishes\n" msgstr "# `wait`は`sleep 5`コマンドが終了するまで5秒間実行され続けます。\n" #: src/std_misc/fs.md:3 msgid "" "The `std::fs` module contains several functions that deal with the " "filesystem." msgstr "" "`std::fs`モジュールはファイルシステムとやり取りするための関数をいくつか持って" "います。" #: src/std_misc/fs.md:10 src/std_misc/fs.md:68 src/std_misc/ffi.md:20 msgid "\"unix\"" msgstr "\"unix\"" #: src/std_misc/fs.md:15 msgid "// A simple implementation of `% cat path`\n" msgstr "// `% cat path`のシンプルな実装\n" #: src/std_misc/fs.md:25 msgid "// A simple implementation of `% echo s > path`\n" msgstr "// `% echo s > path`の簡単な実装\n" #: src/std_misc/fs.md:32 msgid "// A simple implementation of `% touch path` (ignores existing files)\n" msgstr "" "// `% touch path`の簡単な実装（すでにファイルが存在しても無視します。）\n" #: src/std_misc/fs.md:42 msgid "\"`mkdir a`\"" msgstr "\"`mkdir a`\"" #: src/std_misc/fs.md:43 msgid "// Create a directory, returns `io::Result<()>`\n" msgstr "// ディレクトリを作成します。返り値は`io::Result<()>`。\n" #: src/std_misc/fs.md:45 src/std_misc/fs.md:52 src/std_misc/fs.md:58 #: src/std_misc/fs.md:63 src/std_misc/fs.md:70 src/std_misc/fs.md:75 #: src/std_misc/fs.md:81 src/std_misc/fs.md:88 src/std_misc/fs.md:97 #: src/std_misc/fs.md:103 msgid "\"! {:?}\"" msgstr "\"! {:?}\"" #: src/std_misc/fs.md:49 msgid "\"`echo hello > a/b.txt`\"" msgstr "\"`echo hello > a/b.txt`\"" #: src/std_misc/fs.md:50 msgid "" "// The previous match can be simplified using the `unwrap_or_else` method\n" msgstr "// 上のmatchは`unwrap_or_else`をメソッドを用いて簡略化できます。\n" #: src/std_misc/fs.md:51 msgid "\"a/b.txt\"" msgstr "\"a/b.txt\"" #: src/std_misc/fs.md:55 msgid "\"`mkdir -p a/c/d`\"" msgstr "\"`mkdir -p a/c/d`\"" #: src/std_misc/fs.md:56 msgid "// Recursively create a directory, returns `io::Result<()>`\n" msgstr "// 再帰的にディレクトリを作成します。返り値は`io::Result<()>`。\n" #: src/std_misc/fs.md:57 src/std_misc/fs.md:102 msgid "\"a/c/d\"" msgstr "\"a/c/d\"" #: src/std_misc/fs.md:61 msgid "\"`touch a/c/e.txt`\"" msgstr "\"`touch a/c/e.txt`\"" #: src/std_misc/fs.md:62 src/std_misc/fs.md:96 msgid "\"a/c/e.txt\"" msgstr "\"a/c/e.txt\"" #: src/std_misc/fs.md:66 msgid "\"`ln -s ../b.txt a/c/b.txt`\"" msgstr "\"`ln -s ../b.txt a/c/b.txt`\"" #: src/std_misc/fs.md:67 msgid "// Create a symbolic link, returns `io::Result<()>`\n" msgstr "// シンボリックリンクを作成、返り値は`io::Result<()>`。\n" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 msgid "\"../b.txt\"" msgstr "\"../b.txt\"" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 src/std_misc/fs.md:80 msgid "\"a/c/b.txt\"" msgstr "\"a/c/b.txt\"" #: src/std_misc/fs.md:79 msgid "\"`cat a/c/b.txt`\"" msgstr "\"`cat a/c/b.txt`\"" #: src/std_misc/fs.md:85 msgid "\"`ls a`\"" msgstr "\"`ls a`\"" #: src/std_misc/fs.md:86 msgid "// Read the contents of a directory, returns `io::Result>`\n" msgstr "" "// ディレクトリの内容を読み込みます。返り値は`io::Result>`。\n" #: src/std_misc/fs.md:94 msgid "\"`rm a/c/e.txt`\"" msgstr "\"`rm a/c/e.txt`\"" #: src/std_misc/fs.md:95 msgid "// Remove a file, returns `io::Result<()>`\n" msgstr "// ファイルを削除。返り値は`io::Result<()>`。\n" #: src/std_misc/fs.md:100 msgid "\"`rmdir a/c/d`\"" msgstr "\"`rmdir a/c/d`\"" #: src/std_misc/fs.md:101 msgid "// Remove an empty directory, returns `io::Result<()>`\n" msgstr "// 空のディレクトリを削除。返り値は`io::Result<()>`。\n" #: src/std_misc/fs.md:111 msgid "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" msgstr "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" #: src/std_misc/fs.md:127 msgid "And the final state of the `a` directory is:" msgstr "最終的な`a`ディレクトリの状態は以下です。" #: src/std_misc/fs.md:139 msgid "An alternative way to define the function `cat` is with `?` notation:" msgstr "" #: src/std_misc/fs.md:152 msgid "[`cfg!`](../attribute/cfg.md)" msgstr "[`cfg!`](../attribute/cfg.md)" #: src/std_misc/arg.md:3 msgid "Standard Library" msgstr "標準ライブラリ" #: src/std_misc/arg.md:5 msgid "" "The command line arguments can be accessed using `std::env::args`, which " "returns an iterator that yields a `String` for each argument:" msgstr "" "コマンドライン引数は`std::env::args`を介して取得できます。これはそれぞれの引" "数を文字列として生成するイテレータを返します。" #: src/std_misc/arg.md:14 msgid "// The first argument is the path that was used to call the program.\n" msgstr "// ひとつ目の引数はプログラムを呼び出す際に使用したパス。\n" #: src/std_misc/arg.md:15 msgid "\"My path is {}.\"" msgstr "\"My path is {}.\"" #: src/std_misc/arg.md:17 msgid "" "// The rest of the arguments are the passed command line parameters.\n" " // Call the program like this:\n" " // $ ./args arg1 arg2\n" msgstr "" "// 残りはプログラムに渡されたコマンドラインパラメータ。\n" " // プログラムはこんなふうに呼び出します。\n" " // $ ./args arg1 arg2\n" #: src/std_misc/arg.md:20 msgid "\"I got {:?} arguments: {:?}.\"" msgstr "\"I got {:?} arguments: {:?}.\"" #: src/std_misc/arg.md:24 msgid "" "```shell\n" "$ ./args 1 2 3\n" "My path is ./args.\n" "I got 3 arguments: [\"1\", \"2\", \"3\"].\n" "```" msgstr "" "```shell\n" "$ ./args 1 2 3\n" "My path is ./args.\n" "I got 3 arguments: [\"1\", \"2\", \"3\"].\n" "```" #: src/std_misc/arg.md:32 msgid "" "Alternatively, there are numerous crates that can provide extra " "functionality when creating command-line applications. One of the more " "popular command line argument crates being [`clap`](https://rust-cli.github." "io/book/tutorial/cli-args.html#parsing-cli-arguments-with-clap)." msgstr "" #: src/std_misc/arg/matching.md:3 msgid "Matching can be used to parse simple arguments:" msgstr "matchを用いて簡単な引数をパースできます。" #: src/std_misc/arg/matching.md:17 msgid "" "\"usage:\n" "match_args \n" " Check whether given string is the answer.\n" "match_args {{increase|decrease}} \n" " Increase or decrease given integer by one.\"" msgstr "" "\"usage:\n" "match_args \n" " Check whether given string is the answer.\n" "match_args {{increase|decrease}} \n" " Increase or decrease given integer by one.\"" #: src/std_misc/arg/matching.md:28 msgid "// no arguments passed\n" msgstr "// 引数がない場合\n" #: src/std_misc/arg/matching.md:30 msgid "\"My name is 'match_args'. Try passing some arguments!\"" msgstr "\"My name is 'match_args'. Try passing some arguments!\"" #: src/std_misc/arg/matching.md:32 msgid "// one argument passed\n" msgstr "// 引数が1つの場合\n" #: src/std_misc/arg/matching.md:35 msgid "\"This is the answer!\"" msgstr "\"This is the answer!\"" #: src/std_misc/arg/matching.md:36 msgid "\"This is not the answer.\"" msgstr "\"This is not the answer.\"" #: src/std_misc/arg/matching.md:39 msgid "// one command and one argument passed\n" msgstr "// コマンドが一つと引数が一つの場合\n" #: src/std_misc/arg/matching.md:43 msgid "// parse the number\n" msgstr "// 数字をパース。\n" #: src/std_misc/arg/matching.md:49 msgid "\"error: second argument not an integer\"" msgstr "\"error: second argument not an integer\"" #: src/std_misc/arg/matching.md:54 msgid "// parse the command\n" msgstr "// コマンドをパース。\n" #: src/std_misc/arg/matching.md:56 msgid "\"increase\"" msgstr "\"increase\"" #: src/std_misc/arg/matching.md:57 msgid "\"decrease\"" msgstr "\"decrease\"" #: src/std_misc/arg/matching.md:59 msgid "\"error: invalid command\"" msgstr "\"error: invalid command\"" #: src/std_misc/arg/matching.md:64 msgid "// all the other cases\n" msgstr "// その他の場合\n" #: src/std_misc/arg/matching.md:66 msgid "// show a help message\n" msgstr "// ヘルプメッセージを表示。\n" #: src/std_misc/arg/matching.md:73 msgid "" "If you named your program `match_args.rs` and compile it like this `rustc " "match_args.rs`, you can execute it as follows:" msgstr "" #: src/std_misc/ffi.md:3 msgid "" "Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign " "functions must be declared inside an `extern` block annotated with a " "`#[link]` attribute containing the name of the foreign library." msgstr "" "RustはCのライブラリを呼び出すために他言語関数インターフェイス（Foreign " "Function Interface, FFI）を持っています。他言語の関数を使用する際には、そのラ" "イブラリ名を`#[link]`アトリビュートに渡し、更にそれでアノテーションされた" "`extern`ブロック内で宣言する必要があります。" #: src/std_misc/ffi.md:9 msgid "// this extern block links to the libm library\n" msgstr "// このexternブロックはlibmライブラリをリンクします。\n" #: src/std_misc/ffi.md:12 msgid "\"msvcrt\"" msgstr "\"msvcrt\"" #: src/std_misc/ffi.md:14 src/std_misc/ffi.md:23 msgid "" "// this is a foreign function\n" " // that computes the square root of a single precision complex number\n" msgstr "" "// 他言語の関数宣言。\n" " // この関数は単精度浮動小数の複素数型の平方根を計算するためのものです。\n" #: src/std_misc/ffi.md:21 msgid "\"m\"" msgstr "\"m\"" #: src/std_misc/ffi.md:29 msgid "" "// Since calling foreign functions is considered unsafe,\n" "// it's common to write safe wrappers around them.\n" msgstr "// 型安全にするためのラッパ\n" #: src/std_misc/ffi.md:37 msgid "// z = -1 + 0i\n" msgstr "// z = -1 + 0i\n" #: src/std_misc/ffi.md:40 msgid "// calling a foreign function is an unsafe operation\n" msgstr "" #: src/std_misc/ffi.md:43 msgid "\"the square root of {:?} is {:?}\"" msgstr "\"the square root of {:?} is {:?}\"" #: src/std_misc/ffi.md:45 msgid "// calling safe API wrapped around unsafe operation\n" msgstr "" #: src/std_misc/ffi.md:46 msgid "\"cos({:?}) = {:?}\"" msgstr "\"cos({:?}) = {:?}\"" #: src/std_misc/ffi.md:48 msgid "// Minimal implementation of single precision complex numbers\n" msgstr "// 単精度浮動小数の複素数型の最小限の実装\n" #: src/std_misc/ffi.md:60 msgid "\"{}-{}i\"" msgstr "\"{}-{}i\"" #: src/std_misc/ffi.md:62 msgid "\"{}+{}i\"" msgstr "\"{}+{}i\"" #: src/testing.md:3 msgid "" "Rust is a programming language that cares a lot about correctness and it " "includes support for writing software tests within the language itself." msgstr "" "Rustはとても正確性を配慮したプログラミング言語であり、ソフトウェアテストを書" "くためのサポートを言語自身が含んでいます。" #: src/testing.md:6 msgid "Testing comes in three styles:" msgstr "テストには3つの種類があります。" #: src/testing.md:8 msgid "[Unit](testing/unit_testing.md) testing." msgstr "[単体テスト](testing/unit_testing.md)" #: src/testing.md:9 msgid "[Doc](testing/doc_testing.md) testing." msgstr "[ドキュメンテーションテスト](testing/doc_testing.md)" #: src/testing.md:10 msgid "[Integration](testing/integration_testing.md) testing." msgstr "[結合テスト](testing/integration_testing.md)" #: src/testing.md:12 msgid "Also Rust has support for specifying additional dependencies for tests:" msgstr "" "またRustではテストのために追加の依存パッケージを指定することもできます。" #: src/testing.md:14 msgid "[Dev-dependencies](testing/dev_dependencies.md)" msgstr "" #: src/testing.md:18 msgid "" "[The Book](https://doc.rust-lang.org/book/ch11-00-testing.html) chapter on " "testing" msgstr "" "[The Book](https://doc.rust-lang.org/book/ch11-00-testing.html) のテストの章" #: src/testing.md:19 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on doc-testing" msgstr "" #: src/testing/unit_testing.md:3 msgid "" "Tests are Rust functions that verify that the non-test code is functioning " "in the expected manner. The bodies of test functions typically perform some " "setup, run the code we want to test, then assert whether the results are " "what we expect." msgstr "" "テストは、テスト以外のコードが想定通りに動いているかを確かめるRustの関数で" "す。一般にテスト関数は、準備をしてからテストしたいコードを実行し、そしてその" "結果が期待したものであるか確認します。" #: src/testing/unit_testing.md:8 msgid "" "Most unit tests go into a `tests` [mod](../mod.md) with the `#[cfg(test)]` " "[attribute](../attribute.md). Test functions are marked with the `#[test]` " "attribute." msgstr "" "大抵の場合ユニットテストは`#[cfg(test)]`[アトリビュート](../attribute.md)を付" "けた`tests`[モジュール](../mod.md)に配置されます。テスト関数には`#[test]`アト" "リビュートを付与します。" #: src/testing/unit_testing.md:11 msgid "" "Tests fail when something in the test function [panics](../std/panic.md). " "There are some helper [macros](../macros.md):" msgstr "" "テスト関数内部で[パニック](../std/panic.md)するとテストは失敗となります。次の" "ような[マクロ](../macros.md)が用意されています。" #: src/testing/unit_testing.md:14 msgid "`assert!(expression)` - panics if expression evaluates to `false`." msgstr "" "`assert!(expression)` - 式を評価した結果が`false`であればパニックします。" #: src/testing/unit_testing.md:15 msgid "" "`assert_eq!(left, right)` and `assert_ne!(left, right)` - testing left and " "right expressions for equality and inequality respectively." msgstr "" "`assert_eq!(left, right)`と`assert_ne!(left, right)` - 左右の式を評価した結果" "が、それぞれ等しくなること、ならないことをテストします。" #: src/testing/unit_testing.md:22 msgid "" "// This is a really bad adding function, its purpose is to fail in this\n" "// example.\n" msgstr "// 誤った加算をする関数がテストに通らないことを示します。\n" #: src/testing/unit_testing.md:32 msgid "" "// Note this useful idiom: importing names from outer (for mod tests) " "scope.\n" msgstr "" "// 外部のスコープから（mod testsに）名前をインポートする便利なイディオム。\n" #: src/testing/unit_testing.md:42 msgid "" "// This assert would fire and test will fail.\n" " // Please note, that private functions can be tested too!\n" msgstr "" "// このアサーションはパニックして、テストは失敗します。\n" " // プライベートな関数もテストすることができます。\n" #: src/testing/unit_testing.md:49 msgid "Tests can be run with `cargo test`." msgstr "`cargo test`でテストを実行できます。" #: src/testing/unit_testing.md:73 msgid "Tests and `?`" msgstr "テストと`?`" #: src/testing/unit_testing.md:74 msgid "" "None of the previous unit test examples had a return type. But in Rust 2018, " "your unit tests can return `Result<()>`, which lets you use `?` in them! " "This can make them much more concise." msgstr "" "ここまでに例示したユニットテストは返り値の型を持っていませんでしたが、Rust " "2018ではユニットテストが`Result<()>`を返し、内部で`?`を使えるようになりまし" "た！これにより、ユニットテストをさらに簡潔に記述できます。" #: src/testing/unit_testing.md:83 msgid "\"negative floats don't have square roots\"" msgstr "\"negative floats don't have square roots\"" #: src/testing/unit_testing.md:100 msgid "" "See [\"The Edition Guide\"](https://doc.rust-lang.org/edition-guide/" "rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html) " "for more details." msgstr "" "詳細は[エディションガイド](https://doc.rust-lang.org/edition-guide/rust-2018/" "error-handling-and-panics/question-mark-in-main-and-tests.html)を参照してくだ" "さい。" #: src/testing/unit_testing.md:102 msgid "Testing panics" msgstr "パニックをテストする" #: src/testing/unit_testing.md:104 msgid "" "To check functions that should panic under certain circumstances, use " "attribute `#[should_panic]`. This attribute accepts optional parameter " "`expected = ` with the text of the panic message. If your function can panic " "in multiple ways, it helps make sure your test is testing the correct panic." msgstr "" "ある条件下でパニックすべき関数をテストするには、`#[should_panic]`アトリビュー" "トを使います。このアトリビュートはパニックメッセージをオプションの引数" "`expected =`で受け取れます。パニックの原因が複数あるときに、想定した原因でパ" "ニックが発生したことを確認できます。" #: src/testing/unit_testing.md:112 src/testing/doc_testing.md:45 msgid "\"Divide-by-zero error\"" msgstr "\"Divide-by-zero error\"" #: src/testing/unit_testing.md:114 src/testing/unit_testing.md:135 msgid "\"Divide result is zero\"" msgstr "\"Divide result is zero\"" #: src/testing/unit_testing.md:142 msgid "Running these tests gives us:" msgstr "テストを実行すると、次の結果を得られます。" #: src/testing/unit_testing.md:161 msgid "Running specific tests" msgstr "実行するテストを指定する" #: src/testing/unit_testing.md:163 msgid "" "To run specific tests one may specify the test name to `cargo test` command." msgstr "`cargo test`にテストの名前を与えると、そのテストだけが実行されます。" #: src/testing/unit_testing.md:179 msgid "" "To run multiple tests one may specify part of a test name that matches all " "the tests that should be run." msgstr "" "テスト名の一部を指定すると、それにマッチするすべてのテストが実行されます。" #: src/testing/unit_testing.md:197 msgid "Ignoring tests" msgstr "テストを除外する" #: src/testing/unit_testing.md:199 msgid "" "Tests can be marked with the `#[ignore]` attribute to exclude some tests. Or " "to run them with command `cargo test -- --ignored`" msgstr "" "テストを実行から除外するには、`#[ignore]`アトリビュートを使います。また、" "`cargo test -- --ignored`で、除外したテストのみを実行できます。" #: src/testing/doc_testing.md:3 msgid "" "The primary way of documenting a Rust project is through annotating the " "source code. Documentation comments are written in [CommonMark Markdown " "specification](https://commonmark.org/) and support code blocks in them. " "Rust takes care about correctness, so these code blocks are compiled and " "used as documentation tests." msgstr "" "Rustのプロジェクトでは、ソースコードに注釈する形でドキュメントを書くのが主流" "です。ドキュメンテーションコメントの記述は[CommonMark Markdown specification]" "(https://commonmark.org/)で行い、コードブロックも使えます。Rustは正確性を重視" "しているので、コードブロックもコンパイルされ、テストとして使われます。" #: src/testing/doc_testing.md:10 msgid "" "/// First line is a short summary describing function.\n" "///\n" "/// The next lines present detailed documentation. Code blocks start with\n" "/// triple backquotes and have implicit `fn main()` inside\n" "/// and `extern crate `. Assume we're testing a `playground` library\n" "/// crate or using the Playground's Test action:\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" msgstr "" "/// 最初の行には関数の機能の短い要約を書きます。\n" "///\n" "/// 以降で詳細なドキュメンテーションを記述します。コードブロックは三重のバッ" "ククォートで始まり、\n" "/// 暗黙的に`fn main()`と`extern crate <クレート名>`で囲われます。\n" "/// `playground`クレートをテストしたいときには、次のように記述します。\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" #: src/testing/doc_testing.md:23 msgid "" "/// Usually doc comments may include sections \"Examples\", \"Panics\" and " "\"Failures\".\n" "///\n" "/// The next function divides two numbers.\n" "///\n" "/// # Examples\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # Panics\n" "///\n" "/// The function panics if the second argument is zero.\n" "///\n" "/// ```rust,should_panic\n" "/// // panics on division by zero\n" "/// playground::div(10, 0);\n" "/// ```\n" msgstr "" "/// 一般的に、ドキュメンテーションコメントは\n" "/// \"Examples\", \"Panics\", \"Failures\" という章から成ります。\n" "///\n" "/// 次の関数は除算を実行します。\n" "///\n" "/// # Examples\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # Panics\n" "///\n" "/// 第2引数がゼロであればパニックします。\n" "///\n" "/// ```rust,should_panic\n" "/// // ゼロで除算するとパニックします\n" "/// playground::div(10, 0);\n" "/// ```\n" #: src/testing/doc_testing.md:52 msgid "" "Code blocks in documentation are automatically tested when running the " "regular `cargo test` command:" msgstr "" "ドキュメンテーションコメント中のコードブロックは、`cargo test`コマンドで自動" "的にテストされます。" #: src/testing/doc_testing.md:71 msgid "Motivation behind documentation tests" msgstr "ドキュメンテーションテストの目的" #: src/testing/doc_testing.md:73 msgid "" "The main purpose of documentation tests is to serve as examples that " "exercise the functionality, which is one of the most important [guidelines]" "(https://rust-lang-nursery.github.io/api-guidelines/documentation." "html#examples-use--not-try-not-unwrap-c-question-mark). It allows using " "examples from docs as complete code snippets. But using `?` makes " "compilation fail since `main` returns `unit`. The ability to hide some " "source lines from documentation comes to the rescue: one may write `fn " "try_main() -> Result<(), ErrorType>`, hide it and `unwrap` it in hidden " "`main`. Sounds complicated? Here's an example:" msgstr "" "ドキュメンテーションテストの主な目的は、実行例を示すことであり、これは最も大" "切な[ガイドライン](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html#examples-use--not-try-not-unwrap-c-question-mark)の一つに" "もなっています。これにより、ドキュメントの例を実際に動くコードとして使うこと" "ができます。しかしながら、`main`が`()`を返すために、`?`を使うとコンパイルに失" "敗してしまいます。ドキュメンテーションでコードブロックの一部を隠す機能で、こ" "の問題に対処できます。つまり、`fn try_main() -> Result<(), ErrorType>`を定義" "しておきながらそれを隠し、暗黙の`main`の内部で`unwrap`するのです。複雑なの" "で、例を見てみましょう。" #: src/testing/doc_testing.md:82 msgid "" "/// Using hidden `try_main` in doc tests.\n" "///\n" "/// ```\n" "/// # // hidden lines start with `#` symbol, but they're still compilable!\n" "/// # fn try_main() -> Result<(), String> { // line that wraps the body " "shown in doc\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // returning from try_main\n" "/// # }\n" "/// # fn main() { // starting main that'll unwrap()\n" "/// # try_main().unwrap(); // calling try_main and unwrapping\n" "/// # // so that test will panic in case of error\n" "/// # }\n" "/// ```\n" msgstr "" "/// ドキュメンテーションテストで、`try_main`を隠して使います。\n" "///\n" "/// ```\n" "/// # // 行頭に `#` を置くと行が隠されるが、コンパイルには成功します。\n" "/// # fn try_main() -> Result<(), String> { // ドキュメントの本体を囲う行\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // try_mainから値を返します\n" "/// # }\n" "/// # fn main() { // unwrap()を実行します。\n" "/// # try_main().unwrap(); // try_mainを呼びunwrapすると、エラーの場合にパ" "ニックします。\n" "/// # }\n" "/// ```\n" #: src/testing/doc_testing.md:97 msgid "\"Divide-by-zero\"" msgstr "\"Divide-by-zero\"" #: src/testing/doc_testing.md:106 msgid "" "[RFC505](https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-" "conventions.md) on documentation style" msgstr "" "[RFC505](https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-" "conventions.md) ドキュメンテーションのスタイルについて" #: src/testing/doc_testing.md:107 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on documentation guidelines" msgstr "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) ドキュメンテーションのガイドラインについて" #: src/testing/integration_testing.md:3 msgid "" "[Unit tests](unit_testing.md) are testing one module in isolation at a time: " "they're small and can test private code. Integration tests are external to " "your crate and use only its public interface in the same way any other code " "would. Their purpose is to test that many parts of your library work " "correctly together." msgstr "" "[ユニットテスト](unit_testing.md)は、独立したモジュールを一つずつテストするも" "のであり、テストは小さく、プライベートなコードについてもテストすることができ" "ます。統合テストはクレートの外側にあるもので、他の外部のコードと同様に、パブ" "リックなインタフェースだけを使います。統合テストの目的は、ライブラリのそれぞ" "れのモジュールが連携して正しく動作するかどうかテストすることです。" #: src/testing/integration_testing.md:8 msgid "Cargo looks for integration tests in `tests` directory next to `src`." msgstr "" "Cargoは、`src`ディレクトリと並んで配置された`tests`ディレクトリを統合テストと" "して扱います。" #: src/testing/integration_testing.md:10 src/testing/dev_dependencies.md:17 msgid "File `src/lib.rs`:" msgstr "ファイル`src/lib.rs`：" #: src/testing/integration_testing.md:13 msgid "// Define this in a crate called `adder`.\n" msgstr "// `adder`という名前のクレートの内部で、次の関数を定義します。\n" #: src/testing/integration_testing.md:19 msgid "File with test: `tests/integration_test.rs`:" msgstr "テストを含むファイル`tests/integration_test.rs`：" #: src/testing/integration_testing.md:28 msgid "Running tests with `cargo test` command:" msgstr "`cargo test`コマンドでテストを実行します。" #: src/testing/integration_testing.md:50 msgid "" "Each Rust source file in the `tests` directory is compiled as a separate " "crate. In order to share some code between integration tests we can make a " "module with public functions, importing and using it within tests." msgstr "" "`tests`ディレクトリにあるRustのソースファイルは別のクレートとしてコンパイルさ" "れます。統合テストの間でコードを共有するには、パブリックな関数をモジュールに" "入れて、それぞれのテストでインポートして利用する方法があります。" #: src/testing/integration_testing.md:54 msgid "File `tests/common/mod.rs`:" msgstr "ファイル`tests/common.rs`：" #: src/testing/integration_testing.md:58 msgid "" "// some setup code, like creating required files/directories, starting\n" " // servers, etc.\n" msgstr "" "// 必要なファイル・ディレクトリの作成やサーバの起動といった準備を行うコードを" "記述します。\n" #: src/testing/integration_testing.md:63 msgid "File with test: `tests/integration_test.rs`" msgstr "テストを含むファイル`tests/integration_test.rs`：" #: src/testing/integration_testing.md:66 msgid "// importing common module.\n" msgstr "// 共通のモジュールをインポートします。\n" #: src/testing/integration_testing.md:71 msgid "// using common code.\n" msgstr "// 共通のコードを利用します。\n" #: src/testing/integration_testing.md:77 msgid "" "Creating the module as `tests/common.rs` also works, but is not recommended " "because the test runner will treat the file as a test crate and try to run " "tests inside it." msgstr "" "モジュールを`tests/common.rs`に記述することも可能ですが、`tests/common.rs`中" "のテストも自動的に実行されてしまうため非推奨です。" #: src/testing/dev_dependencies.md:1 msgid "Development dependencies" msgstr "開発中の依存関係" #: src/testing/dev_dependencies.md:3 msgid "" "Sometimes there is a need to have dependencies for tests (or examples, or " "benchmarks) only. Such dependencies are added to `Cargo.toml` in the `[dev-" "dependencies]` section. These dependencies are not propagated to other " "packages which depend on this package." msgstr "" "テスト（あるいは例やベンチマーク）のためだけに、あるクレートに依存しなければ" "ならないことがあります。このような依存関係は、`Cargo.toml`の`[dev-" "dependencies]`セクションに追加します。このセクションに追加した依存関係は、こ" "のパッケージに依存するパッケージには適用されません。" #: src/testing/dev_dependencies.md:8 msgid "" "One such example is [`pretty_assertions`](https://docs.rs/" "pretty_assertions/1.0.0/pretty_assertions/index.html), which extends " "standard `assert_eq!` and `assert_ne!` macros, to provide colorful diff. \n" "File `Cargo.toml`:" msgstr "" "そのようなクレートの例として、[`pretty_assertions`](https://docs.rs/" "pretty_assertions/1.0.0/pretty_assertions/index.html)クレートが挙げられます。" "これは、標準の`assert_eq!`と`assert_ne!`マクロを拡張して、差分をカラフルに表" "示するものです。 \n" "ファイル`Cargo.toml`：" #: src/testing/dev_dependencies.md:11 msgid "" "```toml\n" "# standard crate data is left out\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" msgstr "" "```toml\n" "# 本節の内容に関係のない行は省略しています。\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" #: src/testing/dev_dependencies.md:27 msgid "// crate for test-only use. Cannot be used in non-test code.\n" msgstr "" "// テストのためのクレートであり、\n" " // テスト以外のコードには使えません。\n" #: src/testing/dev_dependencies.md:37 msgid "" "[Cargo](http://doc.crates.io/specifying-dependencies.html) docs on " "specifying dependencies." msgstr "" "[Cargo](http://doc.crates.io/specifying-dependencies.html) 依存関係の指定につ" "いて" #: src/unsafe.md:3 msgid "" "As an introduction to this section, to borrow from [the official docs]" "(https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html), \"one should try " "to minimize the amount of unsafe code in a code base.\" With that in mind, " "let's get started! Unsafe annotations in Rust are used to bypass protections " "put in place by the compiler; specifically, there are four primary things " "that unsafe is used for:" msgstr "" "この章の内容を見る前に、[公式ドキュメント](https://doc.rust-lang.org/book/" "ch19-01-unsafe-rust.html)から引用した次の文章をお読みください。「コードベース" "中の、アンセーフな操作をするコードの量は、可能な限り小さく無くてはならな" "い。」この戒めを頭に叩き込んだ上で、さあはじめましょう！Rustにおいて、アン" "セーフなブロックはコンパイラのチェックをスルーするために使われます。具体的に" "は以下の4つの主要なユースケースがあります。" #: src/unsafe.md:9 msgid "dereferencing raw pointers" msgstr "生ポインタのデリファレンス" #: src/unsafe.md:10 msgid "" "calling functions or methods which are `unsafe` (including calling a " "function over FFI, see [a previous chapter](std_misc/ffi.md) of the book)" msgstr "" "安全でない関数やメソッドの呼び出し(FFI経由の関数の呼び出しを含む (詳細は [本" "書のFFIに関する説明](std_misc/ffi.md) を参照ください))" #: src/unsafe.md:12 msgid "accessing or modifying static mutable variables" msgstr "静的なミュータブル変数へのアクセスや変更" #: src/unsafe.md:13 msgid "implementing unsafe traits" msgstr "安全でないトレイトの実装" #: src/unsafe.md:15 msgid "Raw Pointers" msgstr "生ポインタ" #: src/unsafe.md:16 msgid "" "Raw pointers `*` and references `&T` function similarly, but references are " "always safe because they are guaranteed to point to valid data due to the " "borrow checker. Dereferencing a raw pointer can only be done through an " "unsafe block." msgstr "" "生ポインタ`*`と参照`&T`はよく似た機能を持ちますが、後者は必ず有効なデータを指" "していることが借用チェッカーによって保証されているので、常に安全です。生ポイ" "ンタのデリファレンスはアンセーフなブロックでしか実行できません。" #: src/unsafe.md:31 msgid "Calling Unsafe Functions" msgstr "安全でない関数呼び出し" #: src/unsafe.md:32 msgid "" "Some functions can be declared as `unsafe`, meaning it is the programmer's " "responsibility to ensure correctness instead of the compiler's. One example " "of this is [`std::slice::from_raw_parts`](https://doc.rust-lang.org/std/" "slice/fn.from_raw_parts.html) which will create a slice given a pointer to " "the first element and a length." msgstr "" "関数は `unsafe` として宣言できます。これはコンパイラの代わりにプログラマの責" "任で正しさを保証することを意味します。例として [`std::slice::from_raw_parts`]" "(https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html)があります。この" "関数は最初の要素へのポインタと長さを指定してスライスを作成します。" #: src/unsafe.md:54 msgid "" "For `slice::from_raw_parts`, one of the assumptions which _must_ be upheld " "is that the pointer passed in points to valid memory and that the memory " "pointed to is of the correct type. If these invariants aren't upheld then " "the program's behaviour is undefined and there is no knowing what will " "happen." msgstr "" "`slice::from_raw_parts` は、次のふたつの仮定に基づいて処理します。ひとつは渡" "されたポインタが有効なメモリ位置を指していること、もうひとつはそのメモリに格" "納された値が正しい型であることです。この仮定を満たさない場合、プログラムの動" "作は不定となり、何が起こるかわかりません。" #: src/unsafe/asm.md:3 msgid "" "Rust provides support for inline assembly via the `asm!` macro. It can be " "used to embed handwritten assembly in the assembly output generated by the " "compiler. Generally this should not be necessary, but might be where the " "required performance or timing cannot be otherwise achieved. Accessing low " "level hardware primitives, e.g. in kernel code, may also demand this " "functionality." msgstr "" "Rustは`asm!`マクロによってインラインアセンブリをサポートしています。コンパイ" "ラが生成するアセンブリに、手書きのアセンブリを埋め込むことができます。一般的" "には必要ありませんが、要求されるパフォーマンスやタイミングを達成するために必" "要な場合があります。カーネルコードのような、低レベルなハードウェアの基本要素" "にアクセスする場合にも、この機能が必要でしょう。" #: src/unsafe/asm.md:8 msgid "" "**Note**: the examples here are given in x86/x86-64 assembly, but other " "architectures are also supported." msgstr "" "**注意**: 以下の例はx86/x86-64アセンブリで書かれていますが、他のアーキテク" "チャもサポートされています。" #: src/unsafe/asm.md:10 msgid "Inline assembly is currently supported on the following architectures:" msgstr "インラインアセンブリは現在以下のアーキテクチャでサポートされています。" #: src/unsafe/asm.md:11 msgid "x86 and x86-64" msgstr "x86とx86-64" #: src/unsafe/asm.md:12 msgid "ARM" msgstr "ARM" #: src/unsafe/asm.md:13 msgid "AArch64" msgstr "AArch64" #: src/unsafe/asm.md:14 msgid "RISC-V" msgstr "RISC-V" #: src/unsafe/asm.md:16 msgid "Basic usage" msgstr "基本的な使い方" #: src/unsafe/asm.md:18 msgid "Let us start with the simplest possible example:" msgstr "最も単純な例から始めましょう。" #: src/unsafe/asm.md:21 src/unsafe/asm.md:41 src/unsafe/asm.md:68 #: src/unsafe/asm.md:106 src/unsafe/asm.md:123 src/unsafe/asm.md:148 #: src/unsafe/asm.md:174 src/unsafe/asm.md:195 src/unsafe/asm.md:212 #: src/unsafe/asm.md:251 src/unsafe/asm.md:287 src/unsafe/asm.md:303 #: src/unsafe/asm.md:329 src/unsafe/asm.md:367 src/unsafe/asm.md:394 #: src/unsafe/asm.md:418 src/unsafe/asm.md:456 msgid "\"x86_64\"" msgstr "\"x86_64\"" #: src/unsafe/asm.md:25 msgid "\"nop\"" msgstr "\"nop\"" #: src/unsafe/asm.md:30 msgid "" "This will insert a NOP (no operation) instruction into the assembly " "generated by the compiler. Note that all `asm!` invocations have to be " "inside an `unsafe` block, as they could insert arbitrary instructions and " "break various invariants. The instructions to be inserted are listed in the " "first argument of the `asm!` macro as a string literal." msgstr "" "これは、コンパイラが生成したアセンブリに、NOP（no operation）命令を挿入しま" "す。すべての`asm!`呼び出しは、`unsafe`ブロックの中になければいけません。イン" "ラインアセンブリは任意の命令を挿入でき、不変条件を壊してしまうからです。挿入" "される命令は、文字列リテラルとして`asm!`マクロの第一引数に列挙されます。" #: src/unsafe/asm.md:35 msgid "Inputs and outputs" msgstr "入力と出力" #: src/unsafe/asm.md:37 msgid "" "Now inserting an instruction that does nothing is rather boring. Let us do " "something that actually acts on data:" msgstr "" "何もしない命令を挿入しても面白くありません。実際にデータを操作してみましょ" "う。" #: src/unsafe/asm.md:46 msgid "\"mov {}, 5\"" msgstr "\"mov {}, 5\"" #: src/unsafe/asm.md:52 msgid "" "This will write the value `5` into the `u64` variable `x`. You can see that " "the string literal we use to specify instructions is actually a template " "string. It is governed by the same rules as Rust [format strings](https://" "doc.rust-lang.org/std/fmt/#syntax). The arguments that are inserted into the " "template however look a bit different than you may be familiar with. First " "we need to specify if the variable is an input or an output of the inline " "assembly. In this case it is an output. We declared this by writing `out`. " "We also need to specify in what kind of register the assembly expects the " "variable. In this case we put it in an arbitrary general purpose register by " "specifying `reg`. The compiler will choose an appropriate register to insert " "into the template and will read the variable from there after the inline " "assembly finishes executing." msgstr "" "これは`u64`型の変数`x`に`5`の値を書き込んでいます。命令を指定するために利用し" "ている文字列リテラルが、実はテンプレート文字列になっています。これはRustの" "[フォーマット文字列](https://doc.rust-lang.org/std/fmt/#syntax)と同じルールに" "従います。ですが、テンプレートに挿入される引数は、みなさんがよく知っているも" "のとは少し違っています。まず、変数がインラインアセンブリの入力なのか出力なの" "かを指定する必要があります。上記の例では出力となっています。`out`と書くことで" "出力であると宣言しています。また、アセンブリが変数をどの種類のレジスタに格納" "するかについても指定する必要があります。上の例では、`reg`を指定して任意の汎用" "レジスタに格納しています。コンパイラはテンプレートに挿入する適切なレジスタを" "選び、インラインアセンブリの実行終了後、そのレジスタから変数を読みこみます。" #: src/unsafe/asm.md:65 msgid "Let us see another example that also uses an input:" msgstr "入力を利用する別の例を見てみましょう。" #: src/unsafe/asm.md:75 msgid "\"mov {0}, {1}\"" msgstr "\"mov {0}, {1}\"" #: src/unsafe/asm.md:76 src/unsafe/asm.md:111 src/unsafe/asm.md:129 msgid "\"add {0}, 5\"" msgstr "\"add {0}, 5\"" #: src/unsafe/asm.md:85 msgid "" "This will add `5` to the input in variable `i` and write the result to " "variable `o`. The particular way this assembly does this is first copying " "the value from `i` to the output, and then adding `5` to it." msgstr "" "この例では、変数`i`の入力に`5`を加え、その結果を変数`o`に書き込んでいます。こ" "のアセンブリ特有のやり方として、はじめに`i`の値を出力にコピーし、それから`5`" "を加えています。" #: src/unsafe/asm.md:89 msgid "The example shows a few things:" msgstr "この例はいくつかのことを示します。" #: src/unsafe/asm.md:91 msgid "" "First, we can see that `asm!` allows multiple template string arguments; " "each one is treated as a separate line of assembly code, as if they were all " "joined together with newlines between them. This makes it easy to format " "assembly code." msgstr "" "まず、`asm!`では複数のテンプレート文字列を引数として利用できます。それぞれの" "文字列は、改行を挟んで結合されたのと同じように、独立したアセンブリコードとし" "て扱われます。このおかげで、アセンブリコードを容易にフォーマットできます。" #: src/unsafe/asm.md:96 msgid "" "Second, we can see that inputs are declared by writing `in` instead of `out`." msgstr "つぎに、入力は`out`ではなく`in`と書くことで宣言されています。" #: src/unsafe/asm.md:98 msgid "" "Third, we can see that we can specify an argument number, or name as in any " "format string. For inline assembly templates this is particularly useful as " "arguments are often used more than once. For more complex inline assembly " "using this facility is generally recommended, as it improves readability, " "and allows reordering instructions without changing the argument order." msgstr "" "そして、他のフォーマット文字列と同じように引数を番号や名前で指定できます。イ" "ンラインアセンブリのテンプレートでは、引数が2回以上利用されることが多いため、" "これは特に便利です。より複雑なインラインアセンブリを書く場合、この機能を使う" "のが推奨されます。可読性が向上し、引数の順序を変えることなく命令を並べ替える" "ことができるからです。" #: src/unsafe/asm.md:103 msgid "We can further refine the above example to avoid the `mov` instruction:" msgstr "上記の例をさらに改善して、`mov`命令をやめることもできます。" #: src/unsafe/asm.md:117 msgid "" "We can see that `inout` is used to specify an argument that is both input " "and output. This is different from specifying an input and output separately " "in that it is guaranteed to assign both to the same register." msgstr "" "`inout`で入力でもあり出力でもある引数を指定しています。こうすることで、入力と" "出力を個別に指定する場合と違って、入出力が同じレジスタに割り当てられることが" "保証されます。" #: src/unsafe/asm.md:120 msgid "" "It is also possible to specify different variables for the input and output " "parts of an `inout` operand:" msgstr "" "`inout`のオペランドとして、入力と出力それぞれに異なる変数を指定することも可能" "です。" #: src/unsafe/asm.md:135 msgid "Late output operands" msgstr "遅延出力オペランド" #: src/unsafe/asm.md:137 msgid "" "The Rust compiler is conservative with its allocation of operands. It is " "assumed that an `out` can be written at any time, and can therefore not " "share its location with any other argument. However, to guarantee optimal " "performance it is important to use as few registers as possible, so they " "won't have to be saved and reloaded around the inline assembly block. To " "achieve this Rust provides a `lateout` specifier. This can be used on any " "output that is written only after all inputs have been consumed. There is " "also an `inlateout` variant of this specifier." msgstr "" "Rustコンパイラはオペランドの割り当てに保守的です。`out`はいつでも書き込めるの" "で、他の引数とは場所を共有できません。しかし、最適なパフォーマンスを保証する" "ためには、できるだけ少ないレジスタを使うことが重要です。そうすることで、イン" "ラインアセンブリブロックの前後でレジスタを保存したり再読み込みしたりする必要" "がありません。これを達成するために、Rustは`lateout`指定子を提供します。全ての" "入力が消費された後でのみ書き込まれる出力に利用できます。この指定子には" "`inlateout`という変化形もあります。" #: src/unsafe/asm.md:145 msgid "" "Here is an example where `inlateout` _cannot_ be used in `release` mode or " "other optimized cases:" msgstr "" "以下は、`release`モードやその他の最適化された場合に、`inlateout`を利用 *でき" "ない* 例です。" #: src/unsafe/asm.md:156 src/unsafe/asm.md:180 src/unsafe/asm.md:463 msgid "\"add {0}, {1}\"" msgstr "\"add {0}, {1}\"" #: src/unsafe/asm.md:157 msgid "\"add {0}, {2}\"" msgstr "\"add {0}, {2}\"" #: src/unsafe/asm.md:167 msgid "" "In unoptimized cases (e.g. `Debug` mode), replacing `inout(reg) a` with " "`inlateout(reg) a` in the above example can continue to give the expected " "result. However, with `release` mode or other optimized cases, using " "`inlateout(reg) a` can instead lead to the final value `a = 16`, causing the " "assertion to fail." msgstr "" #: src/unsafe/asm.md:169 msgid "" "This is because in optimized cases, the compiler is free to allocate the " "same register for inputs `b` and `c` since it knows that they have the same " "value. Furthermore, when `inlateout` is used, `a` and `c` could be allocated " "to the same register, in which case the first `add` instruction would " "overwrite the initial load from variable `c`. This is in contrast to how " "using `inout(reg) a` ensures a separate register is allocated for `a`." msgstr "" "というのも、最適化されている場合、コンパイラは`b`と`c`が同じ値だと知っている" "ので、`b`と`c`の入力に同じレジスタを割り当てる場合があります。もし`inlateout`" "が使われていたら、`a`と`c`に同じレジスタが割り当てられ、最初の`add`命令によっ" "て`c`の値が上書きされるでしょう。`inout(reg) a`の使用により`a`に対する独立し" "たレジスタ割り当てが保証されるのとは対照的です。" #: src/unsafe/asm.md:171 msgid "" "However, the following example can use `inlateout` since the output is only " "modified after all input registers have been read:" msgstr "" "しかし、次の例では、全ての入力レジスタが読み込まれた後でのみ出力が変更される" "ので、`inlateout`を利用できます。" #: src/unsafe/asm.md:186 msgid "" "As you can see, this assembly fragment will still work correctly if `a` and " "`b` are assigned to the same register." msgstr "" "このアセンブリコードは、`a`と`b`が同じレジスタに割り当てられても、正しく動作" "します。" #: src/unsafe/asm.md:188 msgid "Explicit register operands" msgstr "明示的なレジスタオペランド" #: src/unsafe/asm.md:190 msgid "" "Some instructions require that the operands be in a specific register. " "Therefore, Rust inline assembly provides some more specific constraint " "specifiers. While `reg` is generally available on any architecture, explicit " "registers are highly architecture specific. E.g. for x86 the general purpose " "registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi` among others " "can be addressed by their name." msgstr "" "いくつかの命令では、オペランドが特定のレジスタにある必要があります。したがっ" "て、Rustのインラインアセンブリでは、より具体的な制約指定子を提供しています。" "`reg`は一般的にどのアーキテクチャでも利用可能ですが、明示的レジスタはアーキテ" "クチャに強く依存しています。たとえば、x86の汎用レジスタである`eax`、`ebx`、" "`ecx`、`edx`、`ebp`、`esi`、`edi`などは、その名前で指定できます。" #: src/unsafe/asm.md:200 msgid "\"out 0x64, eax\"" msgstr "\"out 0x64, eax\"" #: src/unsafe/asm.md:200 src/unsafe/asm.md:276 msgid "\"eax\"" msgstr "\"eax\"" #: src/unsafe/asm.md:205 msgid "" "In this example we call the `out` instruction to output the content of the " "`cmd` variable to port `0x64`. Since the `out` instruction only accepts " "`eax` (and its sub registers) as operand we had to use the `eax` constraint " "specifier." msgstr "" "この例では、`out`命令を呼び出して、`cmd`変数の中身を`0x64`ポートに出力してい" "ます。`out`命令は`eax`とそのサブレジスタのみをオペランドとして受け取るため、" "`eax`の制約指定子を使わなければなりません。" #: src/unsafe/asm.md:207 msgid "" "**Note**: unlike other operand types, explicit register operands cannot be " "used in the template string: you can't use `{}` and should write the " "register name directly instead. Also, they must appear at the end of the " "operand list after all other operand types." msgstr "" "**注意**: 他のオペランドタイプと異なり、明示的なレジスタオペランドはテンプ" "レート文字列中で利用できません。`{}`を使えないので、レジスタの名前を直接書く" "必要があります。また、オペランドのリストの中で他のオペランドタイプの一番最後" "に置かれなくてはなりません。" #: src/unsafe/asm.md:209 msgid "Consider this example which uses the x86 `mul` instruction:" msgstr "x86の`mul`命令を使った次の例を考えてみましょう。" #: src/unsafe/asm.md:221 msgid "" "// The x86 mul instruction takes rax as an implicit input and writes\n" " // the 128-bit result of the multiplication to rax:rdx.\n" " \"mul {}\"" msgstr "" "// x86のmul命令はraxを暗黙的な入力に取り、\n" " // 128ビットの乗算結果をrax:rdxに書き込みます。\n" " \"mul {}\"" #: src/unsafe/asm.md:225 src/unsafe/asm.md:347 msgid "\"rax\"" msgstr "\"rax\"" #: src/unsafe/asm.md:226 msgid "\"rdx\"" msgstr "\"rdx\"" #: src/unsafe/asm.md:235 msgid "" "This uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit " "result. The only explicit operand is a register, that we fill from the " "variable `a`. The second operand is implicit, and must be the `rax` " "register, which we fill from the variable `b`. The lower 64 bits of the " "result are stored in `rax` from which we fill the variable `lo`. The higher " "64 bits are stored in `rdx` from which we fill the variable `hi`." msgstr "" "`mul`命令を使って2つの64ビットの入力を128ビットの結果に出力しています。唯一の" "明示的なオペランドはレジスタで、変数`a`から入力します。2つ目のオペランドは暗" "黙的であり、`rax`レジスタである必要があります。変数`b`から`rax`レジスタに入力" "します。計算結果の下位64ビットは`rax`レジスタに保存され、そこから変数`lo`に出" "力されます。上位64ビットは`rdx`レジスタに保存され、そこから変数`hi`に出力され" "ます。" #: src/unsafe/asm.md:241 msgid "Clobbered registers" msgstr "クロバーレジスタ" #: src/unsafe/asm.md:243 msgid "" "In many cases inline assembly will modify state that is not needed as an " "output. Usually this is either because we have to use a scratch register in " "the assembly or because instructions modify state that we don't need to " "further examine. This state is generally referred to as being \"clobbered\". " "We need to tell the compiler about this since it may need to save and " "restore this state around the inline assembly block." msgstr "" "多くの場合、インラインアセンブリは出力として必要のない状態を変更することがあ" "ります。これは普通、アセンブリでスクラッチレジスタを利用する必要があったり、" "私たちがこれ以上必要としていない状態を命令が変更したりするためです。この状態" "を一般的に\"クロバー\"（訳注：上書き）と呼びます。私たちはコンパイラにこのこ" "とを伝える必要があります。なぜならコンパイラは、インラインアセンブリブロック" "の前後で、この状態を保存して復元しなくてはならない可能性があるからです。" #: src/unsafe/asm.md:253 msgid "// three entries of four bytes each\n" msgstr "// 4バイトのエントリー3つ\n" #: src/unsafe/asm.md:255 msgid "" "// String is stored as ascii in ebx, edx, ecx in order\n" " // Because ebx is reserved, the asm needs to preserve the value of it.\n" " // So we push and pop it around the main asm.\n" " // 64 bit mode on 64 bit processors does not allow pushing/popping of\n" " // 32 bit registers (like ebx), so we have to use the extended rbx " "register instead.\n" msgstr "" "// 文字列はasciiとしてebx, edx, ecxの順に保存されています。\n" " // ebxは予約されているので、アセンブリはebxの値を維持する必要がありま" "す。\n" " // 従ってメインのアセンブリの前後でプッシュおよびポップを行います。\n" " // （以下は64ビットプロセッサの64ビットモードの場合。32ビットプロセッサは" "ebxを利用します。）\n" #: src/unsafe/asm.md:263 msgid "\"push rbx\"" msgstr "\"push rbx\"" #: src/unsafe/asm.md:264 msgid "\"cpuid\"" msgstr "\"cpuid\"" #: src/unsafe/asm.md:265 msgid "\"mov [rdi], ebx\"" msgstr "\"mov [rdi], ebx\"" #: src/unsafe/asm.md:266 msgid "\"mov [rdi + 4], edx\"" msgstr "\"mov [rdi + 4], edx\"" #: src/unsafe/asm.md:267 msgid "\"mov [rdi + 8], ecx\"" msgstr "\"mov [rdi + 8], ecx\"" #: src/unsafe/asm.md:268 msgid "\"pop rbx\"" msgstr "\"pop rbx\"" #: src/unsafe/asm.md:269 msgid "" "// We use a pointer to an array for storing the values to simplify\n" " // the Rust code at the cost of a couple more asm instructions\n" " // This is more explicit with how the asm works however, as " "opposed\n" " // to explicit register outputs such as `out(\"ecx\") val`\n" " // The *pointer itself* is only an input even though it's " "written behind\n" msgstr "" "// いくつかのアセンブリ命令を追加してRustのコードを単純化するために\n" " // 値を格納する配列へのポインタを利用します。\n" " // しかし、`out(\"ecx\") val`のような明示的なレジスタの出力とは違" "い、\n" " // アセンブリの動作をより明示的にします。\n" " // *ポインタそのもの* は後ろに書かれていても入力にすぎません。\n" #: src/unsafe/asm.md:274 src/unsafe/asm.md:345 msgid "\"rdi\"" msgstr "\"rdi\"" #: src/unsafe/asm.md:275 msgid "// select cpuid 0, also specify eax as clobbered\n" msgstr "// cpuid 0を選択し、eaxをクロバーに指定します。\n" #: src/unsafe/asm.md:277 msgid "// cpuid clobbers these registers too\n" msgstr "// cpuidは以下のレジスタもクロバーします。\n" #: src/unsafe/asm.md:278 msgid "\"ecx\"" msgstr "\"ecx\"" #: src/unsafe/asm.md:279 msgid "\"edx\"" msgstr "\"edx\"" #: src/unsafe/asm.md:284 msgid "\"CPU Manufacturer ID: {}\"" msgstr "\"CPU Manufacturer ID: {}\"" #: src/unsafe/asm.md:291 msgid "" "In the example above we use the `cpuid` instruction to read the CPU " "manufacturer ID. This instruction writes to `eax` with the maximum supported " "`cpuid` argument and `ebx`, `edx`, and `ecx` with the CPU manufacturer ID as " "ASCII bytes in that order." msgstr "" "上の例では、`cpuid`命令を使い、CPUベンタIDを読み込んでいます。この命令は`eax`" "にサポートされている最大の`cpuid`引数を書き込み、`ebx`、`edx`、`ecx`の順にCPU" "ベンダIDをASCIIコードとして書き込みます。" #: src/unsafe/asm.md:294 msgid "" "Even though `eax` is never read we still need to tell the compiler that the " "register has been modified so that the compiler can save any values that " "were in these registers before the asm. This is done by declaring it as an " "output but with `_` instead of a variable name, which indicates that the " "output value is to be discarded." msgstr "" "`eax`は読み込まれることはありません。しかし、コンパイラがアセンブリ以前にこれ" "らのレジスタにあった値を保存できるように、レジスタが変更されたことをコンパイ" "ラに伝える必要があります。そのために、変数名の代わりに`_`を用いて出力を宣言" "し、出力の値が破棄されるということを示しています。" #: src/unsafe/asm.md:296 msgid "" "This code also works around the limitation that `ebx` is a reserved register " "by LLVM. That means that LLVM assumes that it has full control over the " "register and it must be restored to its original state before exiting the " "asm block, so it cannot be used as an input or output **except** if the " "compiler uses it to fulfill a general register class (e.g. `in(reg)`). This " "makes `reg` operands dangerous when using reserved registers as we could " "unknowingly corrupt our input or output because they share the same register." msgstr "" "このコードは`ebx`がLLVMによって予約されたレジスタであるという制約を回避してい" "ます。LLVMは、自身がレジスタを完全にコントロールし、アセンブリブロックを抜け" "る前に元の状態を復元しなくてはならないと考えています。そのため、コンパイラが" "`in(reg)`のような汎用レジスタクラスを満たすために使用する場合 **を除いて** " "`ebx`を入力や出力として利用できません。つまり、予約されたレジスタを利用する場" "合に、`reg`オペランドは危険なのです。入力と出力が同じレジスタを共有しているの" "で、知らないうちに入力や出力を破壊してしまうかもしれません。" #: src/unsafe/asm.md:298 msgid "" "To work around this we use `rdi` to store the pointer to the output array, " "save `ebx` via `push`, read from `ebx` inside the asm block into the array " "and then restore `ebx` to its original state via `pop`. The `push` and `pop` " "use the full 64-bit `rbx` version of the register to ensure that the entire " "register is saved. On 32 bit targets the code would instead use `ebx` in the " "`push`/`pop`." msgstr "" "これを回避するために、`rdi`を用いて出力の配列へのポインタを保管し、`push`で" "`ebx`を保存し、アセンブリブロック内で`ebx`から読み込んで配列に書き込み、`pop`" "で`ebx`を元の状態に戻しています。`push`と`pop`は完全な64ビットの`rbx`レジスタ" "を使って、レジスタ全体を確実に保存しています。32ビットの場合、`push`と`pop`に" "おいて`ebx`がかわりに利用されるでしょう。" #: src/unsafe/asm.md:300 msgid "" "This can also be used with a general register class to obtain a scratch " "register for use inside the asm code:" msgstr "" "アセンブリコード内部で利用するスクラッチレジスタを獲得するために、汎用レジス" "タクラスとともに使用することもできます。" #: src/unsafe/asm.md:305 msgid "// Multiply x by 6 using shifts and adds\n" msgstr "// シフト演算と加算を利用してxに6をかけます。\n" #: src/unsafe/asm.md:310 msgid "\"mov {tmp}, {x}\"" msgstr "\"mov {tmp}, {x}\"" #: src/unsafe/asm.md:311 msgid "\"shl {tmp}, 1\"" msgstr "\"shl {tmp}, 1\"" #: src/unsafe/asm.md:312 msgid "\"shl {x}, 2\"" msgstr "\"shl {x}, 2\"" #: src/unsafe/asm.md:313 msgid "\"add {x}, {tmp}\"" msgstr "\"add {x}, {tmp}\"" #: src/unsafe/asm.md:322 msgid "Symbol operands and ABI clobbers" msgstr "シンボル・オペランドとABIクロバー" #: src/unsafe/asm.md:324 msgid "" "By default, `asm!` assumes that any register not specified as an output will " "have its contents preserved by the assembly code. The [`clobber_abi`]" "(https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-" "clobbers) argument to `asm!` tells the compiler to automatically insert the " "necessary clobber operands according to the given calling convention ABI: " "any register which is not fully preserved in that ABI will be treated as " "clobbered. Multiple `clobber_abi` arguments may be provided and all " "clobbers from all specified ABIs will be inserted." msgstr "" "デフォルトでは、`asm!`は、出力として指定されていないレジスタはアセンブリコー" "ドによって中身が維持される、と考えます。`asm!`に渡される[`clobber_abi`]" "(https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-" "clobbers)引数は、与えられた呼び出し規約のABIに従って、必要なクロバーオペラン" "ドを自動的に挿入するようコンパイラに伝えます。そのABIで完全に保存されていない" "レジスタは、クロバーとして扱われます。複数の `clobber_abi` 引数を指定すると、" "指定されたすべてのABIのクロバーが挿入されます。" #: src/unsafe/asm.md:332 src/unsafe/asm.md:350 msgid "\"C\"" msgstr "\"C\"" #: src/unsafe/asm.md:333 msgid "\"arg = {}\"" msgstr "\"arg = {}\"" #: src/unsafe/asm.md:341 msgid "\"call {}\"" msgstr "\"call {}\"" #: src/unsafe/asm.md:342 msgid "// Function pointer to call\n" msgstr "// 呼び出す関数ポインタ\n" #: src/unsafe/asm.md:344 msgid "// 1st argument in rdi\n" msgstr "// 最初の引数はrdiにあります。\n" #: src/unsafe/asm.md:346 msgid "// Return value in rax\n" msgstr "// 戻り値はraxにあります。\n" #: src/unsafe/asm.md:348 msgid "" "// Mark all registers which are not preserved by the \"C\" calling\n" " // convention as clobbered.\n" msgstr "" "// \"C\"の呼び出し規約で保存されていないすべてのレジスタをクロバーに指定。\n" #: src/unsafe/asm.md:358 msgid "Register template modifiers" msgstr "レジスタテンプレート修飾子" #: src/unsafe/asm.md:360 msgid "" "In some cases, fine control is needed over the way a register name is " "formatted when inserted into the template string. This is needed when an " "architecture's assembly language has several names for the same register, " "each typically being a \"view\" over a subset of the register (e.g. the low " "32 bits of a 64-bit register)." msgstr "" "テンプレート文字列に挿入されるレジスタの名前のフォーマット方法について、細か" "い制御が必要な場合があります。アーキテクチャのアセンブリ言語が、同じレジスタ" "に別名を持っている場合です。典型的な例としては、レジスタの部分集合に対する" "\"ビュー\"があります（例：64ビットレジスタの下位32ビット）。" #: src/unsafe/asm.md:362 msgid "" "By default the compiler will always choose the name that refers to the full " "register size (e.g. `rax` on x86-64, `eax` on x86, etc)." msgstr "" "デフォルトでは、コンパイラは常に完全なレジスタサイズの名前を選択します（例：" "x86-64では`rax`、x86では`eax`、など）。" #: src/unsafe/asm.md:364 msgid "" "This default can be overridden by using modifiers on the template string " "operands, just like you would with format strings:" msgstr "" "この挙動は、フォーマット文字列と同じように、テンプレート文字列のオペランドに" "修飾子を利用することで上書きできます。" #: src/unsafe/asm.md:373 msgid "\"mov {0:h}, {0:l}\"" msgstr "\"mov {0:h}, {0:l}\"" #: src/unsafe/asm.md:380 msgid "" "In this example, we use the `reg_abcd` register class to restrict the " "register allocator to the 4 legacy x86 registers (`ax`, `bx`, `cx`, `dx`) of " "which the first two bytes can be addressed independently." msgstr "" "この例では、`reg_abcd`レジスタクラスを用いて、レジスタアロケータを4つのレガ" "シーなx86レジスタ（`ax`, `bx`, `cx`, `dx`）に制限しています。このうち最初の2" "バイトは独立して指定できます。" #: src/unsafe/asm.md:382 msgid "" "Let us assume that the register allocator has chosen to allocate `x` in the " "`ax` register. The `h` modifier will emit the register name for the high " "byte of that register and the `l` modifier will emit the register name for " "the low byte. The asm code will therefore be expanded as `mov ah, al` which " "copies the low byte of the value into the high byte." msgstr "" "レジスタアロケータが`x`を`ax`レジスタに割り当てることにしたと仮定しましょう。" "`h`修飾子はそのレジスタの上位バイトのレジスタ名を出力し、`l`修飾子は下位バイ" "トのレジスタ名を出力します。したがって、このアセンブリコードは`mov ah, al`に" "展開され、値の下位バイトを上位バイトにコピーします。" #: src/unsafe/asm.md:385 msgid "" "If you use a smaller data type (e.g. `u16`) with an operand and forget to " "use template modifiers, the compiler will emit a warning and suggest the " "correct modifier to use." msgstr "" "より小さなデータ型（例：`u16`）をオペランドに利用し、テンプレート修飾子を使い" "忘れた場合、コンパイラは警告を出力し、正しい修飾子を提案してくれます。" #: src/unsafe/asm.md:387 msgid "Memory address operands" msgstr "メモリアドレスオペランド" #: src/unsafe/asm.md:389 msgid "" "Sometimes assembly instructions require operands passed via memory addresses/" "memory locations. You have to manually use the memory address syntax " "specified by the target architecture. For example, on x86/x86_64 using Intel " "assembly syntax, you should wrap inputs/outputs in `[]` to indicate they are " "memory operands:" msgstr "" "アセンブリ命令はオペランドがメモリアドレスやメモリロケーション経由で渡される" "必要なこともあります。そのときは手動で、ターゲットのアーキテクチャによって指" "定されたメモリアドレスのシンタックスを利用しなくてはなりません。例えば、Intel" "のアセンブリシンタックスを使うx86/x86_64の場合、入出力を`[]`で囲んで、メモリ" "オペランドであることを示さなくてはなりません。" #: src/unsafe/asm.md:399 msgid "\"fldcw [{}]\"" msgstr "\"fldcw [{}]\"" #: src/unsafe/asm.md:405 msgid "Labels" msgstr "ラベル" #: src/unsafe/asm.md:407 msgid "" "Any reuse of a named label, local or otherwise, can result in an assembler " "or linker error or may cause other strange behavior. Reuse of a named label " "can happen in a variety of ways including:" msgstr "" "名前つきラベルの再利用は、ローカルかそうでないかに関わらず、アセンブラやリン" "カのエラーを引き起こしたり、変な挙動の原因となります。名前つきラベルの再利用" "は以下のようなケースがあります。" #: src/unsafe/asm.md:409 msgid "" "explicitly: using a label more than once in one `asm!` block, or multiple " "times across blocks." msgstr "" "明示的再利用：同じラベルを1つの`asm!`ブロック中で、または複数のブロック中で2" "回以上利用する場合です。" #: src/unsafe/asm.md:410 msgid "" "implicitly via inlining: the compiler is allowed to instantiate multiple " "copies of an `asm!` block, for example when the function containing it is " "inlined in multiple places." msgstr "" "インライン化による暗黙の再利用：コンパイラは`asm!`ブロックの複数のコピーをイ" "ンスタンス化する場合があります。例えば、`asm!`ブロックを含む関数が複数箇所で" "インライン化される場合です。" #: src/unsafe/asm.md:411 msgid "" "implicitly via LTO: LTO can cause code from _other crates_ to be placed in " "the same codegen unit, and so could bring in arbitrary labels." msgstr "" "LTO（訳注：Link Time Optimizationの略）による暗黙の再利用：LTOは *他のクレー" "ト* のコードを同じコード生成単位に配置するため、同じ名前のラベルを持ち込む場" "合があります。" #: src/unsafe/asm.md:413 msgid "" "As a consequence, you should only use GNU assembler **numeric** [local " "labels](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-" "Labels) inside inline assembly code. Defining symbols in assembly code may " "lead to assembler and/or linker errors due to duplicate symbol definitions." msgstr "" "そのため、インラインアセンブリコードの中では、GNUアセンブラの **数値型**[ロー" "カルラベル](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-" "Labels)のみ使用してください。アセンブリコード内でシンボルを定義すると、シンボ" "ル定義の重複により、アセンブラやリンカのエラーが発生する可能性があります。" #: src/unsafe/asm.md:415 msgid "" "Moreover, on x86 when using the default Intel syntax, due to [an LLVM bug]" "(https://bugs.llvm.org/show_bug.cgi?id=36144), you shouldn't use labels " "exclusively made of `0` and `1` digits, e.g. `0`, `11` or `101010`, as they " "may end up being interpreted as binary values. Using `options(att_syntax)` " "will avoid any ambiguity, but that affects the syntax of the _entire_ `asm!` " "block. (See [Options](#options), below, for more on `options`.)" msgstr "" "さらに、x86でデフォルトのIntel構文を使用する場合、[LLVMのバグ](https://bugs." "llvm.org/show_bug.cgi?id=36144)によって、`0`、`11`、`101010`といった`0`と`1`" "だけで構成されたラベルは、バイナリ値として解釈されてしまうため、使用してはい" "けません。`options(att_syntax)`を使うと曖昧さを避けられますが、`asm!`ブロッ" "ク _全体_ の構文に影響します。（`options`については、後述の[オプション]" "(#options)を参照してください。）" #: src/unsafe/asm.md:424 msgid "\"mov {0}, 10\"" msgstr "\"mov {0}, 10\"" #: src/unsafe/asm.md:425 src/unsafe/asm.md:430 msgid "\"2:\"" msgstr "\"2:\"" #: src/unsafe/asm.md:426 msgid "\"sub {0}, 1\"" msgstr "\"sub {0}, 1\"" #: src/unsafe/asm.md:427 msgid "\"cmp {0}, 3\"" msgstr "\"cmp {0}, 3\"" #: src/unsafe/asm.md:428 msgid "\"jle 2f\"" msgstr "\"jle 2f\"" #: src/unsafe/asm.md:429 msgid "\"jmp 2b\"" msgstr "\"jmp 2b\"" #: src/unsafe/asm.md:431 msgid "\"add {0}, 2\"" msgstr "\"add {0}, 2\"" #: src/unsafe/asm.md:439 msgid "" "This will decrement the `{0}` register value from 10 to 3, then add 2 and " "store it in `a`." msgstr "" "このコードは、`{0}`のレジスタの値を10から3にデクリメントし、2を加え、`a`にそ" "の値を保存します。" #: src/unsafe/asm.md:441 msgid "This example shows a few things:" msgstr "この例は、以下のことを示しています。" #: src/unsafe/asm.md:443 msgid "" "First, that the same number can be used as a label multiple times in the " "same inline block." msgstr "" "まず、ラベルとして同じ数字を複数回、同じインラインブロックで利用できます。" #: src/unsafe/asm.md:444 msgid "" "Second, that when a numeric label is used as a reference (as an instruction " "operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) " "should be added to the numeric label. It will then refer to the nearest " "label defined by this number in this direction." msgstr "" "つぎに、数字のラベルが参照として(例えば、命令のオペランドに)利用された場" "合、\"b\"（\"後方\"）や\"f\"（\"前方\"）の接尾辞が数字のラベルに追加されなく" "てはなりません。そうすることで、この数字の指定された方向の最も近いラベルを参" "照できます。" #: src/unsafe/asm.md:449 msgid "Options" msgstr "オプション" #: src/unsafe/asm.md:451 msgid "" "By default, an inline assembly block is treated the same way as an external " "FFI function call with a custom calling convention: it may read/write " "memory, have observable side effects, etc. However, in many cases it is " "desirable to give the compiler more information about what the assembly code " "is actually doing so that it can optimize better." msgstr "" "デフォルトでは、インラインアセンブリブロックは、カスタム呼び出し規約をもつ外" "部のFFI関数呼び出しと同じように扱われます:メモリを読み込んだり書き込んだり、" "観測可能な副作用を持っていたりするかもしれません。しかし、多くの場合、アセン" "ブリコードが実際に何をするかという情報を多く与えて、より最適化できる方が望ま" "しいでしょう。" #: src/unsafe/asm.md:453 msgid "Let's take our previous example of an `add` instruction:" msgstr "先ほどの`add`命令の例を見てみましょう。" #: src/unsafe/asm.md:472 msgid "" "Options can be provided as an optional final argument to the `asm!` macro. " "We specified three options here:" msgstr "" "オプションは`asm!`マクロの最後の任意引数として渡されます。ここでは3つのオプ" "ションを利用しました：" #: src/unsafe/asm.md:473 msgid "" "`pure` means that the asm code has no observable side effects and that its " "output depends only on its inputs. This allows the compiler optimizer to " "call the inline asm fewer times or even eliminate it entirely." msgstr "" "`pure`は、アセンブリコードが観測可能な副作用を持っておらず、出力は入力のみに" "依存することを意味します。これにより、コンパイラオプティマイザはインラインア" "センブリの呼び出し回数を減らしたり、インラインアセンブリを完全に削除したりで" "きます。" #: src/unsafe/asm.md:474 msgid "" "`nomem` means that the asm code does not read or write to memory. By default " "the compiler will assume that inline assembly can read or write any memory " "address that is accessible to it (e.g. through a pointer passed as an " "operand, or a global)." msgstr "" "`nomem`は、アセンブリコードがメモリの読み書きをしないことを意味します。デフォ" "ルトでは、インラインアセンブリはアクセス可能なメモリアドレス（例えばオペラン" "ドとして渡されたポインタや、グローバルなど）の読み書きを行うとコンパイラは仮" "定しています。" #: src/unsafe/asm.md:475 msgid "" "`nostack` means that the asm code does not push any data onto the stack. " "This allows the compiler to use optimizations such as the stack red zone on " "x86-64 to avoid stack pointer adjustments." msgstr "" "`nostack`は、アセンブリコードがスタックにデータをプッシュしないことを意味しま" "す。これにより、コンパイラはx86-64のスタックレッドゾーンなどの最適化を利用" "し、スタックポインタの調整を避けることができます。" #: src/unsafe/asm.md:477 msgid "" "These allow the compiler to better optimize code using `asm!`, for example " "by eliminating pure `asm!` blocks whose outputs are not needed." msgstr "" "これにより、コンパイラは、出力が全く必要とされていない純粋な`asm!`ブロックを" "削除するなどして、`asm!`を使ったコードをより最適化できます。" #: src/unsafe/asm.md:479 msgid "" "See the [reference](https://doc.rust-lang.org/stable/reference/inline-" "assembly.html) for the full list of available options and their effects." msgstr "" "利用可能なオプションとその効果の一覧は[リファレンス](https://doc.rust-lang." "org/stable/reference/inline-assembly.html)を参照してください。" #: src/compatibility.md:3 msgid "" "The Rust language is fastly evolving, and because of this certain " "compatibility issues can arise, despite efforts to ensure forwards-" "compatibility wherever possible." msgstr "" "Rust言語は急速に進化しており、可能な限り前方互換性を確保する努力にも関わら" "ず、特定の互換性の問題が生じることがあります。" #: src/compatibility.md:7 msgid "[Raw identifiers](compatibility/raw_identifiers.md)" msgstr "[生識別子](compatibility/raw_identifiers.md)" #: src/compatibility/raw_identifiers.md:3 msgid "" "Rust, like many programming languages, has the concept of \"keywords\". " "These identifiers mean something to the language, and so you cannot use them " "in places like variable names, function names, and other places. Raw " "identifiers let you use keywords where they would not normally be allowed. " "This is particularly useful when Rust introduces new keywords, and a library " "using an older edition of Rust has a variable or function with the same name " "as a keyword introduced in a newer edition." msgstr "" "Rustは多くのプログラミング言語と同様に、「キーワード」の概念を持っています。" "これらの識別子は言語にとって何かしらの意味を持ちますので、変数名や関数名、そ" "の他の場所で使用することはできません。生識別子は、通常は許されない状況でキー" "ワードを使用することを可能にします。これは、新しいキーワードを導入したRust" "と、古いエディションのRustを使用したライブラリが同じ名前の変数や関数を持つ場" "合に特に便利です。" #: src/compatibility/raw_identifiers.md:11 msgid "" "For example, consider a crate `foo` compiled with the 2015 edition of Rust " "that exports a function named `try`. This keyword is reserved for a new " "feature in the 2018 edition, so without raw identifiers, we would have no " "way to name the function." msgstr "" "例えば、2015年エディションのRustでコンパイルされたクレート`foo`が`try`という" "名前の関数をエクスポートしているとします。このキーワードは2018年エディション" "で新機能として予約されていますので、生識別子がなければ、この関数を名付ける方" "法がありません。" #: src/compatibility/raw_identifiers.md:24 msgid "You'll get this error:" msgstr "このエラーが出ます：" #: src/compatibility/raw_identifiers.md:34 msgid "You can write this with a raw identifier:" msgstr "これは生識別子を使って書くことができます：" #: src/meta.md:3 msgid "" "Some topics aren't exactly relevant to how you program runs but provide you " "tooling or infrastructure support which just makes things better for " "everyone. These topics include:" msgstr "" "この章では、プログラミングそれ自体に関係はないけれども、色々と人々の役に立つ" "機能やインフラについて説明していきます。例えば：" #: src/meta.md:7 msgid "" "[Documentation](meta/doc.md): Generate library documentation for users via " "the included `rustdoc`." msgstr "" "[ドキュメンテーション](meta/doc.md): Rust付属コマンド`rustdoc`を用いて、ライ" "ブラリのドキュメントを生成します。" #: src/meta.md:9 msgid "" "[Playground](meta/playground.md): Integrate the Rust Playground in your " "documentation." msgstr "" "[プレイグラウンド](meta/playground.md): あなたのドキュメンテーションにRust " "Playgroundを組み込めます。" #: src/meta/doc.md:3 msgid "" "Use `cargo doc` to build documentation in `target/doc`, `cargo doc --open` " "will automatically open it in your web browser." msgstr "" #: src/meta/doc.md:6 msgid "" "Use `cargo test` to run all tests (including documentation tests), and " "`cargo test --doc` to only run documentation tests." msgstr "" #: src/meta/doc.md:9 msgid "" "These commands will appropriately invoke `rustdoc` (and `rustc`) as required." msgstr "" #: src/meta/doc.md:11 msgid "Doc comments" msgstr "ドキュメンテーションコメント" #: src/meta/doc.md:13 msgid "" "Doc comments are very useful for big projects that require documentation. " "When running `rustdoc`, these are the comments that get compiled into " "documentation. They are denoted by a `///`, and support [Markdown](https://" "en.wikipedia.org/wiki/Markdown)." msgstr "" "ドキュメンテーションコメントとは`rustdoc`を使用した際にドキュメントにコンパイ" "ルされるコメントのことです。`///`によって普通のコメントと区別され、ここでは" "[Markdown](https://en.wikipedia.org/wiki/Markdown)を使用することができます。" "ドキュメンテーションコメントは大規模なプロジェクトの際に非常に有用です。" #: src/meta/doc.md:18 msgid "\"doc\"" msgstr "\"doc\"" #: src/meta/doc.md:19 msgid "/// A human being is represented here\n" msgstr "/// あらゆる人物はここに代表されます。\n" #: src/meta/doc.md:22 msgid "/// A person must have a name, no matter how much Juliet may hate it\n" msgstr "" "/// ジュリエットがどんなに名前というものを嫌っていようと、\n" " /// 人物には名前が必要です。\n" #: src/meta/doc.md:27 msgid "" "/// Creates a person with the given name.\n" " ///\n" " /// # Examples\n" " ///\n" " /// ```\n" " /// // You can have rust code between fences inside the comments\n" " /// // If you pass --test to `rustdoc`, it will even test it for you!\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" msgstr "" "/// 与えられた名前を持つpersonを返します。\n" " ///\n" " /// # Examples\n" " ///\n" " /// ```\n" " /// // バッククォートによってRustのコードをコメント中に挟むこと\n" " /// // もできます。`rustdoc`に--testを渡せば、テストも行えます！\n" " /// // （訳注: pythonのdoctestと同じです。）\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" #: src/meta/doc.md:43 msgid "" "/// Gives a friendly hello!\n" " ///\n" " /// Says \"Hello, [name](Person::name)\" to the `Person` it is called " "on.\n" msgstr "" "/// フレンドリーに挨拶しましょう！\n" " ///\n" " /// このメソッドを呼び出した`Person`に対して\n" " /// \"Hello, [name](Person::name)\"と話しかけます。\n" #: src/meta/doc.md:47 msgid "\"Hello, {}!\"" msgstr "\"Hello, {}!\"" #: src/meta/doc.md:52 msgid "\"John\"" msgstr "\"John\"" #: src/meta/doc.md:58 msgid "" "To run the tests, first build the code as a library, then tell `rustdoc` " "where to find the library so it can link it into each doctest program:" msgstr "" #: src/meta/doc.md:61 msgid "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" msgstr "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" #: src/meta/doc.md:66 msgid "Doc attributes" msgstr "" #: src/meta/doc.md:68 msgid "" "Below are a few examples of the most common `#[doc]` attributes used with " "`rustdoc`." msgstr "" #: src/meta/doc.md:71 msgid "`inline`" msgstr "`inline`" #: src/meta/doc.md:73 msgid "Used to inline docs, instead of linking out to separate page." msgstr "" #: src/meta/doc.md:78 msgid "/// bar docs\n" msgstr "" #: src/meta/doc.md:81 msgid "/// the docs for Bar\n" msgstr "" #: src/meta/doc.md:86 msgid "`no_inline`" msgstr "`no_inline`" #: src/meta/doc.md:88 msgid "Used to prevent linking out to separate page or anywhere." msgstr "" #: src/meta/doc.md:91 msgid "// Example from libcore/prelude\n" msgstr "" #: src/meta/doc.md:96 msgid "`hidden`" msgstr "`hidden`" #: src/meta/doc.md:98 msgid "Using this tells `rustdoc` not to include this in documentation:" msgstr "" #: src/meta/doc.md:101 msgid "// Example from the futures-rs library\n" msgstr "" #: src/meta/doc.md:106 msgid "" "For documentation, `rustdoc` is widely used by the community. It's what is " "used to generate the [std library docs](https://doc.rust-lang.org/std/)." msgstr "" #: src/meta/doc.md:111 msgid "" "[The Rust Book: Making Useful Documentation Comments](https://doc.rust-lang." "org/book/ch14-02-publishing-to-crates-io.html#making-useful-documentation-" "comments)" msgstr "" #: src/meta/doc.md:112 msgid "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/index.html)" msgstr "" #: src/meta/doc.md:113 msgid "" "[The Reference: Doc comments](https://doc.rust-lang.org/stable/reference/" "comments.html#doc-comments)" msgstr "" #: src/meta/doc.md:114 msgid "" "[RFC 1574: API Documentation Conventions](https://rust-lang.github.io/" "rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-" "conventions-text)" msgstr "" #: src/meta/doc.md:115 msgid "" "[RFC 1946: Relative links to other items from doc comments (intra-rustdoc " "links)](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)" msgstr "" #: src/meta/doc.md:116 msgid "" "[Is there any documentation style guide for comments? (reddit)](https://www." "reddit.com/r/rust/comments/ahb50s/" "is_there_any_documentation_style_guide_for/)" msgstr "" #: src/meta/playground.md:3 msgid "" "The [Rust Playground](https://play.rust-lang.org/) is a way to experiment " "with Rust code through a web interface." msgstr "" "[Rust Playground](https://play.rust-lang.org/)では、RustのコードをWebのイン" "ターフェースを通じて実験できます。" #: src/meta/playground.md:6 msgid "Using it with `mdbook`" msgstr "`mdbook`と組み合わせる" #: src/meta/playground.md:8 msgid "" "In [`mdbook`](https://github.com/rust-lang/mdBook), you can make code " "examples playable and editable." msgstr "" "[`mdbook`](https://github.com/rust-lang/mdBook)では、コード例を実行・編集可能" "にできます。" #: src/meta/playground.md:16 msgid "" "This allows the reader to both run your code sample, but also modify and " "tweak it. The key here is the adding of the word `editable` to your " "codefence block separated by a comma." msgstr "" "これにより、読者はあなたのコード例を実行するだけでなく、変更することもできま" "す。`editable`という単語をカンマで区切って、あなたのコードブロックに追加する" "のがキーです。" #: src/meta/playground.md:26 msgid "" "Additionally, you can add `ignore` if you want `mdbook` to skip your code " "when it builds and tests." msgstr "" "加えて、`mdbook`がビルドやテストを実行するときに、あなたのコードをスキップさ" "せたい場合は、`ignore`を追加できます。" #: src/meta/playground.md:35 msgid "Using it with docs" msgstr "ドキュメントと組み合わせる" #: src/meta/playground.md:37 msgid "" "You may have noticed in some of the [official Rust docs](https://doc.rust-" "lang.org/core/) a button that says \"Run\", which opens the code sample up " "in a new tab in Rust Playground. This feature is enabled if you use the " "`#[doc]` attribute called [`html_playground_url`](https://doc.rust-lang.org/" "rustdoc/write-documentation/the-doc-attribute.html#html_playground_url)." msgstr "" "[Rustの公式ドキュメント](https://doc.rust-lang.org/core/)には、「実行(Run)」" "ボタンがある場合があります。クリックすると、新しいタブでRust Playgroundが開" "き、コード例が表示されます。この機能は、#[doc]アトリビュートの" "[`html_playground_url`](https://doc.rust-lang.org/rustdoc/write-" "documentation/the-doc-attribute.html#html_playground_url)の値で有効化できま" "す。" #: src/meta/playground.md:42 msgid "" "````\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" msgstr "" "````\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" #: src/meta/playground.md:51 msgid "[The Rust Playground](https://play.rust-lang.org/)" msgstr "" #: src/meta/playground.md:52 msgid "" "[The Rust Playground On Github](https://github.com/integer32llc/rust-" "playground/)" msgstr "" #: src/meta/playground.md:53 msgid "" "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)" msgstr "" #~ msgid "" #~ "Using the `Into` trait will typically require specification of the type " #~ "to convert into as the compiler is unable to determine this most of the " #~ "time. However this is a small trade-off considering we get the " #~ "functionality for free." #~ msgstr "" #~ "`Into`トレイトを使用すると、ほとんどの場合、コンパイラが型を決定することが" #~ "できないため、変換する型を指定する必要があります。しかし、この機能を無料で" #~ "得られることを考えれば、これは小さなトレードオフです。" #~ msgid "\"Base 16 (hexadecimal): {:X}\"" #~ msgstr "\"Base 16 (hexadecimal): {:X}\"" #~ msgid "// 10F2C\n" #~ msgstr "// 10F2C\n" #~ msgid "\"The rich have lots of money!\"" #~ msgstr "\"The rich have lots of money!\"" #~ msgid "\"The poor have no money...\"" #~ msgstr "\"The poor have no money...\"" #~ msgid "\"Civilians work!\"" #~ msgstr "\"Civilians work!\"" #~ msgid "\"Soldiers fight!\"" #~ msgstr "\"Soldiers fight!\"" #~ msgid "\"Old enough {}\"" #~ msgstr "\"Old enough {}\"" #~ msgid "\"the quick brown fox jumped over the lazy dog\\n\"" #~ msgstr "\"the quick brown fox jumped over the lazy dog\\n\"" ================================================ FILE: po/ko.po ================================================ msgid "" msgstr "" "Project-Id-Version: Rust By Example\n" "POT-Creation-Date: 2026-01-13T13:46:42+09:00\n" "PO-Revision-Date: 2026-01-13 13:46+0900\n" "Last-Translator: ehottl \n" "Language-Team: Korean \n" "Language: ko\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" #: src/SUMMARY.md:1 msgid "Summary" msgstr "요약" #: src/SUMMARY.md:3 msgid "Introduction" msgstr "소개" #: src/SUMMARY.md:5 src/hello.md:1 msgid "Hello World" msgstr "Hello World" #: src/SUMMARY.md:6 src/hello/comment.md:1 msgid "Comments" msgstr "주석" #: src/SUMMARY.md:7 src/hello/print.md:1 msgid "Formatted print" msgstr "형식화된 출력" #: src/SUMMARY.md:8 src/hello/print/print_debug.md:1 msgid "Debug" msgstr "디버그" #: src/SUMMARY.md:9 src/hello/print/print_display.md:1 msgid "Display" msgstr "디스플레이" #: src/SUMMARY.md:10 src/hello/print/print_display/testcase_list.md:1 msgid "Testcase: List" msgstr "테스트케이스: 리스트" #: src/SUMMARY.md:11 src/hello/print/fmt.md:1 msgid "Formatting" msgstr "형식화" #: src/SUMMARY.md:13 src/primitives.md:1 msgid "Primitives" msgstr "기본 자료형" #: src/SUMMARY.md:14 src/primitives/literals.md:1 msgid "Literals and operators" msgstr "리터럴과 연산자" #: src/SUMMARY.md:15 src/primitives/tuples.md:1 msgid "Tuples" msgstr "튜플" #: src/SUMMARY.md:16 src/primitives/array.md:1 msgid "Arrays and Slices" msgstr "배열과 슬라이스" #: src/SUMMARY.md:18 src/custom_types.md:1 msgid "Custom Types" msgstr "사용자 정의 타입" #: src/SUMMARY.md:19 src/custom_types/structs.md:1 msgid "Structures" msgstr "구조체" #: src/SUMMARY.md:20 src/custom_types/enum.md:1 msgid "Enums" msgstr "열거형" #: src/SUMMARY.md:21 src/custom_types/enum/enum_use.md:1 msgid "use" msgstr "use" #: src/SUMMARY.md:22 src/custom_types/enum/c_like.md:1 msgid "C-like" msgstr "C-like" #: src/SUMMARY.md:23 src/custom_types/enum/testcase_linked_list.md:1 msgid "Testcase: linked-list" msgstr "테스트케이스: 연결 리스트" #: src/SUMMARY.md:24 src/custom_types/constants.md:1 msgid "constants" msgstr "상수" #: src/SUMMARY.md:26 src/variable_bindings.md:1 msgid "Variable Bindings" msgstr "변수 바인딩" #: src/SUMMARY.md:27 src/SUMMARY.md:120 src/SUMMARY.md:123 #: src/variable_bindings/mut.md:1 src/scope/move/mut.md:1 #: src/scope/borrow/mut.md:1 msgid "Mutability" msgstr "가변성" #: src/SUMMARY.md:28 src/variable_bindings/scope.md:1 msgid "Scope and Shadowing" msgstr "스코프와 섀도잉" #: src/SUMMARY.md:29 src/variable_bindings/declare.md:1 msgid "Declare first" msgstr "선언 우선" #: src/SUMMARY.md:30 src/variable_bindings/freeze.md:1 msgid "Freezing" msgstr "동결" #: src/SUMMARY.md:32 src/types.md:1 msgid "Types" msgstr "타입" #: src/SUMMARY.md:33 src/types/cast.md:1 msgid "Casting" msgstr "형변환" #: src/SUMMARY.md:34 src/types/literals.md:1 msgid "Literals" msgstr "리터럴" #: src/SUMMARY.md:35 src/types/inference.md:1 msgid "Inference" msgstr "추론" #: src/SUMMARY.md:36 src/SUMMARY.md:124 src/types/alias.md:1 #: src/scope/borrow/alias.md:1 msgid "Aliasing" msgstr "별칭" #: src/SUMMARY.md:38 src/conversion.md:1 msgid "Conversion" msgstr "타입 변환" #: src/SUMMARY.md:39 src/conversion/from_into.md:1 msgid "`From` and `Into`" msgstr "`From`과 `Into`" #: src/SUMMARY.md:40 src/conversion/try_from_try_into.md:1 msgid "`TryFrom` and `TryInto`" msgstr "`TryFrom`과 `TryInto`" #: src/SUMMARY.md:41 msgid "To and from `String`s" msgstr "`String` 변환" #: src/SUMMARY.md:43 src/expression.md:1 msgid "Expressions" msgstr "표현식" #: src/SUMMARY.md:45 src/flow_control.md:1 msgid "Flow of Control" msgstr "제어 흐름" #: src/SUMMARY.md:46 src/flow_control/if_else.md:1 msgid "if/else" msgstr "if/else" #: src/SUMMARY.md:47 src/flow_control/loop.md:1 msgid "loop" msgstr "loop" #: src/SUMMARY.md:48 src/flow_control/loop/nested.md:1 msgid "Nesting and labels" msgstr "중첩과 레이블" #: src/SUMMARY.md:49 src/flow_control/loop/return.md:1 msgid "Returning from loops" msgstr "반복문에서 리턴하기" #: src/SUMMARY.md:50 src/flow_control/while.md:1 msgid "while" msgstr "while" #: src/SUMMARY.md:51 src/flow_control/for.md:3 msgid "for and range" msgstr "for와 range" #: src/SUMMARY.md:52 src/flow_control/match.md:1 msgid "match" msgstr "match" #: src/SUMMARY.md:53 src/flow_control/match/destructuring.md:1 msgid "Destructuring" msgstr "구조 분해" #: src/SUMMARY.md:54 #: src/flow_control/match/destructuring/destructure_tuple.md:1 msgid "tuples" msgstr "튜플" #: src/SUMMARY.md:55 #: src/flow_control/match/destructuring/destructure_slice.md:1 msgid "arrays/slices" msgstr "배열/슬라이스" #: src/SUMMARY.md:56 src/flow_control/match/destructuring/destructure_enum.md:1 msgid "enums" msgstr "열거형" #: src/SUMMARY.md:57 #: src/flow_control/match/destructuring/destructure_pointers.md:1 msgid "pointers/ref" msgstr "포인터/ref" #: src/SUMMARY.md:58 #: src/flow_control/match/destructuring/destructure_structures.md:1 msgid "structs" msgstr "구조체" #: src/SUMMARY.md:59 src/flow_control/match/guard.md:1 msgid "Guards" msgstr "가드" #: src/SUMMARY.md:60 src/flow_control/match/binding.md:1 msgid "Binding" msgstr "바인딩" #: src/SUMMARY.md:61 src/flow_control/if_let.md:1 msgid "if let" msgstr "if let" #: src/SUMMARY.md:62 src/flow_control/let_else.md:1 msgid "let-else" msgstr "let-else" #: src/SUMMARY.md:63 src/flow_control/while_let.md:1 msgid "while let" msgstr "while let" #: src/SUMMARY.md:65 src/SUMMARY.md:103 src/SUMMARY.md:128 src/fn.md:1 #: src/generics/gen_fn.md:1 src/scope/lifetime/fn.md:1 msgid "Functions" msgstr "함수" #: src/SUMMARY.md:66 src/SUMMARY.md:129 src/scope/lifetime/methods.md:1 msgid "Methods" msgstr "메서드" #: src/SUMMARY.md:67 src/fn/closures.md:1 msgid "Closures" msgstr "클로저" #: src/SUMMARY.md:68 src/fn/closures/capture.md:1 msgid "Capturing" msgstr "캡처" #: src/SUMMARY.md:69 src/fn/closures/input_parameters.md:1 msgid "As input parameters" msgstr "입력 파라미터로 사용" #: src/SUMMARY.md:70 src/fn/closures/anonymity.md:1 msgid "Type anonymity" msgstr "타입 익명성" #: src/SUMMARY.md:71 src/fn/closures/input_functions.md:1 msgid "Input functions" msgstr "입력 함수" #: src/SUMMARY.md:72 src/fn/closures/output_parameters.md:1 msgid "As output parameters" msgstr "출력 파라미터로 사용" #: src/SUMMARY.md:73 src/fn/closures/closure_examples.md:1 msgid "Examples in `std`" msgstr "`std` 예제" #: src/SUMMARY.md:74 src/fn/closures/closure_examples/iter_any.md:1 msgid "Iterator::any" msgstr "Iterator::any" #: src/SUMMARY.md:75 src/fn/closures/closure_examples/iter_find.md:1 msgid "Searching through iterators" msgstr "이터레이터 검색" #: src/SUMMARY.md:76 src/fn/hof.md:1 msgid "Higher Order Functions" msgstr "고차 함수" #: src/SUMMARY.md:77 src/fn/diverging.md:1 msgid "Diverging functions" msgstr "발산 함수" #: src/SUMMARY.md:79 src/mod.md:1 msgid "Modules" msgstr "모듈" #: src/SUMMARY.md:80 src/mod/visibility.md:1 msgid "Visibility" msgstr "가시성" #: src/SUMMARY.md:81 src/mod/struct_visibility.md:1 msgid "Struct visibility" msgstr "구조체 가시성" #: src/SUMMARY.md:82 src/mod/use.md:1 msgid "The `use` declaration" msgstr "`use` 선언" #: src/SUMMARY.md:83 src/mod/super.md:1 msgid "`super` and `self`" msgstr "`super`와 `self`" #: src/SUMMARY.md:84 src/mod/split.md:1 msgid "File hierarchy" msgstr "파일 계층 구조" #: src/SUMMARY.md:86 src/SUMMARY.md:98 src/crates.md:1 src/attribute/crate.md:1 #: src/std_misc/arg.md:30 msgid "Crates" msgstr "크레이트" #: src/SUMMARY.md:87 src/crates/lib.md:1 msgid "Creating a Library" msgstr "라이브러리 생성" #: src/SUMMARY.md:88 src/crates/using_lib.md:1 msgid "Using a Library" msgstr "라이브러리 사용" #: src/SUMMARY.md:90 src/cargo.md:1 msgid "Cargo" msgstr "카고" #: src/SUMMARY.md:91 src/cargo/deps.md:1 msgid "Dependencies" msgstr "의존성" #: src/SUMMARY.md:92 src/cargo/conventions.md:1 msgid "Conventions" msgstr "관례" #: src/SUMMARY.md:93 msgid "Tests" msgstr "테스트" #: src/SUMMARY.md:94 src/cargo/build_scripts.md:1 msgid "Build Scripts" msgstr "빌드 스크립트" #: src/SUMMARY.md:96 src/attribute.md:1 msgid "Attributes" msgstr "속성" #: src/SUMMARY.md:97 src/attribute/unused.md:1 msgid "`dead_code`" msgstr "`dead_code`" #: src/SUMMARY.md:99 src/attribute/cfg.md:1 msgid "`cfg`" msgstr "`cfg`" #: src/SUMMARY.md:100 src/attribute/cfg/custom.md:1 msgid "Custom" msgstr "사용자 정의" #: src/SUMMARY.md:102 src/generics.md:1 msgid "Generics" msgstr "제네릭" #: src/SUMMARY.md:104 src/generics/impl.md:1 msgid "Implementation" msgstr "구현" #: src/SUMMARY.md:105 src/SUMMARY.md:131 src/SUMMARY.md:137 #: src/generics/gen_trait.md:1 src/scope/lifetime/trait.md:1 src/trait.md:1 msgid "Traits" msgstr "트레이트" #: src/SUMMARY.md:106 src/SUMMARY.md:132 src/generics/bounds.md:1 #: src/scope/lifetime/lifetime_bounds.md:1 msgid "Bounds" msgstr "바운드" #: src/SUMMARY.md:107 src/generics/bounds/testcase_empty.md:1 msgid "Testcase: empty bounds" msgstr "테스트케이스: 빈 바운드" #: src/SUMMARY.md:108 src/generics/multi_bounds.md:1 msgid "Multiple bounds" msgstr "다중 바운드" #: src/SUMMARY.md:109 src/generics/where.md:1 msgid "Where clauses" msgstr "Where 절" #: src/SUMMARY.md:110 src/generics/new_types.md:1 msgid "New Type Idiom" msgstr "New Type 관용구" #: src/SUMMARY.md:111 src/generics/assoc_items.md:1 msgid "Associated items" msgstr "연관 아이템" #: src/SUMMARY.md:112 src/generics/assoc_items/the_problem.md:1 msgid "The Problem" msgstr "문제점" #: src/SUMMARY.md:113 src/generics/assoc_items/types.md:1 msgid "Associated types" msgstr "연관 타입" #: src/SUMMARY.md:114 src/generics/phantom.md:1 msgid "Phantom type parameters" msgstr "팬텀 타입 파라미터" #: src/SUMMARY.md:115 src/generics/phantom/testcase_units.md:1 msgid "Testcase: unit clarification" msgstr "테스트케이스: 단위 명확화" #: src/SUMMARY.md:117 src/scope.md:1 msgid "Scoping rules" msgstr "스코프 규칙" #: src/SUMMARY.md:118 src/scope/raii.md:1 msgid "RAII" msgstr "RAII" #: src/SUMMARY.md:119 src/scope/move.md:1 msgid "Ownership and moves" msgstr "소유권과 이동" #: src/SUMMARY.md:121 src/scope/move/partial_move.md:1 msgid "Partial moves" msgstr "부분 이동" #: src/SUMMARY.md:122 src/scope/borrow.md:1 msgid "Borrowing" msgstr "빌림" #: src/SUMMARY.md:125 src/scope/borrow/ref.md:1 msgid "The ref pattern" msgstr "ref 패턴" #: src/SUMMARY.md:126 src/scope/lifetime.md:1 msgid "Lifetimes" msgstr "라이프타임" #: src/SUMMARY.md:127 src/scope/lifetime/explicit.md:1 msgid "Explicit annotation" msgstr "명시적 어노테이션" #: src/SUMMARY.md:130 src/scope/lifetime/struct.md:1 msgid "Structs" msgstr "구조체" #: src/SUMMARY.md:133 src/scope/lifetime/lifetime_coercion.md:1 msgid "Coercion" msgstr "강제" #: src/SUMMARY.md:134 src/scope/lifetime/static_lifetime.md:1 msgid "Static" msgstr "Static" #: src/SUMMARY.md:135 src/scope/lifetime/elision.md:1 msgid "Elision" msgstr "생략" #: src/SUMMARY.md:138 src/trait/derive.md:1 msgid "Derive" msgstr "Derive" #: src/SUMMARY.md:139 src/trait/dyn.md:1 msgid "Returning Traits with `dyn`" msgstr "`dyn`으로 트레이트 반환하기" #: src/SUMMARY.md:140 src/trait/ops.md:1 msgid "Operator Overloading" msgstr "연산자 오버로딩" #: src/SUMMARY.md:141 src/trait/drop.md:1 msgid "Drop" msgstr "Drop" #: src/SUMMARY.md:142 src/trait/iter.md:1 msgid "Iterators" msgstr "이터레이터" #: src/SUMMARY.md:143 src/trait/impl_trait.md:1 msgid "`impl Trait`" msgstr "`impl Trait`" #: src/SUMMARY.md:144 src/trait/clone.md:1 msgid "Clone" msgstr "Clone" #: src/SUMMARY.md:145 src/trait/supertraits.md:1 msgid "Supertraits" msgstr "슈퍼트레이트" #: src/SUMMARY.md:146 src/trait/disambiguating.md:1 msgid "Disambiguating overlapping traits" msgstr "중복 트레이트 명확화" #: src/SUMMARY.md:148 msgid "macro_rules!" msgstr "macro_rules!" #: src/SUMMARY.md:149 src/macros/syntax.md:1 msgid "Syntax" msgstr "문법" #: src/SUMMARY.md:150 src/macros/designators.md:1 msgid "Designators" msgstr "지시자" #: src/SUMMARY.md:151 src/macros/overload.md:1 msgid "Overload" msgstr "오버로드" #: src/SUMMARY.md:152 src/macros/repeat.md:1 msgid "Repeat" msgstr "반복" #: src/SUMMARY.md:153 src/macros/dry.md:1 msgid "DRY (Don't Repeat Yourself)" msgstr "DRY (반복하지 말라)" #: src/SUMMARY.md:154 msgid "DSL (Domain Specific Languages)" msgstr "DSL (도메인 특화 언어)" #: src/SUMMARY.md:155 msgid "Variadics" msgstr "가변 인자" #: src/SUMMARY.md:157 src/error.md:1 msgid "Error handling" msgstr "에러 핸들링" #: src/SUMMARY.md:158 src/error/panic.md:1 msgid "`panic`" msgstr "`panic`" #: src/SUMMARY.md:159 msgid "`abort` & `unwind`" msgstr "`abort`와 `unwind`" #: src/SUMMARY.md:160 src/error/option_unwrap.md:1 msgid "`Option` & `unwrap`" msgstr "`Option`과 `unwrap`" #: src/SUMMARY.md:161 src/error/option_unwrap/question_mark.md:1 msgid "Unpacking options with `?`" msgstr "`?`로 옵션 풀기" #: src/SUMMARY.md:162 src/error/option_unwrap/map.md:1 msgid "Combinators: `map`" msgstr "콤비네이터: `map`" #: src/SUMMARY.md:163 src/error/option_unwrap/and_then.md:1 msgid "Combinators: `and_then`" msgstr "콤비네이터: `and_then`" #: src/SUMMARY.md:164 msgid "Defaults: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`" msgstr "기본값: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`" #: src/SUMMARY.md:165 src/SUMMARY.md:183 src/error/result.md:1 #: src/std/result.md:1 msgid "`Result`" msgstr "`Result`" #: src/SUMMARY.md:166 src/error/result/result_map.md:1 msgid "`map` for `Result`" msgstr "`Result`에서의 `map`" #: src/SUMMARY.md:167 src/error/result/result_alias.md:1 msgid "aliases for `Result`" msgstr "`Result`의 별칭" #: src/SUMMARY.md:168 src/error/result/early_returns.md:1 msgid "Early returns" msgstr "조기 리턴" #: src/SUMMARY.md:169 src/error/result/enter_question_mark.md:1 msgid "Introducing `?`" msgstr "`?` 소개" #: src/SUMMARY.md:170 src/error/multiple_error_types.md:1 msgid "Multiple error types" msgstr "여러 에러 타입" #: src/SUMMARY.md:171 src/error/multiple_error_types/option_result.md:1 msgid "Pulling `Result`s out of `Option`s" msgstr "`Option`에서 `Result` 꺼내기" #: src/SUMMARY.md:172 src/error/multiple_error_types/define_error_type.md:1 msgid "Defining an error type" msgstr "에러 타입 정의하기" #: src/SUMMARY.md:173 src/error/multiple_error_types/boxing_errors.md:1 msgid "`Box`ing errors" msgstr "에러 `Box`하기" #: src/SUMMARY.md:174 src/error/multiple_error_types/reenter_question_mark.md:1 msgid "Other uses of `?`" msgstr "`?`의 다른 용도" #: src/SUMMARY.md:175 src/error/multiple_error_types/wrap_error.md:1 msgid "Wrapping errors" msgstr "에러 감싸기" #: src/SUMMARY.md:176 src/error/iter_result.md:1 msgid "Iterating over `Result`s" msgstr "`Result` 반복하기" #: src/SUMMARY.md:178 src/std.md:1 msgid "Std library types" msgstr "표준 라이브러리 타입" #: src/SUMMARY.md:179 src/std/box.md:1 msgid "Box, stack and heap" msgstr "Box, 스택과 힙" #: src/SUMMARY.md:180 src/std/vec.md:1 msgid "Vectors" msgstr "벡터" #: src/SUMMARY.md:181 src/std/str.md:1 msgid "Strings" msgstr "문자열" #: src/SUMMARY.md:182 src/std/option.md:1 msgid "`Option`" msgstr "`Option`" #: src/SUMMARY.md:184 src/std/result/question_mark.md:1 msgid "`?`" msgstr "`?`" #: src/SUMMARY.md:185 src/std/panic.md:1 msgid "`panic!`" msgstr "`panic!`" #: src/SUMMARY.md:186 src/std/hash.md:1 msgid "HashMap" msgstr "해시맵" #: src/SUMMARY.md:187 src/std/hash/alt_key_types.md:1 msgid "Alternate/custom key types" msgstr "대체/사용자 정의 키 타입" #: src/SUMMARY.md:188 src/std/hash/hashset.md:1 msgid "HashSet" msgstr "해시셋" #: src/SUMMARY.md:189 src/std/rc.md:1 msgid "`Rc`" msgstr "`Rc`" #: src/SUMMARY.md:190 msgid "`Arc`" msgstr "`Arc`" #: src/SUMMARY.md:192 src/std_misc.md:1 msgid "Std misc" msgstr "기타 표준 라이브러리" #: src/SUMMARY.md:193 src/std_misc.md:6 src/std_misc/threads.md:1 msgid "Threads" msgstr "스레드" #: src/SUMMARY.md:194 src/std_misc/threads/testcase_mapreduce.md:1 msgid "Testcase: map-reduce" msgstr "테스트케이스: 맵-리듀스" #: src/SUMMARY.md:195 src/std_misc.md:7 src/std_misc/channels.md:1 msgid "Channels" msgstr "채널" #: src/SUMMARY.md:196 src/std_misc/path.md:1 msgid "Path" msgstr "경로" #: src/SUMMARY.md:197 src/std_misc.md:8 src/std_misc/file.md:1 msgid "File I/O" msgstr "파일 입출력" #: src/SUMMARY.md:198 src/std_misc/file/open.md:1 msgid "`open`" msgstr "`open`" #: src/SUMMARY.md:199 src/std_misc/file/create.md:1 msgid "`create`" msgstr "`create`" #: src/SUMMARY.md:200 src/std_misc/file/read_lines.md:1 msgid "`read_lines`" msgstr "`read_lines`" #: src/SUMMARY.md:201 src/std_misc/process.md:1 msgid "Child processes" msgstr "자식 프로세스" #: src/SUMMARY.md:202 src/std_misc/process/pipe.md:1 msgid "Pipes" msgstr "파이프" #: src/SUMMARY.md:203 src/std_misc/process/wait.md:1 msgid "Wait" msgstr "대기" #: src/SUMMARY.md:204 src/std_misc/fs.md:1 msgid "Filesystem Operations" msgstr "파일시스템 연산" #: src/SUMMARY.md:205 src/std_misc/arg.md:1 msgid "Program arguments" msgstr "프로그램 인자" #: src/SUMMARY.md:206 src/std_misc/arg/matching.md:1 msgid "Argument parsing" msgstr "인자 파싱" #: src/SUMMARY.md:207 src/std_misc/ffi.md:1 msgid "Foreign Function Interface" msgstr "외부 함수 인터페이스" #: src/SUMMARY.md:209 src/cargo/test.md:1 src/testing.md:1 msgid "Testing" msgstr "테스트" #: src/SUMMARY.md:210 src/testing/unit_testing.md:1 msgid "Unit testing" msgstr "유닛 테스트" #: src/SUMMARY.md:211 src/testing/doc_testing.md:1 msgid "Documentation testing" msgstr "문서 테스트" #: src/SUMMARY.md:212 src/testing/integration_testing.md:1 msgid "Integration testing" msgstr "통합 테스트" #: src/SUMMARY.md:213 msgid "Dev-dependencies" msgstr "개발 의존성" #: src/SUMMARY.md:215 src/unsafe.md:1 msgid "Unsafe Operations" msgstr "Unsafe 연산" #: src/SUMMARY.md:216 src/unsafe/asm.md:1 msgid "Inline assembly" msgstr "인라인 어셈블리" #: src/SUMMARY.md:218 src/compatibility.md:1 msgid "Compatibility" msgstr "호환성" #: src/SUMMARY.md:219 src/compatibility/raw_identifiers.md:1 msgid "Raw identifiers" msgstr "Raw 식별자" #: src/SUMMARY.md:221 src/meta.md:1 msgid "Meta" msgstr "메타" #: src/SUMMARY.md:222 src/meta/doc.md:1 msgid "Documentation" msgstr "문서화" #: src/SUMMARY.md:223 src/meta/playground.md:1 msgid "Playground" msgstr "플레이그라운드" #: src/index.md:1 msgid "Rust by Example" msgstr "Rust by Example" #: src/index.md:3 msgid "" "[Rust](https://www.rust-lang.org/) is a modern systems programming language " "focusing on safety, speed, and concurrency. It accomplishes these goals by " "being memory safe without using garbage collection." msgstr "" "[Rust](https://www.rust-lang.org/)는 안전성, 속도, 동시성에 중점을 둔 현대적" "인 시스템 프로그래밍 언어입니다. 가비지 컬렉션을 사용하지 않고도 메모리 안전" "성을 확보하여 이러한 목표를 달성합니다." #: src/index.md:7 msgid "" "Rust by Example (RBE) is a collection of runnable examples that illustrate " "various Rust concepts and standard libraries. To get even more out of these " "examples, don't forget to [install Rust locally](https://www.rust-lang.org/" "tools/install) and check out the [official docs](https://doc.rust-lang.org/" "std/). Additionally for the curious, you can also [check out the source code " "for this site](https://github.com/rust-lang/rust-by-example)." msgstr "" "Rust by Example (RBE)는 다양한 Rust 개념과 표준 라이브러리를 보여주는 실행 가" "능한 예제 모음입니다. 이러한 예제를 더 잘 활용하려면 [Rust를 로컬에 설치]" "(https://www.rust-lang.org/tools/install)하고 [공식 문서](https://doc.rust-" "lang.org/std/)를 확인해 보세요. 또한 궁금하신 분들은 [이 사이트의 소스 코드]" "(https://github.com/rust-lang/rust-by-example)도 확인하실 수 있습니다." #: src/index.md:12 msgid "Now let's begin!" msgstr "자, 이제 시작해 봅시다!" #: src/index.md:14 msgid "[Hello World](hello.md) - Start with a traditional Hello World program." msgstr "" "[Hello World](hello.md) - 전통적인 Hello World 프로그램으로 시작합니다." #: src/index.md:16 msgid "" "[Primitives](primitives.md) - Learn about signed integers, unsigned integers " "and other primitives." msgstr "" "[기본 자료형](primitives.md) - 부호 있는 정수, 부호 없는 정수 및 기타 기본 자" "료형에 대해 배웁니다." #: src/index.md:18 msgid "[Custom Types](custom_types.md) - `struct` and `enum`." msgstr "[사용자 정의 타입](custom_types.md) - `struct`와 `enum`." #: src/index.md:20 msgid "" "[Variable Bindings](variable_bindings.md) - mutable bindings, scope, " "shadowing." msgstr "[변수 바인딩](variable_bindings.md) - 가변 바인딩, 스코프, 섀도잉." #: src/index.md:22 msgid "[Types](types.md) - Learn about changing and defining types." msgstr "[타입](types.md) - 타입을 변경하고 정의하는 법을 배웁니다." #: src/index.md:24 msgid "" "[Conversion](conversion.md) - Convert between different types, such as " "strings, integers, and floats." msgstr "" "[타입 변환](conversion.md) - 문자열, 정수, 부동 소수점 등 서로 다른 타입 간" "의 변환에 대해 배웁니다." #: src/index.md:26 msgid "" "[Expressions](expression.md) - Learn about Expressions & how to use them." msgstr "[표현식](expression.md) - 표현식과 그 사용법에 대해 배웁니다." #: src/index.md:28 msgid "[Flow of Control](flow_control.md) - `if`/`else`, `for`, and others." msgstr "[제어 흐름](flow_control.md) - `if`/`else`, `for` 등을 배웁니다." #: src/index.md:30 msgid "" "[Functions](fn.md) - Learn about Methods, Closures and Higher Order " "Functions." msgstr "[함수](fn.md) - 메서드, 클로저, 고차 함수에 대해 배웁니다." #: src/index.md:32 msgid "[Modules](mod.md) - Organize code using modules" msgstr "[모듈](mod.md) - 모듈을 사용하여 코드를 구성합니다." #: src/index.md:34 msgid "" "[Crates](crates.md) - A crate is a compilation unit in Rust. Learn to create " "a library." msgstr "" "[크레이트](crates.md) - 크레이트는 Rust의 컴파일 단위입니다. 라이브러리를 만" "드는 법을 배웁니다." #: src/index.md:36 msgid "" "[Cargo](cargo.md) - Go through some basic features of the official Rust " "package management tool." msgstr "" "[Cargo](cargo.md) - Rust 공식 패키지 관리 도구의 기본적인 기능을 살펴봅니다." #: src/index.md:38 msgid "" "[Attributes](attribute.md) - An attribute is metadata applied to some " "module, crate or item." msgstr "" "[속성](attribute.md) - 속성은 모듈, 크레이트 또는 아이템에 적용되는 메타데이" "터입니다." #: src/index.md:40 msgid "" "[Generics](generics.md) - Learn about writing a function or data type which " "can work for multiple types of arguments." msgstr "" "[제네릭](generics.md) - 다양한 타입의 인자에 대해 작동할 수 있는 함수나 데이" "터 타입을 작성하는 법을 배웁니다." #: src/index.md:42 msgid "" "[Scoping rules](scope.md) - Scopes play an important part in ownership, " "borrowing, and lifetimes." msgstr "" "[스코프 규칙](scope.md) - 스코프는 소유권, 빌림, 라이프타임에서 중요한 역할" "을 합니다." #: src/index.md:44 msgid "" "[Traits](trait.md) - A trait is a collection of methods defined for an " "unknown type: `Self`" msgstr "" "[트레이트](trait.md) - 트레이트는 알 수 없는 타입 `Self`에 대해 정의된 메서" "드 모음입니다." #: src/index.md:46 msgid "" "[Macros](macros.md) - Macros are a way of writing code that writes other " "code, which is known as metaprogramming." msgstr "" "[매크로](macros.md) - 매크로는 다른 코드를 작성하는 코드를 작성하는 방법으" "로, 메타프로그래밍이라고도 합니다." #: src/index.md:48 msgid "[Error handling](error.md) - Learn Rust way of handling failures." msgstr "[에러 핸들링](error.md) - 실패를 처리하는 Rust의 방식을 배웁니다." #: src/index.md:50 msgid "" "[Std library types](std.md) - Learn about some custom types provided by " "`std` library." msgstr "" "[표준 라이브러리 타입](std.md) - `std` 라이브러리에서 제공하는 몇 가지 사용" "자 정의 타입에 대해 배웁니다." #: src/index.md:52 msgid "[Std misc](std_misc.md) - More custom types for file handling, threads." msgstr "" "[기타 표준 라이브러리](std_misc.md) - 파일 처리, 스레드 등을 위한 추가적인 사" "용자 정의 타입을 배웁니다." #: src/index.md:54 msgid "[Testing](testing.md) - All sorts of testing in Rust." msgstr "[테스트](testing.md) - Rust에서의 다양한 테스트 방식을 배웁니다." #: src/index.md:56 msgid "" "[Unsafe Operations](unsafe.md) - Learn about entering a block of unsafe " "operations." msgstr "[Unsafe 연산](unsafe.md) - Unsafe 연산 블록에 진입하는 법을 배웁니다." #: src/index.md:58 msgid "" "[Compatibility](compatibility.md) - Handling Rust's evolution and potential " "compatibility issues." msgstr "" "[호환성](compatibility.md) - Rust의 발전과 잠재적인 호환성 문제를 처리하는 법" "을 배웁니다." #: src/index.md:60 msgid "[Meta](meta.md) - Documentation, Benchmarking." msgstr "[메타](meta.md) - 문서화, 벤치마킹." #: src/hello.md:3 msgid "This is the source code of the traditional Hello World program." msgstr "전통적인 Hello World 프로그램의 소스 코드입니다." #: src/hello.md:6 msgid "" "// This is a comment, and is ignored by the compiler.\n" "// You can test this code by clicking the \"Run\" button over there ->\n" "// or if you prefer to use your keyboard, you can use the \"Ctrl + Enter\"\n" "// shortcut.\n" msgstr "" "// 이것은 주석이며, 컴파일러에 의해 무시됩니다.\n" "// 오른쪽에 있는 \"Run\" 버튼을 클릭하거나,\n" "// 키보드를 사용하고 싶다면 \"Ctrl + Enter\" 단축키를 사용하여\n" "// 이 코드를 테스트해 볼 수 있습니다.\n" #: src/hello.md:10 msgid "" "// This code is editable, feel free to hack it!\n" "// You can always return to the original code by clicking the \"Reset\" " "button ->\n" msgstr "" "// 이 코드는 수정 가능하므로, 자유롭게 고쳐보세요!\n" "// \"Reset\" 버튼을 클릭하면 언제든지 원래 코드로 되돌릴 수 있습니다 ->\n" #: src/hello.md:13 msgid "// This is the main function.\n" msgstr "// 메인 함수입니다.\n" #: src/hello.md:16 msgid "// Statements here are executed when the compiled binary is called.\n" msgstr "// 여기에 있는 문장들은 컴파일된 바이너리가 호출될 때 실행됩니다.\n" #: src/hello.md:18 msgid "// Print text to the console.\n" msgstr "// 콘솔에 텍스트를 출력합니다.\n" #: src/hello.md:19 src/error/result.md:55 src/meta/playground.md:12 msgid "\"Hello World!\"" msgstr "\"Hello World!\"" #: src/hello.md:23 msgid "`println!` is a [_macro_](macros.md) that prints text to the console." msgstr "`println!`은 콘솔에 텍스트를 출력하는 [_매크로_](macros.md)입니다." #: src/hello.md:26 msgid "A binary can be generated using the Rust compiler: `rustc`." msgstr "Rust 컴파일러인 `rustc`를 사용하여 바이너리를 생성할 수 있습니다." #: src/hello.md:32 msgid "`rustc` will produce a `hello` binary that can be executed." msgstr "`rustc`는 실행 가능한 `hello` 바이너리를 생성합니다." #: src/hello.md:39 src/hello/print/print_display.md:107 #: src/hello/print/print_display/testcase_list.md:53 src/hello/print/fmt.md:70 #: src/primitives/tuples.md:64 src/custom_types/structs.md:89 msgid "Activity" msgstr "실습" #: src/hello.md:41 msgid "" "Click 'Run' above to see the expected output. Next, add a new line with a " "second `println!` macro so that the output shows:" msgstr "" "위의 'Run'을 클릭하여 예상 출력을 확인하세요. 그런 다음, 두 번째 `println!` " "매크로를 사용하여 다음과 같은 출력이 나오도록 새로운 라인을 추가하세요." #: src/hello/comment.md:3 msgid "" "Any program requires comments, and Rust supports a few different varieties:" msgstr "" "어떤 프로그램이든 주석이 필요하며, Rust는 몇 가지 다른 종류를 지원합니다." #: src/hello/comment.md:6 msgid "Regular Comments" msgstr "일반 주석" #: src/hello/comment.md:8 msgid "These are ignored by the compiler:" msgstr "이것들은 컴파일러에 의해 무시됩니다:" #: src/hello/comment.md:10 msgid "**Line comments**: Start with `//` and continue to the end of the line" msgstr "**라인 주석**: `//`로 시작하여 줄의 끝까지 이어집니다." #: src/hello/comment.md:11 msgid "**Block comments**: Enclosed in `/* ... */` and can span multiple lines" msgstr "**블록 주석**: `/* ... */`로 감싸여 여러 줄에 걸쳐 있을 수 있습니다." #: src/hello/comment.md:13 msgid "" "Documentation Comments (Doc Comments) which are parsed into HTML library " "[documentation](../meta/doc.md):" msgstr "" "HTML 라이브러리 [문서](../meta/doc.md)로 파싱되는 문서화 주석 (Doc Comments):" #: src/hello/comment.md:15 msgid "`///` - Generates docs for the item that follows it" msgstr "`///` - 다음에 오는 아이템에 대한 문서를 생성합니다." #: src/hello/comment.md:16 msgid "" "`//!` - Generates docs for the enclosing item (typically used at the top of " "a file or module)" msgstr "" "`//!` - 해당 아이템을 포함하는 아이템(주로 파일이나 모듈의 상단에서 사용됨)" "에 대한 문서를 생성합니다." #: src/hello/comment.md:20 msgid "" "// Line comments start with two slashes.\n" " // Everything after the slashes is ignored by the compiler.\n" msgstr "" "// 라인 주석은 두 개의 슬래시로 시작합니다.\n" " // 슬래시 이후의 모든 내용은 컴파일러에 의해 무시됩니다.\n" #: src/hello/comment.md:23 msgid "" "// Example: This line won't execute\n" " // println!(\"Hello, world!\");\n" msgstr "" "// 예시: 이 줄은 실행되지 않습니다\n" " // println!(\"Hello, world!\");\n" #: src/hello/comment.md:26 msgid "// Try removing the slashes above and running the code again.\n" msgstr "// 위의 슬래시를 제거하고 코드를 다시 실행해 보세요.\n" #: src/hello/comment.md:28 msgid "" "/*\n" " * Block comments are useful for temporarily disabling code.\n" " * They can also be nested: /* like this */ which makes it easy\n" " * to comment out large sections quickly.\n" " */" msgstr "" "/*\n" " * 블록 주석은 코드를 일시적으로 비활성화하는 데 유용합니다.\n" " * 블록 주석은 중첩될 수도 있습니다: /* 이와 같이 */ 중첩이 가능하여\n" " * 큰 섹션을 빠르게 주석 처리하기 쉽습니다.\n" " */" #: src/hello/comment.md:34 msgid "" "/*\n" " Note: The asterisk column on the left is just for style - \n" " it's not required by the language.\n" " */" msgstr "" "/*\n" " 참고: 왼쪽의 별표 기둥은 단지 스타일을 위한 것입니다 - \n" " 언어적으로 요구되는 사항은 아닙니다.\n" " */" #: src/hello/comment.md:39 msgid "" "// Block comments make it easy to toggle code on/off by adding\n" " // or removing just one slash:\n" msgstr "" "// 블록 주석은 슬래시 하나를 추가하거나 제거하여\n" " // 코드를 켜고 끄기 쉽게 만들어 줍니다:\n" #: src/hello/comment.md:42 msgid "" "/* <- Add a '/' here to uncomment the entire block below\n" "\n" " println!(\"Now\");\n" " println!(\"everything\");\n" " println!(\"executes!\");\n" " // Line comments inside remain unaffected\n" "\n" " // */" msgstr "" "/* <- 여기에 '/'를 추가하면 아래 블록 전체의 주석이 해제됩니다\n" "\n" " println!(\"이제\");\n" " println!(\"모든 것이\");\n" " println!(\"실행됩니다!\");\n" " // 내부의 라인 주석은 영향을 받지 않습니다\n" "\n" " // */" #: src/hello/comment.md:51 msgid "// Block comments can also be used within expressions:\n" msgstr "// 블록 주석은 표현식 내에서도 사용될 수 있습니다:\n" #: src/hello/comment.md:52 msgid "/* 90 + */" msgstr "/* 90 + */" #: src/hello/comment.md:53 msgid "\"Is `x` 10 or 100? x = {}\"" msgstr "\"`x`는 10인가요 100인가요? x = {}\"" #: src/hello/comment.md:57 src/hello/print.md:103 #: src/hello/print/print_debug.md:75 src/hello/print/print_display.md:128 #: src/hello/print/print_display/testcase_list.md:62 src/hello/print/fmt.md:94 #: src/primitives.md:64 src/custom_types/enum.md:100 #: src/custom_types/enum/enum_use.md:45 src/custom_types/enum/c_like.md:33 #: src/custom_types/enum/testcase_linked_list.md:78 #: src/custom_types/constants.md:35 src/types/alias.md:30 #: src/flow_control/for.md:121 src/flow_control/match/destructuring.md:17 #: src/flow_control/match/destructuring/destructure_tuple.md:25 #: src/flow_control/match/destructuring/destructure_slice.md:46 #: src/flow_control/match/destructuring/destructure_enum.md:48 #: src/flow_control/match/destructuring/destructure_pointers.md:63 #: src/flow_control/match/destructuring/destructure_structures.md:45 #: src/flow_control/match/guard.md:43 src/flow_control/match/binding.md:63 #: src/flow_control/if_let.md:118 src/flow_control/let_else.md:55 #: src/flow_control/while_let.md:56 src/fn/closures/capture.md:110 #: src/fn/closures/input_parameters.md:84 src/fn/closures/anonymity.md:47 #: src/fn/closures/input_functions.md:32 #: src/fn/closures/output_parameters.md:49 #: src/fn/closures/closure_examples/iter_any.md:51 #: src/fn/closures/closure_examples/iter_find.md:71 #: src/mod/struct_visibility.md:53 src/attribute/cfg.md:39 src/generics.md:59 #: src/generics/gen_fn.md:54 src/generics/impl.md:48 #: src/generics/gen_trait.md:39 src/generics/bounds.md:73 #: src/generics/bounds/testcase_empty.md:37 src/generics/multi_bounds.md:32 #: src/generics/where.md:49 src/generics/new_types.md:54 #: src/generics/assoc_items.md:10 src/generics/assoc_items/the_problem.md:62 #: src/generics/phantom.md:56 src/generics/phantom/testcase_units.md:75 #: src/scope/raii.md:92 src/scope/move/partial_move.md:57 #: src/scope/borrow/mut.md:56 src/scope/lifetime/explicit.md:68 #: src/scope/lifetime/fn.md:58 src/scope/lifetime/methods.md:24 #: src/scope/lifetime/struct.md:41 src/scope/lifetime/trait.md:28 #: src/scope/lifetime/lifetime_bounds.md:46 #: src/scope/lifetime/static_lifetime.md:133 src/scope/lifetime/elision.md:39 #: src/trait/derive.md:65 src/trait/supertraits.md:40 #: src/trait/disambiguating.md:60 src/error/option_unwrap/map.md:79 #: src/error/option_unwrap/and_then.md:73 #: src/error/option_unwrap/defaults.md:115 src/error/result/result_alias.md:41 #: src/error/multiple_error_types/boxing_errors.md:57 #: src/error/multiple_error_types/reenter_question_mark.md:74 #: src/error/multiple_error_types/wrap_error.md:91 src/std.md:12 #: src/std/rc.md:55 src/std_misc.md:12 #: src/std_misc/threads/testcase_mapreduce.md:127 src/std_misc/path.md:52 #: src/std_misc/fs.md:149 src/meta/doc.md:109 src/meta/playground.md:49 msgid "See also:" msgstr "참고:" #: src/hello/comment.md:59 msgid "[Library documentation](../meta/doc.md)" msgstr "[라이브러리 문서](../meta/doc.md)" #: src/hello/print.md:3 msgid "" "Printing is handled by a series of [`macros`](../macros.md) defined in " "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) some of which are:" msgstr "" "출력은 [`std::fmt`](https://doc.rust-lang.org/std/fmt/)에 정의된 일련의 [`매" "크로`](../macros.md)들에 의해 처리되며, 그 중 몇 가지는 다음과 같습니다:" #: src/hello/print.md:6 msgid "`format!`: write formatted text to [`String`](../std/str.md)" msgstr "`format!`: 형식화된 텍스트를 [`String`](../std/str.md)에 씁니다." #: src/hello/print.md:7 msgid "" "`print!`: same as `format!` but the text is printed to the console " "(io::stdout)." msgstr "`print!`: `format!`과 같지만 텍스트가 콘솔(io::stdout)에 출력됩니다." #: src/hello/print.md:9 msgid "`println!`: same as `print!` but a newline is appended." msgstr "`println!`: `print!`와 같지만 줄바꿈 문자가 추가됩니다." #: src/hello/print.md:10 msgid "" "`eprint!`: same as `print!` but the text is printed to the standard error " "(io::stderr)." msgstr "" "`eprint!`: `print!`와 같지만 텍스트가 표준 에러(io::stderr)로 출력됩니다." #: src/hello/print.md:12 msgid "`eprintln!`: same as `eprint!` but a newline is appended." msgstr "`eprintln!`: `eprint!`와 같지만 줄바꿈 문자가 추가됩니다." #: src/hello/print.md:14 msgid "" "All parse text in the same fashion. As a plus, Rust checks formatting " "correctness at compile time." msgstr "" "모두 같은 방식으로 텍스트를 파싱합니다. 추가로, Rust는 컴파일 타임에 형식화" "의 올바름을 검사합니다." #: src/hello/print.md:19 msgid "" "// In general, the `{}` will be automatically replaced with any\n" " // arguments. These will be stringified.\n" msgstr "" "// 일반적으로 `{}`는 어떤 인자로든 자동으로 교체됩니다.\n" " // 이들은 문자열화될 것입니다.\n" #: src/hello/print.md:21 msgid "\"{} days\"" msgstr "\"{}일\"" #: src/hello/print.md:23 msgid "" "// Positional arguments can be used. Specifying an integer inside `{}`\n" " // determines which additional argument will be replaced. Arguments " "start\n" " // at 0 immediately after the format string.\n" msgstr "" "// 위치 인자를 사용할 수 있습니다. `{}` 안에 정수를 지정하면\n" " // 어떤 추가 인자가 교체될지 결정합니다. 인자는 형식 문자열\n" " // 바로 뒤에서 0부터 시작합니다.\n" #: src/hello/print.md:26 msgid "\"{0}, this is {1}. {1}, this is {0}\"" msgstr "\"{0}, 여기는 {1}입니다. {1}, 여기는 {0}입니다.\"" #: src/hello/print.md:26 src/scope/move/partial_move.md:31 msgid "\"Alice\"" msgstr "\"앨리스\"" #: src/hello/print.md:26 src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Bob\"" msgstr "\"밥\"" #: src/hello/print.md:28 msgid "// As can named arguments.\n" msgstr "// 이름을 지정한 인자(named arguments)도 사용할 수 있습니다.\n" #: src/hello/print.md:29 msgid "\"{subject} {verb} {object}\"" msgstr "\"{subject} {verb} {object}\"" #: src/hello/print.md:30 msgid "\"the lazy dog\"" msgstr "\"게으른 개\"" #: src/hello/print.md:31 msgid "\"the quick brown fox\"" msgstr "\"빠른 갈색 여우\"" #: src/hello/print.md:32 msgid "\"jumps over\"" msgstr "\"넘어 뛰어넘다\"" #: src/hello/print.md:34 msgid "" "// Different formatting can be invoked by specifying the format character\n" " // after a `:`.\n" msgstr "// `:` 뒤에 형식 문자를 지정하여 다양한 형식화를 수행할 수 있습니다.\n" #: src/hello/print.md:36 msgid "\"Base 10: {}\"" msgstr "\"10진수: {}\"" #: src/hello/print.md:36 msgid "// 69420\n" msgstr "// 69420\n" #: src/hello/print.md:37 msgid "\"Base 2 (binary): {:b}\"" msgstr "\"2진수: {:b}\"" #: src/hello/print.md:37 msgid "// 10000111100101100\n" msgstr "// 10000111100101100\n" #: src/hello/print.md:38 msgid "\"Base 8 (octal): {:o}\"" msgstr "\"8진수: {:o}\"" #: src/hello/print.md:38 msgid "// 207454\n" msgstr "// 207454\n" #: src/hello/print.md:39 msgid "\"Base 16 (hexadecimal): {:x}\"" msgstr "\"16진수: {:x}\"" #: src/hello/print.md:39 msgid "// 10f2c\n" msgstr "// 10f2c\n" #: src/hello/print.md:41 msgid "" "// You can right-justify text with a specified width. This will\n" " // output \" 1\". (Four white spaces and a \"1\", for a total width " "of 5.)\n" msgstr "" "// 지정된 너비로 텍스트를 오른쪽 정렬할 수 있습니다. 이 예시는\n" " // \" 1\"을 출력할 것입니다. (공백 4개와 \"1\" 하나로 총 너비 5가 됩니" "다.)\n" #: src/hello/print.md:43 msgid "\"{number:>5}\"" msgstr "\"{number:>5}\"" #: src/hello/print.md:45 msgid "// You can pad numbers with extra zeroes,\n" msgstr "// 숫자를 0으로 채울 수도 있습니다,\n" #: src/hello/print.md:46 msgid "\"{number:0>5}\"" msgstr "\"{number:0>5}\"" #: src/hello/print.md:46 msgid "" "// 00001\n" " // and left-adjust by flipping the sign. This will output \"10000\".\n" msgstr "" "// 00001\n" " // 그리고 부호를 뒤집어 왼쪽 정렬할 수 있습니다. 이것은 \"10000\"을 출력" "합니다.\n" #: src/hello/print.md:48 msgid "\"{number:0<5}\"" msgstr "\"{number:0<5}\"" #: src/hello/print.md:48 msgid "// 10000\n" msgstr "// 10000\n" #: src/hello/print.md:50 msgid "" "// You can use named arguments in the format specifier by appending a `$`.\n" msgstr "" "// 형식 지정자(format specifier)에 `$`를 붙여 명명된 인자를 사용할 수 있습니" "다.\n" #: src/hello/print.md:51 msgid "\"{number:0>width$}\"" msgstr "\"{number:0>width$}\"" #: src/hello/print.md:53 msgid "" "// Rust even checks to make sure the correct number of arguments are used.\n" msgstr "// Rust는 올바른 개수의 인자가 사용되었는지도 확인합니다.\n" #: src/hello/print.md:54 msgid "\"My name is {0}, {1} {0}\"" msgstr "\"제 이름은 {0}, {1} {0}입니다.\"" #: src/hello/print.md:54 msgid "\"Bond\"" msgstr "\"본드\"" #: src/hello/print.md:55 msgid "// FIXME ^ Add the missing argument: \"James\"\n" msgstr "// FIXME ^ 누락된 인자를 추가하세요: \"제임스\"\n" #: src/hello/print.md:57 msgid "" "// Only types that implement fmt::Display can be formatted with `{}`. User-\n" " // defined types do not implement fmt::Display by default.\n" msgstr "" "// fmt::Display를 구현하는 타입만 `{}`로 형식화할 수 있습니다. 사용자\n" " // 정의 타입은 기본적으로 fmt::Display를 구현하지 않습니다.\n" #: src/hello/print.md:60 msgid "// disable `dead_code` which warn against unused module\n" msgstr "// 사용되지 않는 모듈에 대한 경고인 `dead_code`를 비활성화합니다\n" #: src/hello/print.md:63 msgid "" "// This will not compile because `Structure` does not implement\n" " // fmt::Display.\n" " // println!(\"This struct `{}` won't print...\", Structure(3));\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// `Structure`가 fmt::Display를 구현하지 않으므로 컴파일되지 않습니다.\n" " // println!(\"이 구조체 `{}`는 출력되지 않습니다...\", Structure(3));\n" " // TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/hello/print.md:68 msgid "" "// For Rust 1.58 and above, you can directly capture the argument from a\n" " // surrounding variable. Just like the above, this will output\n" " // \" 1\", 4 white spaces and a \"1\".\n" msgstr "" "// Rust 1.58 이상에서는 주변 변수에서 직접 인자를 캡처할 수 있습니다.\n" " // 위와 마찬가지로, 이것은 \" 1\"(공백 4개와 \"1\")을 출력합니다.\n" #: src/hello/print.md:73 msgid "\"{number:>width$}\"" msgstr "\"{number:>width$}\"" #: src/hello/print.md:77 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) contains many [`traits`]" "(https://doc.rust-lang.org/std/fmt/#formatting-traits) which govern the " "display of text. The base form of two important ones are listed below:" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)에는 텍스트 표시를 제어하는 " "많은 [`트레이트`](https://doc.rust-lang.org/std/fmt/#formatting-traits)가 포" "함되어 있습니다. 그 중 중요한 두 가지의 기본 형태는 다음과 같습니다:" #: src/hello/print.md:80 msgid "" "`fmt::Debug`: Uses the `{:?}` marker. Format text for debugging purposes." msgstr "" "`fmt::Debug`: `{:?}` 마커를 사용합니다. 디버깅 목적으로 텍스트 형식을 지정합" "니다." #: src/hello/print.md:81 msgid "" "`fmt::Display`: Uses the `{}` marker. Format text in a more elegant, user " "friendly fashion." msgstr "" "`fmt::Display`: `{}` 마커를 사용합니다. 보다 우아하고 사용자 친화적인 방식으" "로 텍스트 형식을 지정합니다." #: src/hello/print.md:84 msgid "" "Here, we used `fmt::Display` because the std library provides " "implementations for these types. To print text for custom types, more steps " "are required." msgstr "" "여기서는 표준 라이브러리가 이러한 타입들에 대한 구현을 제공하기 때문에 " "`fmt::Display`를 사용했습니다. 커스텀 타입에 대해 텍스트를 출력하려면 더 많" "은 단계가 필요합니다." #: src/hello/print.md:87 msgid "" "Implementing the `fmt::Display` trait automatically implements the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "which allows us to [convert](../conversion/string.md) the type to [`String`]" "(../std/str.md)." msgstr "" "`fmt::Display` 트레이트를 구현하면 타입을 [`String`](../std/str.md)으로 [변" "환](../conversion/string.md)할 수 있게 해주는 [`ToString`](https://doc.rust-" "lang.org/std/string/trait.ToString.html) 트레이트가 자동으로 구현됩니다." #: src/hello/print.md:90 msgid "" "In _line 43_, `#[allow(dead_code)]` is an [attribute](../attribute.md) which " "only applies to the module after it." msgstr "" "_43행_의 `#[allow(dead_code)]`는 그 뒤에 오는 모듈에만 적용되는 [속성](../" "attribute.md)입니다." #: src/hello/print.md:92 msgid "Activities" msgstr "실습" #: src/hello/print.md:94 msgid "" "Fix the issue in the above code (see FIXME) so that it runs without error." msgstr "위 코드의 문제(FIXME 참고)를 수정하여 에러 없이 실행되도록 하세요." #: src/hello/print.md:96 msgid "" "Try uncommenting the line that attempts to format the `Structure` struct " "(see TODO)" msgstr "" "`Structure` 구조체를 형식화하려는 줄의 주석을 제거해 보세요 (TODO 참고)." #: src/hello/print.md:98 msgid "" "Add a `println!` macro call that prints: `Pi is roughly 3.142` by " "controlling the number of decimal places shown. For the purposes of this " "exercise, use `let pi = 3.141592` as an estimate for pi. (Hint: you may need " "to check the [`std::fmt`](https://doc.rust-lang.org/std/fmt/) documentation " "for setting the number of decimals to display)" msgstr "" "표시되는 소수점 자릿수를 제어하여 `Pi is roughly 3.142`를 출력하는 `println!" "` 매크로 호출을 추가하세요. 이 연습을 위해 파이의 근사값으로 `let pi = " "3.141592`를 사용하세요. (힌트: 표시할 소수점 자릿수를 설정하는 방법은 " "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) 문서를 확인해야 할 수도 있습" "니다.)" #: src/hello/print.md:105 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`macros`](../macros.md), " "[`struct`](../custom_types/structs.md), [`traits`](https://doc.rust-lang.org/" "std/fmt/#formatting-traits), and [`dead_code`](../attribute/unused.md)" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`매크로`](../macros.md), " "[`구조체`](../custom_types/structs.md), [`트레이트`](https://doc.rust-" "lang.org/std/fmt/#formatting-traits), 그리고 [`dead_code`](../attribute/" "unused.md)" #: src/hello/print/print_debug.md:3 msgid "" "All types which want to use `std::fmt` formatting `traits` require an " "implementation to be printable. Automatic implementations are only provided " "for types such as in the `std` library. All others _must_ be manually " "implemented somehow." msgstr "" "`std::fmt` 형식화 `트레이트`를 사용하려는 모든 타입은 출력 가능하도록 구현이 " "필요합니다. 자동 구현은 `std` 라이브러리와 같은 타입들에 대해서만 제공됩니" "다. 그 외의 모든 타입은 어떻게든 수동으로 구현_해야만_ 합니다." #: src/hello/print/print_debug.md:8 msgid "" "The `fmt::Debug` `trait` makes this very straightforward. _All_ types can " "`derive` (automatically create) the `fmt::Debug` implementation. This is not " "true for `fmt::Display` which must be manually implemented." msgstr "" "`fmt::Debug` `트레이트`는 이를 매우 간단하게 만들어 줍니다. _모든_ 타입은 " "`fmt::Debug` 구현을 `derive`(자동 생성)할 수 있습니다. 하지만 `fmt::Display`" "는 그렇지 않으며 수동으로 구현해야 합니다." #: src/hello/print/print_debug.md:13 msgid "" "// This structure cannot be printed either with `fmt::Display` or\n" "// with `fmt::Debug`.\n" msgstr "" "// 이 구조체는 `fmt::Display`나 `fmt::Debug` 중 어느 것으로도\n" "// 출력할 수 없습니다.\n" #: src/hello/print/print_debug.md:16 msgid "" "// The `derive` attribute automatically creates the implementation\n" "// required to make this `struct` printable with `fmt::Debug`.\n" msgstr "" "// `derive` 속성은 이 `구조체`를 `fmt::Debug`로 출력 가능하게 만드는 데\n" "// 필요한 구현을 자동으로 생성합니다.\n" #: src/hello/print/print_debug.md:23 msgid "All `std` library types are automatically printable with `{:?}` too:" msgstr "모든 `std` 라이브러리 타입들도 `{:?}`로 자동 출력이 가능합니다:" #: src/hello/print/print_debug.md:26 msgid "" "// Derive the `fmt::Debug` implementation for `Structure`. `Structure`\n" "// is a structure which contains a single `i32`.\n" msgstr "" "// `Structure`에 대해 `fmt::Debug` 구현을 유도(derive)합니다. `Structure`는\n" "// 단일 `i32`를 포함하는 구조체입니다.\n" #: src/hello/print/print_debug.md:30 msgid "" "// Put a `Structure` inside of the structure `Deep`. Make it printable\n" "// also.\n" msgstr "" "// `Deep` 구조체 안에 `Structure`를 넣으세요. 그리고 역시 출력 가능하게 만드" "세요.\n" #: src/hello/print/print_debug.md:37 msgid "// Printing with `{:?}` is similar to with `{}`.\n" msgstr "// `{:?}`를 이용한 출력은 `{}`와 유사합니다.\n" #: src/hello/print/print_debug.md:38 msgid "\"{:?} months in a year.\"" msgstr "\"1년은 {:?}개월입니다.\"" #: src/hello/print/print_debug.md:39 msgid "\"{1:?} {0:?} is the {actor:?} name.\"" msgstr "\"{1:?} {0:?}은 {actor:?}의 이름입니다.\"" #: src/hello/print/print_debug.md:40 msgid "\"Slater\"" msgstr "\"슬레이터\"" #: src/hello/print/print_debug.md:41 msgid "\"Christian\"" msgstr "\"크리스찬\"" #: src/hello/print/print_debug.md:42 msgid "\"actor's\"" msgstr "\"배우의\"" #: src/hello/print/print_debug.md:44 msgid "// `Structure` is printable!\n" msgstr "// `Structure`는 출력 가능합니다!\n" #: src/hello/print/print_debug.md:45 src/hello/print/print_debug.md:49 msgid "\"Now {:?} will print!\"" msgstr "\"이제 {:?}가 출력될 것입니다!\"" #: src/hello/print/print_debug.md:47 msgid "" "// The problem with `derive` is there is no control over how\n" " // the results look. What if I want this to just show a `7`?\n" msgstr "" "// `derive`의 문제점은 결과가 어떻게 보일지 제어할 수 없다는 것입니다.\n" " // 만약 이것을 단지 `7`로 보여주고 싶다면 어떡하죠?\n" #: src/hello/print/print_debug.md:53 msgid "" "So `fmt::Debug` definitely makes this printable but sacrifices some " "elegance. Rust also provides \"pretty printing\" with `{:#?}`." msgstr "" "따라서 `fmt::Debug`는 확실히 출력을 가능하게 하지만 우아함을 어느 정도 희생합" "니다. Rust는 `{:#?}`를 사용한 \"예쁘게 출력하기(pretty printing)\"도 제공합니" "다." #: src/hello/print/print_debug.md:64 src/custom_types/structs.md:42 msgid "\"Peter\"" msgstr "\"피터\"" #: src/hello/print/print_debug.md:68 msgid "// Pretty print\n" msgstr "// 예쁘게 출력하기\n" #: src/hello/print/print_debug.md:69 msgid "\"{:#?}\"" msgstr "\"{:#?}\"" #: src/hello/print/print_debug.md:73 msgid "One can manually implement `fmt::Display` to control the display." msgstr "`fmt::Display`를 수동으로 구현하여 출력을 제어할 수 있습니다." #: src/hello/print/print_debug.md:77 msgid "" "[`attributes`](https://doc.rust-lang.org/reference/attributes.html), " "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), and [`struct`](../../custom_types/structs.md)" msgstr "" "[`속성`](https://doc.rust-lang.org/reference/attributes.html), [`derive`]" "(../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/std/fmt/), 그" "리고 [`구조체`](../../custom_types/structs.md)" #: src/hello/print/print_display.md:3 msgid "" "`fmt::Debug` hardly looks compact and clean, so it is often advantageous to " "customize the output appearance. This is done by manually implementing " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/), which uses the `{}` " "print marker. Implementing it looks like this:" msgstr "" "`fmt::Debug`는 콤팩트하고 깔끔해 보이지 않으므로, 출력 모양을 커스터마이징하" "는 것이 종종 유리합니다. 이는 `{}` 출력 마커를 사용하는 [`fmt::Display`]" "(https://doc.rust-lang.org/std/fmt/)를 수동으로 구현함으로써 수행됩니다. 구현" "은 다음과 같습니다:" #: src/hello/print/print_display.md:9 msgid "// Import (via `use`) the `fmt` module to make it available.\n" msgstr "// `fmt` 모듈을 (`use`를 통해) 가져와서 사용할 수 있게 합니다.\n" #: src/hello/print/print_display.md:11 msgid "" "// Define a structure for which `fmt::Display` will be implemented. This is\n" "// a tuple struct named `Structure` that contains an `i32`.\n" msgstr "" "// `fmt::Display`를 구현할 구조체를 정의합니다. 이것은\n" "// `i32`를 포함하는 `Structure`라는 이름의 튜플 구조체입니다.\n" #: src/hello/print/print_display.md:15 msgid "" "// To use the `{}` marker, the trait `fmt::Display` must be implemented\n" "// manually for the type.\n" msgstr "" "// `{}` 마커를 사용하려면, `fmt::Display` 트레이트가 해당 타입에 대해\n" "// 수동으로 구현되어야 합니다.\n" #: src/hello/print/print_display.md:19 msgid "// This trait requires `fmt` with this exact signature.\n" msgstr "// 이 트레이트는 정확히 이 시그니처를 가진 `fmt`를 요구합니다.\n" #: src/hello/print/print_display.md:21 msgid "" "// Write strictly the first element into the supplied output\n" " // stream: `f`. Returns `fmt::Result` which indicates whether the\n" " // operation succeeded or failed. Note that `write!` uses syntax " "which\n" " // is very similar to `println!`.\n" msgstr "" "// 제공된 출력 스트림 `f`에 첫 번째 요소를 씁니다.\n" " // 작업의 성공 또는 실패 여부를 나타내는 `fmt::Result`를 반환합니" "다.\n" " // `write!`는 `println!`과 매우 유사한 구문을 사용한다는 점에 유의하" "세요.\n" #: src/hello/print/print_display.md:25 #: src/hello/print/print_display/testcase_list.md:13 #: src/hello/print/print_display/testcase_list.md:39 #: src/hello/print/print_display/testcase_list.md:49 src/hello/print/fmt.md:53 #: src/custom_types/enum/testcase_linked_list.md:74 src/conversion/string.md:25 #: src/flow_control/loop.md:26 src/flow_control/while.md:21 #: src/flow_control/for.md:23 src/flow_control/for.md:43 src/fn.md:40 #: src/fn/closures/capture.md:96 src/fn/closures/capture.md:97 #: src/fn/closures/anonymity.md:41 src/generics/bounds.md:12 #: src/macros/repeat.md:24 src/macros/repeat.md:25 src/macros/repeat.md:26 #: src/error/result.md:73 src/std/str.md:92 src/std/str.md:102 #: src/std/str.md:106 src/std/str.md:111 src/std/result.md:72 #: src/std/result/question_mark.md:57 src/std/result/question_mark.md:65 #: src/std_misc/file/read_lines.md:60 src/std_misc/arg/matching.md:9 #: src/std_misc/arg/matching.md:13 msgid "\"{}\"" msgstr "\"{}\"" #: src/hello/print/print_display.md:30 msgid "" "`fmt::Display` may be cleaner than `fmt::Debug` but this presents a problem " "for the `std` library. How should ambiguous types be displayed? For example, " "if the `std` library implemented a single style for all `Vec`, what style " "should it be? Would it be either of these two?" msgstr "" "`fmt::Display`가 `fmt::Debug`보다 깔끔할 수 있지만, 이는 `std` 라이브러리에 " "문제를 제기합니다. 모호한 타입들은 어떻게 표시되어야 할까요? 예를 들어, " "`std` 라이브러리가 모든 `Vec`에 대해 단일 스타일을 구현했다면, 어떤 스타일" "이어야 할까요? 다음 두 가지 중 하나일까요?" #: src/hello/print/print_display.md:35 msgid "`Vec`: `/:/etc:/home/username:/bin` (split on `:`)" msgstr "`Vec`: `/:/etc:/home/username:/bin` (`:`로 구분)" #: src/hello/print/print_display.md:36 msgid "`Vec`: `1,2,3` (split on `,`)" msgstr "`Vec`: `1,2,3` (`,`로 구분)" #: src/hello/print/print_display.md:38 msgid "" "No, because there is no ideal style for all types and the `std` library " "doesn't presume to dictate one. `fmt::Display` is not implemented for " "`Vec` or for any other generic containers. `fmt::Debug` must then be used " "for these generic cases." msgstr "" "아니요, 모든 타입에 이상적인 스타일은 없으며 `std` 라이브러리가 하나를 독단적" "으로 정하지 않기 때문입니다. `fmt::Display`는 `Vec`나 다른 제네릭 컨테이너" "에 대해 구현되어 있지 않습니다. 따라서 이러한 제네릭 케이스에는 `fmt::Debug`" "를 사용해야 합니다." #: src/hello/print/print_display.md:43 msgid "" "This is not a problem though because for any new _container_ type which is " "_not_ generic, `fmt::Display` can be implemented." msgstr "" "하지만 제네릭이 _아닌_ 새로운 _컨테이너_ 타입에 대해서는 `fmt::Display`를 구" "현할 수 있으므로 이는 문제가 되지 않습니다." #: src/hello/print/print_display.md:47 msgid "// Import `fmt`\n" msgstr "// `fmt` 가져오기\n" #: src/hello/print/print_display.md:48 msgid "" "// A structure holding two numbers. `Debug` will be derived so the results " "can\n" "// be contrasted with `Display`.\n" msgstr "" "// 두 숫자를 보유하는 구조체입니다. `Display`와 대조해 볼 수 있도록\n" "// `Debug`를 유도(derive)할 것입니다.\n" #: src/hello/print/print_display.md:53 msgid "// Implement `Display` for `MinMax`.\n" msgstr "// `MinMax`에 대해 `Display`를 구현합니다.\n" #: src/hello/print/print_display.md:57 msgid "// Use `self.number` to refer to each positional data point.\n" msgstr "// 각 위치별 데이터 지점을 참조하기 위해 `self.number`를 사용합니다.\n" #: src/hello/print/print_display.md:58 msgid "\"({}, {})\"" msgstr "\"({}, {})\"" #: src/hello/print/print_display.md:61 msgid "// Define a structure where the fields are nameable for comparison.\n" msgstr "// 비교를 위해 필드에 이름을 붙일 수 있는 구조체를 정의합니다.\n" #: src/hello/print/print_display.md:68 msgid "// Similarly, implement `Display` for `Point2D`.\n" msgstr "// 마찬가지로, `Point2D`에 대해 `Display`를 구현합니다.\n" #: src/hello/print/print_display.md:72 msgid "// Customize so only `x` and `y` are denoted.\n" msgstr "// `x`와 `y`만 표시되도록 커스터마이징합니다.\n" #: src/hello/print/print_display.md:73 msgid "\"x: {}, y: {}\"" msgstr "\"x: {}, y: {}\"" #: src/hello/print/print_display.md:80 msgid "\"Compare structures:\"" msgstr "\"구조체 비교:\"" #: src/hello/print/print_display.md:81 src/hello/print/print_display.md:94 msgid "\"Display: {}\"" msgstr "\"디스플레이: {}\"" #: src/hello/print/print_display.md:82 src/hello/print/print_display.md:95 msgid "\"Debug: {:?}\"" msgstr "\"디버그: {:?}\"" #: src/hello/print/print_display.md:87 msgid "\"The big range is {big} and the small is {small}\"" msgstr "\"큰 범위는 {big}이고 작은 범위는 {small}입니다.\"" #: src/hello/print/print_display.md:93 msgid "\"Compare points:\"" msgstr "\"좌표 비교:\"" #: src/hello/print/print_display.md:97 msgid "" "// Error. Both `Debug` and `Display` were implemented, but `{:b}`\n" " // requires `fmt::Binary` to be implemented. This will not work.\n" " // println!(\"What does Point2D look like in binary: {:b}?\", point);\n" msgstr "" "// 에러. `Debug`와 `Display`는 모두 구현되었지만, `{:b}`는\n" " // `fmt::Binary` 구현을 요구합니다. 이것은 작동하지 않을 것입니다.\n" " // println!(\"Point2D의 2진수 형태는 무엇일까요: {:b}?\", point);\n" #: src/hello/print/print_display.md:103 msgid "" "So, `fmt::Display` has been implemented but `fmt::Binary` has not, and " "therefore cannot be used. `std::fmt` has many such [`traits`](https://" "doc.rust-lang.org/std/fmt/#formatting-traits) and each requires its own " "implementation. This is detailed further in [`std::fmt`](https://doc.rust-" "lang.org/std/fmt/)." msgstr "" "따라서, `fmt::Display`는 구현되었지만 `fmt::Binary`는 구현되지 않았으므로 사" "용할 수 없습니다. `std::fmt`에는 이와 같은 많은 [`트레이트`](https://" "doc.rust-lang.org/std/fmt/#formatting-traits)가 있으며 각각은 자체적인 구현" "을 요구합니다. 이에 대한 자세한 내용은 [`std::fmt`](https://doc.rust-" "lang.org/std/fmt/)에 나와 있습니다." #: src/hello/print/print_display.md:109 msgid "" "After checking the output of the above example, use the `Point2D` struct as " "a guide to add a `Complex` struct to the example. When printed in the same " "way, the output should be:" msgstr "" "위 예제의 출력을 확인한 후, `Point2D` 구조체를 가이드로 삼아 예제에 " "`Complex` 구조체를 추가해 보세요. 같은 방식으로 출력했을 때의 결과는 다음과 " "같아야 합니다:" #: src/hello/print/print_display.md:121 msgid "Bonus: Add a space before the `+`/`-` signs." msgstr "보너스: `+`/`-` 기호 앞에 공백을 추가하세요." #: src/hello/print/print_display.md:123 msgid "Hints in case you get stuck:" msgstr "막혔을 때를 위한 힌트:" #: src/hello/print/print_display.md:125 msgid "" "Check the documentation for [`Sign/#/0`](https://doc.rust-lang.org/std/fmt/" "#sign0) in `std::fmt`." msgstr "" "`std::fmt`에서 [`Sign/#/0`](https://doc.rust-lang.org/std/fmt/#sign0)에 대한 " "문서를 확인하세요." #: src/hello/print/print_display.md:126 msgid "" "Bonus: Check [`if`\\-`else`](../../flow_control/if_else.md) branching and " "the [`abs`](https://doc.rust-lang.org/std/primitive.f64.html#method.abs) " "function." msgstr "" "보너스: [`if`\\-`else`](../../flow_control/if_else.md) 분기와 [`abs`]" "(https://doc.rust-lang.org/std/primitive.f64.html#method.abs) 함수를 확인하세" "요." #: src/hello/print/print_display.md:130 msgid "" "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [`macros`](../../macros.md), [`struct`](../../custom_types/" "structs.md), [`trait`](https://doc.rust-lang.org/std/fmt/#formatting-" "traits), and [`use`](../../mod/use.md)" msgstr "" "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [`매크로`](../../macros.md), [`구조체`](../../custom_types/" "structs.md), [`트레이트`](https://doc.rust-lang.org/std/fmt/#formatting-" "traits), 그리고 [`use`](../../mod/use.md)" #: src/hello/print/print_display/testcase_list.md:3 msgid "" "Implementing `fmt::Display` for a structure where the elements must each be " "handled sequentially is tricky. The problem is that each `write!` generates " "a `fmt::Result`. Proper handling of this requires dealing with _all_ the " "results. Rust provides the `?` operator for exactly this purpose." msgstr "" "각 요소를 순차적으로 처리해야 하는 구조체에 대해 `fmt::Display`를 구현하는 것" "은 까다롭습니다. 문제는 각 `write!`가 `fmt::Result`를 생성한다는 것입니다. 이" "를 적절히 처리하려면 _모든_ 결과를 다뤄야 합니다. Rust는 정확히 이 목적을 위" "해 `?` 연산자를 제공합니다." #: src/hello/print/print_display/testcase_list.md:8 msgid "Using `?` on `write!` looks like this:" msgstr "`write!`에 `?`를 사용하는 것은 다음과 같습니다:" #: src/hello/print/print_display/testcase_list.md:11 msgid "" "// Try `write!` to see if it errors. If it errors, return\n" "// the error. Otherwise continue.\n" msgstr "" "// `write!`가 에러를 발생시키는지 확인합니다. 에러가 발생하면\n" "// 에러를 반환합니다. 그렇지 않으면 계속 진행합니다.\n" #: src/hello/print/print_display/testcase_list.md:16 msgid "" "With `?` available, implementing `fmt::Display` for a `Vec` is " "straightforward:" msgstr "`?`가 사용 가능해지면 `Vec`에 대한 `fmt::Display` 구현은 간단해집니다:" #: src/hello/print/print_display/testcase_list.md:20 msgid "// Import the `fmt` module.\n" msgstr "// `fmt` 모듈을 가져옵니다.\n" #: src/hello/print/print_display/testcase_list.md:21 msgid "// Define a structure named `List` containing a `Vec`.\n" msgstr "// `Vec`을 포함하는 `List`라는 이름의 구조체를 정의합니다.\n" #: src/hello/print/print_display/testcase_list.md:27 msgid "" "// Extract the value using tuple indexing,\n" " // and create a reference to `vec`.\n" msgstr "" "// 튜플 인덱싱을 사용하여 값을 추출하고,\n" " // `vec`에 대한 참조를 생성합니다.\n" #: src/hello/print/print_display/testcase_list.md:31 msgid "\"[\"" msgstr "\"[\"" #: src/hello/print/print_display/testcase_list.md:33 msgid "" "// Iterate over `v` in `vec` while enumerating the iteration\n" " // index in `index`.\n" msgstr "// `vec`의 `v`를 순회하면서 반복 인덱스를 `index`에 열거합니다.\n" #: src/hello/print/print_display/testcase_list.md:36 msgid "" "// For every element except the first, add a comma.\n" " // Use the ? operator to return on errors.\n" msgstr "" "// 첫 번째를 제외한 모든 요소에 콤마를 추가합니다.\n" " // 에러 시 반환하기 위해 ? 연산자를 사용합니다.\n" #: src/hello/print/print_display/testcase_list.md:38 src/std/str.md:36 msgid "\", \"" msgstr "\", \"" #: src/hello/print/print_display/testcase_list.md:42 msgid "// Close the opened bracket and return a fmt::Result value.\n" msgstr "// 열려 있는 대괄호를 닫고 `fmt::Result` 값을 반환합니다.\n" #: src/hello/print/print_display/testcase_list.md:43 msgid "\"]\"" msgstr "\"]\"" #: src/hello/print/print_display/testcase_list.md:55 msgid "" "Try changing the program so that the index of each element in the vector is " "also printed. The new output should look like this:" msgstr "" "벡터의 각 요소의 인덱스도 출력되도록 프로그램을 변경해 보세요. 새로운 출력은 " "다음과 같아야 합니다:" #: src/hello/print/print_display/testcase_list.md:64 msgid "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/" "ref.md), [`Result`](../../../std/result.md), [`struct`](../../../" "custom_types/structs.md), [`?`](../../../std/result/question_mark.md), and " "[`vec!`](../../../std/vec.md)" msgstr "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/" "ref.md), [`Result`](../../../std/result.md), [`구조체`](../../../" "custom_types/structs.md), [`?`](../../../std/result/question_mark.md), 그리" "고 [`vec!`](../../../std/vec.md)" #: src/hello/print/fmt.md:3 msgid "We've seen that formatting is specified via a _format string_:" msgstr "형식화는 _형식 문자열_을 통해 지정되는 것을 보았습니다:" #: src/hello/print/fmt.md:5 msgid "`format!(\"{}\", foo)` -> `\"3735928559\"`" msgstr "`format!(\"{}\", foo)` -> `\"3735928559\"`" #: src/hello/print/fmt.md:6 msgid "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" msgstr "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" #: src/hello/print/fmt.md:7 msgid "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" msgstr "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" #: src/hello/print/fmt.md:9 msgid "" "The same variable (`foo`) can be formatted differently depending on which " "_argument type_ is used: `X` vs `o` vs _unspecified_." msgstr "" "동일한 변수(`foo`)라도 `X`, `o` 또는 _지정되지 않음_과 같이 어떤 _인자 타입_" "이 사용되느냐에 따라 다르게 형식화될 수 있습니다." #: src/hello/print/fmt.md:12 msgid "" "This formatting functionality is implemented via traits, and there is one " "trait for each argument type. The most common formatting trait is `Display`, " "which handles cases where the argument type is left unspecified: `{}` for " "instance." msgstr "" "이 형식화 기능은 트레이트를 통해 구현되며, 각 인자 타입에 대해 하나의 트레이" "트가 존재합니다. 가장 일반적인 형식화 트레이트는 `Display`이며, 인자 타입이 " "지정되지 않은 경우(예: `{}`)를 처리합니다." #: src/hello/print/fmt.md:21 msgid "// Latitude\n" msgstr "// 위도\n" #: src/hello/print/fmt.md:23 msgid "// Longitude\n" msgstr "// 경도\n" #: src/hello/print/fmt.md:28 msgid "" "// `f` is a buffer, and this method must write the formatted string into " "it.\n" msgstr "// `f`는 버퍼이며, 이 메서드는 버퍼에 형식화된 문자열을 써야 합니다.\n" #: src/hello/print/fmt.md:30 msgid "'N'" msgstr "'북'" #: src/hello/print/fmt.md:30 msgid "'S'" msgstr "'남'" #: src/hello/print/fmt.md:31 msgid "'E'" msgstr "'동'" #: src/hello/print/fmt.md:31 msgid "'W'" msgstr "'서'" #: src/hello/print/fmt.md:33 msgid "" "// `write!` is like `format!`, but it will write the formatted string\n" " // into a buffer (the first argument).\n" msgstr "" "// `write!`는 `format!`과 비슷하지만, 형식화된 문자열을\n" " // 버퍼(첫 번째 인자)에 씁니다.\n" #: src/hello/print/fmt.md:35 msgid "\"{}: {:.3}°{} {:.3}°{}\"" msgstr "\"{}: {:.3}°{} {:.3}°{}\"" #: src/hello/print/fmt.md:49 msgid "\"Dublin\"" msgstr "\"더블린\"" #: src/hello/print/fmt.md:50 msgid "\"Oslo\"" msgstr "\"오슬로\"" #: src/hello/print/fmt.md:51 msgid "\"Vancouver\"" msgstr "\"밴쿠버\"" #: src/hello/print/fmt.md:60 msgid "" "// Switch this to use {} once you've added an implementation\n" " // for fmt::Display.\n" msgstr "// fmt::Display 구현을 추가한 후에는 {}를 사용하도록 변경하세요.\n" #: src/hello/print/fmt.md:62 src/primitives/tuples.md:60 #: src/custom_types/structs.md:47 src/types/inference.md:23 #: src/conversion/string.md:76 src/generics/bounds.md:49 #: src/generics/where.md:38 src/std/str.md:137 src/std/result.md:59 #: src/std/result.md:61 src/std/result.md:63 src/std/arc.md:26 #: src/std_misc/channels.md:53 msgid "\"{:?}\"" msgstr "\"{:?}\"" #: src/hello/print/fmt.md:67 msgid "" "You can view a [full list of formatting traits](https://doc.rust-lang.org/" "std/fmt/#formatting-traits) and their argument types in the [`std::fmt`]" "(https://doc.rust-lang.org/std/fmt/) documentation." msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) 문서에서 [형식화 트레이트 전" "체 목록](https://doc.rust-lang.org/std/fmt/#formatting-traits)과 해당 인자 타" "입을 확인할 수 있습니다." #: src/hello/print/fmt.md:72 msgid "" "Add an implementation of the `fmt::Display` trait for the `Color` struct " "above so that the output displays as:" msgstr "" "위의 `Color` 구조체에 `fmt::Display` 트레이트 구현을 추가하여 다음과 같이 출" "력되도록 하세요:" #: src/hello/print/fmt.md:81 msgid "Two hints if you get stuck:" msgstr "막혔을 때를 위한 두 가지 힌트:" #: src/hello/print/fmt.md:83 msgid "" "You [may need to list each color more than once](https://doc.rust-lang.org/" "std/fmt/#named-parameters)." msgstr "" "[각 색상을 두 번 이상 나열해야 할 수도 있습니다](https://doc.rust-lang.org/" "std/fmt/#named-parameters)." #: src/hello/print/fmt.md:84 msgid "" "You can [pad with zeros to a width of 2](https://doc.rust-lang.org/std/fmt/" "#width) with `:0>2`. For hexadecimals, you can use `:02X`." msgstr "" "`:0>2`를 사용하여 [0을 채워 너비를 2로 맞출](https://doc.rust-lang.org/std/" "fmt/#width) 수 있습니다. 16진수의 경우 `:02X`를 사용할 수 있습니다." #: src/hello/print/fmt.md:87 msgid "Bonus:" msgstr "보너스:" #: src/hello/print/fmt.md:89 msgid "" "If you would like to experiment with [type casting](../../types/cast.md) in " "advance, the formula for [calculating a color in the RGB color space]" "(https://www.rapidtables.com/web/color/RGB_Color.html#rgb-format) is `RGB = " "(R * 65_536) + (G * 256) + B`, where `R is RED, G is GREEN, and B is BLUE`. " "An unsigned 8-bit integer (`u8`) can only hold numbers up to 255. To cast " "`u8` to `u32`, you can write `variable_name as u32`." msgstr "" "[타입 변환(type casting)](../../types/cast.md)을 미리 실험해보고 싶다면, " "[RGB 색 공간에서 색상을 계산하는 공식](https://www.rapidtables.com/web/color/" "RGB_Color.html#rgb-format)은 `RGB = (R * 65_536) + (G * 256) + B`이며, 여기" "서 `R은 RED, G는 GREEN, B는 BLUE`입니다. 부호 없는 8비트 정수(`u8`)는 255까지" "의 숫자만 담을 수 있습니다. `u8`을 `u32`로 변환하려면 `variable_name as u32`" "와 같이 쓸 수 있습니다." #: src/hello/print/fmt.md:96 msgid "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" msgstr "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" #: src/primitives.md:3 msgid "" "Rust provides access to a wide variety of `primitives`. A sample includes:" msgstr "" "Rust는 다양한 `기본 자료형(primitives)`에 대한 접근을 제공합니다. 샘플은 다음" "과 같습니다:" #: src/primitives.md:5 msgid "Scalar Types" msgstr "스칼라 타입" #: src/primitives.md:7 msgid "" "Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size)" msgstr "" "부호 있는 정수: `i8`, `i16`, `i32`, `i64`, `i128` 및 `isize` (포인터 크기)" #: src/primitives.md:8 msgid "" "Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer " "size)" msgstr "" "부호 없는 정수: `u8`, `u16`, `u32`, `u64`, `u128` 및 `usize` (포인터 크기)" #: src/primitives.md:10 msgid "Floating point: `f32`, `f64`" msgstr "부동 소수점: `f32`, `f64`" #: src/primitives.md:11 msgid "`char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each)" msgstr "`char` 유니코드 스칼라 값: `'a'`, `'α'`, `'∞'` 등 (각 4바이트)" #: src/primitives.md:12 msgid "`bool` either `true` or `false`" msgstr "`bool`: `true` 또는 `false`" #: src/primitives.md:13 msgid "The unit type `()`, whose only possible value is an empty tuple: `()`" msgstr "유닛 타입 `()`: 가능한 유일한 값은 빈 튜플 `()`입니다." #: src/primitives.md:15 msgid "" "Despite the value of a unit type being a tuple, it is not considered a " "compound type because it does not contain multiple values." msgstr "" "유닛 타입의 값이 튜플임에도 불구하고, 여러 값을 포함하지 않기 때문에 복합 타" "입(compound type)으로 간주되지 않습니다." #: src/primitives.md:18 msgid "Compound Types" msgstr "복합 타입" #: src/primitives.md:20 msgid "Arrays like `[1, 2, 3]`" msgstr "`[1, 2, 3]`과 같은 배열" #: src/primitives.md:21 msgid "Tuples like `(1, true)`" msgstr "`(1, true)`와 같은 튜플" #: src/primitives.md:23 msgid "" "Variables can always be _type annotated_. Numbers may additionally be " "annotated via a _suffix_ or _by default_. Integers default to `i32` and " "floats to `f64`. Note that Rust can also infer types from context." msgstr "" "변수는 항상 _타입 어노테이션_이 가능합니다. 숫자는 추가적으로 _접미사" "(suffix)_를 통하거나 _기본값_으로 어노테이션될 수 있습니다. 정수 기본값은 " "`i32`이고 부동 소수점 기본값은 `f64`입니다. 또한 Rust는 문맥으로부터 타입을 " "추론할 수도 있습니다." #: src/primitives.md:29 msgid "// Variables can be type annotated.\n" msgstr "// 변수는 타입 어노테이션이 가능합니다.\n" #: src/primitives.md:32 msgid "// Regular annotation\n" msgstr "// 일반적인 어노테이션\n" #: src/primitives.md:33 msgid "// Suffix annotation\n" msgstr "// 접미사 어노테이션\n" #: src/primitives.md:35 msgid "// Or a default will be used.\n" msgstr "// 혹은 기본값이 사용됩니다.\n" #: src/primitives.md:36 msgid "// `f64`\n" msgstr "// `f64`\n" #: src/primitives.md:37 msgid "// `i32`\n" msgstr "// `i32`\n" #: src/primitives.md:39 msgid "// A type can also be inferred from context.\n" msgstr "// 타입을 문맥에서 추론할 수도 있습니다.\n" #: src/primitives.md:40 msgid "// Type i64 is inferred from another line.\n" msgstr "// i64 타입이 다른 줄에서 추론됩니다.\n" #: src/primitives.md:43 msgid "// A mutable variable's value can be changed.\n" msgstr "// 가변 변수의 값은 변경될 수 있습니다.\n" #: src/primitives.md:44 msgid "// Mutable `i32`\n" msgstr "// 가변 `i32`\n" #: src/primitives.md:47 msgid "// Error! The type of a variable can't be changed.\n" msgstr "// 에러! 변수의 타입은 변경할 수 없습니다.\n" #: src/primitives.md:50 msgid "// Variables can be overwritten with shadowing.\n" msgstr "// 변수는 섀도잉(shadowing)을 통해 덮어쓸 수 있습니다.\n" #: src/primitives.md:53 msgid "/* Compound types - Array and Tuple */" msgstr "/* 복합 타입 - 배열과 튜플 */" #: src/primitives.md:55 msgid "// Array signature consists of Type T and length as [T; length].\n" msgstr "// 배열 시그니처는 타입 T와 길이를 포함하여 [T; length] 형식입니다.\n" #: src/primitives.md:58 msgid "" "// Tuple is a collection of values of different types\n" " // and is constructed using parentheses ().\n" msgstr "" "// 튜플은 서로 다른 타입의 값들을 모아놓은 것이며\n" " // 소괄호 ()를 사용하여 구성됩니다.\n" #: src/primitives.md:66 msgid "" "[the `std` library](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [`inference`](types/inference.md), and " "[`shadowing`](variable_bindings/scope.md)" msgstr "" "[`std` 라이브러리](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [`추론(inference)`](types/inference.md), 그리고 " "[`섀도잉(shadowing)`](variable_bindings/scope.md)" #: src/primitives/literals.md:3 msgid "" "Integers `1`, floats `1.2`, characters `'a'`, strings `\"abc\"`, booleans " "`true` and the unit type `()` can be expressed using literals." msgstr "" "정수 `1`, 부동 소수점 `1.2`, 문자 `'a'`, 문자열 `\"abc\"`, 불리언 `true` 그리" "고 유닛 타입 `()`은 리터럴을 사용하여 표현할 수 있습니다." #: src/primitives/literals.md:6 msgid "" "Integers can, alternatively, be expressed using hexadecimal, octal or binary " "notation using these prefixes respectively: `0x`, `0o` or `0b`." msgstr "" "정수는 또한 `0x`, `0o`, `0b` 접두사를 사용하여 각각 16진수, 8진수, 2진수 표기" "법으로 표현할 수 있습니다." #: src/primitives/literals.md:9 msgid "" "Underscores can be inserted in numeric literals to improve readability, e.g. " "`1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`." msgstr "" "가독성을 높이기 위해 숫자 리터럴에 언더스코어(_)를 삽입할 수 있습니다. 예를 " "들어 `1_000`은 `1000`과 같고, `0.000_001`은 `0.000001`과 같습니다." #: src/primitives/literals.md:12 msgid "" "Rust also supports scientific [E-notation](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. The associated type " "is `f64`." msgstr "" "Rust는 또한 과학적 기수법([E-표기법](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation))을 지원합니다. (예: `1e6`, `7.6e-4`). 관련 타" "입은 `f64`입니다." #: src/primitives/literals.md:15 msgid "" "We need to tell the compiler the type of the literals we use. For now, we'll " "use the `u32` suffix to indicate that the literal is an unsigned 32-bit " "integer, and the `i32` suffix to indicate that it's a signed 32-bit integer." msgstr "" "우리는 사용하는 리터럴의 타입을 컴파일러에게 알려주어야 합니다. 당분간은 부" "호 없는 32비트 정수임을 나타내기 위해 `u32` 접미사를 사용하고, 부호 있는 32비" "트 정수임을 나타내기 위해 `i32` 접미사를 사용할 것입니다." #: src/primitives/literals.md:19 msgid "" "The operators available and their precedence [in Rust](https://doc.rust-" "lang.org/reference/expressions.html#expression-precedence) are similar to " "other [C-like languages](https://en.wikipedia.org/wiki/" "Operator_precedence#Programming_languages)." msgstr "" "[Rust에서의](https://doc.rust-lang.org/reference/expressions.html#expression-" "precedence) 사용 가능한 연산자와 우선순위는 다른 [C 계열 언어들](https://" "en.wikipedia.org/wiki/Operator_precedence#Programming_languages)과 유사합니" "다." #: src/primitives/literals.md:24 msgid "// Integer addition\n" msgstr "// 정수 덧셈\n" #: src/primitives/literals.md:25 msgid "\"1 + 2 = {}\"" msgstr "\"1 + 2 = {}\"" #: src/primitives/literals.md:27 msgid "// Integer subtraction\n" msgstr "// 정수 뺄셈\n" #: src/primitives/literals.md:28 msgid "\"1 - 2 = {}\"" msgstr "\"1 - 2 = {}\"" #: src/primitives/literals.md:29 msgid "" "// TODO ^ Try changing `1i32` to `1u32` to see why the type is important\n" msgstr "" "// TODO ^ `1i32`를 `1u32`로 변경하여 타입이 중요한 이유를 확인해 보세요\n" #: src/primitives/literals.md:31 msgid "// Scientific notation\n" msgstr "// 과학적 표기법\n" #: src/primitives/literals.md:32 msgid "\"1e4 is {}, -2.5e-3 is {}\"" msgstr "\"1e4는 {}, -2.5e-3은 {}입니다\"" #: src/primitives/literals.md:34 msgid "// Short-circuiting boolean logic\n" msgstr "// 단락(Short-circuiting) 불리언 로직\n" #: src/primitives/literals.md:35 msgid "\"true AND false is {}\"" msgstr "\"true AND false는 {}입니다\"" #: src/primitives/literals.md:36 msgid "\"true OR false is {}\"" msgstr "\"true OR false는 {}입니다\"" #: src/primitives/literals.md:37 msgid "\"NOT true is {}\"" msgstr "\"NOT true는 {}입니다\"" #: src/primitives/literals.md:39 msgid "// Bitwise operations\n" msgstr "// 비트 연산\n" #: src/primitives/literals.md:40 msgid "\"0011 AND 0101 is {:04b}\"" msgstr "\"0011 AND 0101은 {:04b}입니다\"" #: src/primitives/literals.md:41 msgid "\"0011 OR 0101 is {:04b}\"" msgstr "\"0011 OR 0101은 {:04b}입니다\"" #: src/primitives/literals.md:42 msgid "\"0011 XOR 0101 is {:04b}\"" msgstr "\"0011 XOR 0101은 {:04b}입니다\"" #: src/primitives/literals.md:43 msgid "\"1 << 5 is {}\"" msgstr "\"1 << 5는 {}입니다\"" #: src/primitives/literals.md:44 msgid "\"0x80 >> 2 is 0x{:x}\"" msgstr "\"0x80 >> 2는 0x{:x}입니다\"" #: src/primitives/literals.md:46 msgid "// Use underscores to improve readability!\n" msgstr "// 가독성을 높이기 위해 밑줄을 사용하세요!\n" #: src/primitives/literals.md:47 msgid "\"One million is written as {}\"" msgstr "\"백만은 {}로 씁니다\"" #: src/primitives/tuples.md:3 msgid "" "A tuple is a collection of values of different types. Tuples are constructed " "using parentheses `()`, and each tuple itself is a value with type signature " "`(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions " "can use tuples to return multiple values, as tuples can hold any number of " "values." msgstr "" "튜플은 서로 다른 타입의 값들의 모음입니다. 튜플은 괄호 `()`를 사용하여 생성되" "며, 각 튜플 자체는 `(T1, T2, ...)` 형태의 타입 시그니처를 가진 값입니다. 여기" "서 `T1`, `T2`는 튜플 멤버의 타입입니다. 튜플은 여러 값을 담을 수 있으므로 함" "수에서 여러 값을 반환하는 데 사용할 수 있습니다." #: src/primitives/tuples.md:9 msgid "// Tuples can be used as function arguments and as return values.\n" msgstr "// 튜플은 함수의 인자와 반환값으로 사용될 수 있습니다.\n" #: src/primitives/tuples.md:11 msgid "// `let` can be used to bind the members of a tuple to variables.\n" msgstr "// `let`을 사용하여 튜플의 멤버를 변수에 바인딩할 수 있습니다.\n" #: src/primitives/tuples.md:16 msgid "// The following struct is for the activity.\n" msgstr "// 다음 구조체는 실습을 위한 것입니다.\n" #: src/primitives/tuples.md:22 msgid "// A tuple with a bunch of different types.\n" msgstr "// 여러 다른 타입을 가진 튜플입니다.\n" #: src/primitives/tuples.md:26 src/generics.md:50 src/generics.md:55 #: src/generics/gen_fn.md:47 msgid "'a'" msgstr "'a'" #: src/primitives/tuples.md:28 msgid "// Values can be extracted from the tuple using tuple indexing.\n" msgstr "// 튜플 인덱싱을 사용하여 튜플에서 값을 추출할 수 있습니다.\n" #: src/primitives/tuples.md:29 msgid "\"Long tuple first value: {}\"" msgstr "\"긴 튜플의 첫 번째 값: {}\"" #: src/primitives/tuples.md:30 msgid "\"Long tuple second value: {}\"" msgstr "\"긴 튜플의 두 번째 값: {}\"" #: src/primitives/tuples.md:32 msgid "// Tuples can be tuple members.\n" msgstr "// 튜플은 튜플의 멤버가 될 수 있습니다.\n" #: src/primitives/tuples.md:35 msgid "// Tuples are printable.\n" msgstr "// 튜플은 출력 가능합니다.\n" #: src/primitives/tuples.md:36 msgid "\"tuple of tuples: {:?}\"" msgstr "\"튜플의 튜플: {:?}\"" #: src/primitives/tuples.md:38 msgid "" "// But long Tuples (more than 12 elements) cannot be printed.\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"Too long tuple: {:?}\", too_long_tuple);\n" " // TODO ^ Uncomment the above 2 lines to see the compiler error\n" msgstr "" "// 하지만 긴 튜플(요소 12개 초과)은 출력할 수 없습니다.\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"Too long tuple: {:?}\", too_long_tuple);\n" " // TODO ^ 위의 두 줄의 주석을 해제하여 컴파일 에러를 확인해 보세요\n" #: src/primitives/tuples.md:44 msgid "\"Pair is {:?}\"" msgstr "\"페어는 {:?}입니다\"" #: src/primitives/tuples.md:46 msgid "\"The reversed pair is {:?}\"" msgstr "\"반전된 페어는 {:?}입니다\"" #: src/primitives/tuples.md:48 msgid "" "// To create one element tuples, the comma is required to tell them apart\n" " // from a literal surrounded by parentheses.\n" msgstr "" "// 요소가 하나인 튜플을 만들려면, 괄호로 둘러싸인 리터럴과\n" " // 구분하기 위해 콤마가 필요합니다.\n" #: src/primitives/tuples.md:50 msgid "\"One element tuple: {:?}\"" msgstr "\"요소가 하나인 튜플: {:?}\"" #: src/primitives/tuples.md:51 msgid "\"Just an integer: {:?}\"" msgstr "\"그냥 정수: {:?}\"" #: src/primitives/tuples.md:53 msgid "// Tuples can be destructured to create bindings.\n" msgstr "// 튜플은 구조 분해(destructure)하여 바인딩을 생성할 수 있습니다.\n" #: src/primitives/tuples.md:54 src/conversion/from_into.md:17 #: src/fn/closures/input_parameters.md:52 src/std_misc/fs.md:51 msgid "\"hello\"" msgstr "\"안녕\"" #: src/primitives/tuples.md:57 msgid "\"{:?}, {:?}, {:?}, {:?}\"" msgstr "\"{:?}, {:?}, {:?}, {:?}\"" #: src/primitives/tuples.md:66 msgid "" "_Recap_: Add the `fmt::Display` trait to the `Matrix` struct in the above " "example, so that if you switch from printing the debug format `{:?}` to the " "display format `{}`, you see the following output:" msgstr "" "_요약_: 위 예제의 `Matrix` 구조체에 `fmt::Display` 트레이트를 추가하여, 디버" "그 형식 `{:?}`에서 디스플레이 형식 `{}`로 출력을 전환했을 때 다음과 같은 출력" "이 나오도록 하세요:" #: src/primitives/tuples.md:75 msgid "" "You may want to refer back to the example for [print display](../hello/print/" "print_display.md)." msgstr "" "[표시 출력](../hello/print/print_display.md)에 대한 예제를 다시 참조하고 싶" "을 수도 있습니다." #: src/primitives/tuples.md:76 msgid "" "Add a `transpose` function using the `reverse` function as a template, which " "accepts a matrix as an argument, and returns a matrix in which two elements " "have been swapped. For example:" msgstr "" "`reverse` 함수를 템플릿으로 사용하여 `transpose` 함수를 추가하세요. 이 함수" "는 행렬을 인자로 받아 두 요소가 바뀐 행렬을 반환합니다. 예를 들어:" #: src/primitives/tuples.md:81 msgid "\"Matrix:\\n{}\"" msgstr "\"행렬:\\n{}\"" #: src/primitives/tuples.md:82 msgid "\"Transpose:\\n{}\"" msgstr "\"전치(Transpose):\\n{}\"" #: src/primitives/tuples.md:85 msgid "Results in the output:" msgstr "출력 결과:" #: src/primitives/array.md:3 msgid "" "An array is a collection of objects of the same type `T`, stored in " "contiguous memory. Arrays are created using brackets `[]`, and their length, " "which is known at compile time, is part of their type signature `[T; " "length]`." msgstr "" "배열은 연속된 메모리에 저장된 동일한 타입 `T`를 가진 객체들의 모음입니다. 배" "열은 대괄호 `[]`를 사용하여 생성되며, 컴파일 타임에 알려진 배열의 길이는 타" "입 시그니처 `[T; length]`의 일부가 됩니다." #: src/primitives/array.md:7 msgid "" "Slices are similar to arrays, but their length is not known at compile time. " "Instead, a slice is a two-word object; the first word is a pointer to the " "data, the second word is the length of the slice. The word size is the same " "as usize, determined by the processor architecture, e.g. 64 bits on an " "x86-64. Slices can be used to borrow a section of an array and have the type " "signature `&[T]`." msgstr "" "슬라이스는 배열과 유사하지만, 컴파일 타임에 그 길이를 알 수 없습니다. 대신, " "슬라이스는 두 개의 워드(word)로 구성된 객체입니다. 첫 번째 워드는 데이터에 대" "한 포인터이고, 두 번째 워드는 슬라이스의 길이입니다. 워드 크기는 프로세서 아" "키텍처에 의해 결정되는 usize와 같으며, 예를 들어 x86-64에서는 64비트입니다. " "슬라이스는 배열의 일부분을 빌려오는 데 사용될 수 있으며 `&[T]`라는 타입 시그" "니처를 가집니다." #: src/primitives/array.md:15 msgid "// This function borrows a slice.\n" msgstr "// 이 함수는 슬라이스를 빌려옵니다.\n" #: src/primitives/array.md:18 msgid "\"First element of the slice: {}\"" msgstr "\"슬라이스의 첫 번째 요소: {}\"" #: src/primitives/array.md:19 msgid "\"The slice has {} elements\"" msgstr "\"슬라이스는 {}개의 요소를 가지고 있습니다\"" #: src/primitives/array.md:23 msgid "// Fixed-size array (type signature is superfluous).\n" msgstr "// 고정 크기 배열 (타입 시그니처는 생략 가능합니다).\n" #: src/primitives/array.md:26 msgid "// All elements can be initialized to the same value.\n" msgstr "// 모든 요소를 동일한 값으로 초기화할 수 있습니다.\n" #: src/primitives/array.md:29 msgid "// Indexing starts at 0.\n" msgstr "// 인덱싱은 0부터 시작합니다.\n" #: src/primitives/array.md:30 msgid "\"First element of the array: {}\"" msgstr "\"배열의 첫 번째 요소: {}\"" #: src/primitives/array.md:31 msgid "\"Second element of the array: {}\"" msgstr "\"배열의 두 번째 요소: {}\"" #: src/primitives/array.md:33 msgid "// `len` returns the count of elements in the array.\n" msgstr "// `len`은 배열의 요소 개수를 반환합니다.\n" #: src/primitives/array.md:34 msgid "\"Number of elements in array: {}\"" msgstr "\"배열의 요소 개수: {}\"" #: src/primitives/array.md:36 msgid "// Arrays are stack allocated.\n" msgstr "// 배열은 스택에 할당됩니다.\n" #: src/primitives/array.md:37 msgid "\"Array occupies {} bytes\"" msgstr "\"배열의 점유 메모리: {} 바이트\"" #: src/primitives/array.md:39 msgid "// Arrays can be automatically borrowed as slices.\n" msgstr "// 배열은 자동으로 슬라이스로 빌려올 수 있습니다.\n" #: src/primitives/array.md:40 msgid "\"Borrow the whole array as a slice.\"" msgstr "\"배열 전체를 슬라이스로 빌려옵니다.\"" #: src/primitives/array.md:43 msgid "" "// Slices can point to a section of an array.\n" " // They are of the form [starting_index..ending_index].\n" " // `starting_index` is the first position in the slice.\n" " // `ending_index` is one more than the last position in the slice.\n" msgstr "" "// 슬라이스는 배열의 한 섹션을 가리킬 수 있습니다.\n" " // [시작_인덱스..종료_인덱스] 형태입니다.\n" " // `시작_인덱스`는 슬라이스의 첫 번째 위치입니다.\n" " // `종료_인덱스`는 슬라이스의 마지막 위치보다 하나 더 큰 값입니다.\n" #: src/primitives/array.md:47 msgid "\"Borrow a section of the array as a slice.\"" msgstr "\"배열의 한 섹션을 슬라이스로 빌려옵니다.\"" #: src/primitives/array.md:50 msgid "// Example of empty slice `&[]`:\n" msgstr "// 빈 슬라이스 `&[]`의 예시:\n" #: src/primitives/array.md:53 msgid "// Same but more verbose\n" msgstr "// 동일하지만 더 장황한 표현\n" #: src/primitives/array.md:55 msgid "" "// Arrays can be safely accessed using `.get`, which returns an\n" " // `Option`. This can be matched as shown below, or used with\n" " // `.expect()` if you would like the program to exit with a nice\n" " // message instead of happily continue.\n" msgstr "" "// 배열은 `.get`을 사용하여 안전하게 접근할 수 있으며, 이는 `Option`을 반환합" "니다.\n" " // 이는 아래와 같이 매치(match)될 수 있으며, 프로그램을 계속 진행하는 대" "신\n" " // 친절한 메시지와 함께 종료하고 싶다면 `.expect()`와 함께 사용될 수 있습" "니다.\n" #: src/primitives/array.md:59 msgid "// Oops, one element too far!\n" msgstr "// 이런, 범위를 하나 벗어났네요!\n" #: src/primitives/array.md:61 msgid "\"{}: {}\"" msgstr "\"{}: {}\"" #: src/primitives/array.md:62 msgid "\"Slow down! {} is too far!\"" msgstr "\"진정하세요! {}는 너무 멀리 갔습니다!\"" #: src/primitives/array.md:66 msgid "" "// Out of bound indexing on array with constant value causes compile time " "error.\n" " //println!(\"{}\", xs[5]);\n" " // Out of bound indexing on slice causes runtime error.\n" " //println!(\"{}\", xs[..][5]);\n" msgstr "" "// 상수 값을 사용한 배열의 범위를 벗어난 인덱싱은 컴파일 타임 에러를 발생시킵" "니다.\n" " //println!(\"{}\", xs[5]);\n" " // 슬라이스에서 범위를 벗어난 인덱싱은 런타임 에러를 발생시킵니다.\n" " //println!(\"{}\", xs[..][5]);\n" #: src/custom_types.md:3 msgid "Rust custom data types are formed mainly through the two keywords:" msgstr "" "Rust의 사용자 정의 데이터 타입은 주로 다음 두 키워드를 통해 형성됩니다:" #: src/custom_types.md:5 msgid "`struct`: define a structure" msgstr "`struct`: 구조체를 정의합니다" #: src/custom_types.md:6 msgid "`enum`: define an enumeration" msgstr "`enum`: 열거형을 정의합니다" #: src/custom_types.md:8 msgid "Constants can also be created via the `const` and `static` keywords." msgstr "상수는 `const`와 `static` 키워드를 통해 생성할 수 있습니다." #: src/custom_types/structs.md:3 msgid "" "There are three types of structures (\"structs\") that can be created using " "the `struct` keyword:" msgstr "" "`struct` 키워드를 사용하여 생성할 수 있는 구조체(\"structs\")에는 세 가지 유" "형이 있습니다:" #: src/custom_types/structs.md:6 msgid "Tuple structs, which are, basically, named tuples." msgstr "기본적으로 이름이 붙은 튜플인 튜플 구조체." #: src/custom_types/structs.md:7 msgid "" "The classic [C structs](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" msgstr "" "전통적인 [C 구조체](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" #: src/custom_types/structs.md:8 msgid "Unit structs, which are field-less, are useful for generics." msgstr "필드가 없는 유닛 구조체로, 제네릭에 유용합니다." #: src/custom_types/structs.md:11 src/custom_types/enum/enum_use.md:6 #: src/custom_types/enum/c_like.md:6 msgid "// An attribute to hide warnings for unused code.\n" msgstr "// 사용되지 않는 코드에 대한 경고를 숨기기 위한 속성입니다.\n" #: src/custom_types/structs.md:19 msgid "// A unit struct\n" msgstr "// 유닛 구조체\n" #: src/custom_types/structs.md:22 msgid "// A tuple struct\n" msgstr "// 튜플 구조체\n" #: src/custom_types/structs.md:25 msgid "// A struct with two fields\n" msgstr "// 두 개의 필드를 가진 구조체\n" #: src/custom_types/structs.md:31 msgid "// Structs can be reused as fields of another struct\n" msgstr "// 구조체는 다른 구조체의 필드로 재사용될 수 있습니다.\n" #: src/custom_types/structs.md:34 msgid "" "// A rectangle can be specified by where the top left and bottom right\n" " // corners are in space.\n" msgstr "" "// 사각형은 공간상에서 왼쪽 위와 오른쪽 아래 모서리의 위치로 지정될 수 있습니" "다.\n" #: src/custom_types/structs.md:41 msgid "// Create struct with field init shorthand\n" msgstr "// 필드 초기화 축약형(field init shorthand)으로 구조체를 생성합니다.\n" #: src/custom_types/structs.md:46 msgid "// Print debug struct\n" msgstr "// 디버그용 구조체 출력\n" #: src/custom_types/structs.md:49 msgid "// Instantiate a `Point`\n" msgstr "// `Point` 인스턴스 생성\n" #: src/custom_types/structs.md:53 msgid "// Access the fields of the point\n" msgstr "// 좌표의 필드에 접근\n" #: src/custom_types/structs.md:54 msgid "\"point coordinates: ({}, {})\"" msgstr "\"좌표 좌표: ({}, {})\"" #: src/custom_types/structs.md:56 msgid "" "// Make a new point by using struct update syntax to use the fields of our\n" " // other one\n" msgstr "" "// 구조체 업데이트 구문을 사용하여 다른 포인트의 필드를 활용해\n" " // 새로운 포인트를 만듭니다.\n" #: src/custom_types/structs.md:60 msgid "" "// `bottom_right.y` will be the same as `another_point.y` because we used " "that field\n" " // from `another_point`\n" msgstr "" "// `another_point`의 필드를 사용했으므로 `bottom_right.y`는 `another_point.y`" "와 동일합니다.\n" #: src/custom_types/structs.md:62 msgid "\"second point: ({}, {})\"" msgstr "\"두 번째 좌표: ({}, {})\"" #: src/custom_types/structs.md:64 msgid "// Destructure the point using a `let` binding\n" msgstr "// `let` 바인딩을 사용하여 좌표를 구조 분해합니다.\n" #: src/custom_types/structs.md:68 msgid "// struct instantiation is an expression too\n" msgstr "// 구조체 인스턴스 생성은 표현식이기도 합니다.\n" #: src/custom_types/structs.md:73 msgid "// Instantiate a unit struct\n" msgstr "// 유닛 구조체 인스턴스 생성\n" #: src/custom_types/structs.md:76 msgid "// Instantiate a tuple struct\n" msgstr "// 튜플 구조체 인스턴스 생성\n" #: src/custom_types/structs.md:79 msgid "// Access the fields of a tuple struct\n" msgstr "// 튜플 구조체의 필드에 접근\n" #: src/custom_types/structs.md:80 src/custom_types/structs.md:85 msgid "\"pair contains {:?} and {:?}\"" msgstr "\"페어는 {:?}와 {:?}를 포함합니다\"" #: src/custom_types/structs.md:82 msgid "// Destructure a tuple struct\n" msgstr "// 튜플 구조체 구조 분해\n" #: src/custom_types/structs.md:91 msgid "" "Add a function `rect_area` which calculates the area of a `Rectangle` (try " "using nested destructuring)." msgstr "" "`Rectangle`의 넓이를 계산하는 `rect_area` 함수를 추가하세요. (중첩된 구조 분" "해를 사용해 보세요)." #: src/custom_types/structs.md:93 msgid "" "Add a function `square` which takes a `Point` and a `f32` as arguments, and " "returns a `Rectangle` with its top left corner on the point, and a width and " "height corresponding to the `f32`." msgstr "" "`Point`와 `f32`를 인자로 받아, 해당 포인트를 왼쪽 위 모서리로 하고 `f32`에 해" "당하는 너비와 높이를 가진 `Rectangle`을 반환하는 `square` 함수를 추가하세요." #: src/custom_types/structs.md:97 msgid "See also" msgstr "참고" #: src/custom_types/structs.md:99 msgid "" "[`attributes`](../attribute.md), [raw identifiers](../compatibility/" "raw_identifiers.md) and [destructuring](../flow_control/match/" "destructuring.md)" msgstr "" "[`속성`](../attribute.md), [raw 식별자](../compatibility/raw_identifiers.md) " "및 [구조 분해](../flow_control/match/destructuring.md)" #: src/custom_types/enum.md:3 msgid "" "The `enum` keyword allows the creation of a type which may be one of a few " "different variants. Any variant which is valid as a `struct` is also valid " "in an `enum`." msgstr "" "`enum` 키워드는 몇 가지 다른 변체 중 하나일 수 있는 타입을 생성할 수 있게 합" "니다. `struct`로 유효한 모든 변체는 `enum`에서도 유효합니다." #: src/custom_types/enum.md:8 msgid "" "// Create an `enum` to classify a web event. Note how both\n" "// names and type information together specify the variant:\n" "// `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.\n" "// Each is different and independent.\n" msgstr "" "// 웹 이벤트를 분류하기 위한 `enum`을 생성합니다. 이름과 타입 정보가\n" "// 함께 변체를 지정하는 방식에 주목하세요:\n" "// `PageLoad != PageUnload` 이고 `KeyPress(char) != Paste(String)` 입니다.\n" "// 각각은 서로 다르고 독립적입니다.\n" #: src/custom_types/enum.md:13 msgid "// An `enum` variant may either be `unit-like`,\n" msgstr "// `enum` 변체는 유닛 형태(unit-like)일 수도 있고,\n" #: src/custom_types/enum.md:16 msgid "// like tuple structs,\n" msgstr "// 튜플 구조체 형태일 수도 있으며,\n" #: src/custom_types/enum.md:19 msgid "// or c-like structures.\n" msgstr "// 또는 C 구조체 형태일 수도 있습니다.\n" #: src/custom_types/enum.md:22 msgid "" "// A function which takes a `WebEvent` enum as an argument and\n" "// returns nothing.\n" msgstr "" "// `WebEvent` 열거형을 인자로 받고 아무것도 반환하지 않는 함수입니다.\n" #: src/custom_types/enum.md:27 msgid "\"page loaded\"" msgstr "\"페이지 로드됨\"" #: src/custom_types/enum.md:28 msgid "\"page unloaded\"" msgstr "\"페이지 언로드됨\"" #: src/custom_types/enum.md:29 msgid "// Destructure `c` from inside the `enum` variant.\n" msgstr "// `enum` 변체 내부에서 `c`를 구조 분해합니다.\n" #: src/custom_types/enum.md:30 msgid "\"pressed '{}'.\"" msgstr "\"'{}' 키가 눌렸습니다.\"" #: src/custom_types/enum.md:31 msgid "\"pasted \\\"{}\\\".\"" msgstr "\"\\\"{}\\\"가 붙여넣기 되었습니다.\"" #: src/custom_types/enum.md:32 msgid "// Destructure `Click` into `x` and `y`.\n" msgstr "// `Click`을 `x`와 `y`로 구조 분해합니다.\n" #: src/custom_types/enum.md:34 msgid "\"clicked at x={}, y={}.\"" msgstr "\"x={}, y={} 지점이 클릭되었습니다.\"" #: src/custom_types/enum.md:40 msgid "'x'" msgstr "'x'" #: src/custom_types/enum.md:41 msgid "// `to_owned()` creates an owned `String` from a string slice.\n" msgstr "" "// `to_owned()`는 문자열 슬라이스로부터 소유권이 있는 `String`을 생성합니" "다.\n" #: src/custom_types/enum.md:42 msgid "\"my text\"" msgstr "\"나의 텍스트\"" #: src/custom_types/enum.md:56 msgid "Type aliases" msgstr "타입 별칭" #: src/custom_types/enum.md:58 msgid "" "If you use a type alias, you can refer to each enum variant via its alias. " "This might be useful if the enum's name is too long or too generic, and you " "want to rename it." msgstr "" "타입 별칭을 사용하면, 별칭을 통해 각 열거형 변체를 참조할 수 있습니다. 이는 " "열거형의 이름이 너무 길거나 너무 일반적이어서 이름을 바꾸고 싶을 때 유용할 " "수 있습니다." #: src/custom_types/enum.md:67 msgid "// Creates a type alias\n" msgstr "// 타입 별칭을 생성합니다\n" #: src/custom_types/enum.md:72 msgid "" "// We can refer to each variant via its alias, not its long and " "inconvenient\n" " // name.\n" msgstr "// 길고 불편한 이름 대신 별칭을 통해 각 변체를 참조할 수 있습니다.\n" #: src/custom_types/enum.md:78 msgid "" "The most common place you'll see this is in `impl` blocks using the `Self` " "alias." msgstr "" "이를 가장 흔히 볼 수 있는 곳은 `Self` 별칭을 사용하는 `impl` 블록 내부입니다." #: src/custom_types/enum.md:96 msgid "" "To learn more about enums and type aliases, you can read the [stabilization " "report](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847) from when this feature was stabilized into Rust." msgstr "" "열거형과 타입 별칭에 대해 더 자세히 알아보려면, 이 기능이 Rust에서 안정화되었" "을 때의 [안정화 보고서](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847)를 읽어보세요." #: src/custom_types/enum.md:102 msgid "" "[`match`](../flow_control/match.md), [`fn`](../fn.md), and [`String`](../std/" "str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/rfcs/" "2338-type-alias-enum-variants.html)" msgstr "" "[`match`](../flow_control/match.md), [`fn`](../fn.md), 그리고 [`String`](../" "std/str.md), [\"타입 별칭 열거형 변체\" RFC](https://rust-lang.github.io/" "rfcs/2338-type-alias-enum-variants.html)" #: src/custom_types/enum/enum_use.md:3 msgid "" "The `use` declaration can be used to avoid typing the full module path to " "access a name:" msgstr "" "`use` 선언을 사용하면 이름을 사용하기 위해 전체 모듈 경로를 입력하는 것을 피" "할 수 있습니다:" #: src/custom_types/enum/enum_use.md:20 msgid "" "// Explicitly `use` each name so they are available without\n" " // manual scoping.\n" msgstr "" "// 각 이름을 명시적으로 `use`하여 수동으로 스코프를 지정하지 않고도\n" " // 사용할 수 있게 합니다.\n" #: src/custom_types/enum/enum_use.md:23 msgid "// Automatically `use` each name inside `Role`.\n" msgstr "// `Role` 내부의 각 이름을 자동으로 `use`합니다.\n" #: src/custom_types/enum/enum_use.md:26 msgid "// Equivalent to `Stage::Beginner`.\n" msgstr "// `Stage::Beginner`와 동일합니다.\n" #: src/custom_types/enum/enum_use.md:28 msgid "// Equivalent to `Role::Student`.\n" msgstr "// `Role::Student`와 동일합니다.\n" #: src/custom_types/enum/enum_use.md:32 msgid "// Note the lack of scoping because of the explicit `use` above.\n" msgstr "// 위의 명시적 `use` 덕분에 스코프 지정이 필요 없음에 주목하세요.\n" #: src/custom_types/enum/enum_use.md:33 msgid "\"Beginners are starting their learning journey!\"" msgstr "\"초보자들이 학습 여정을 시작합니다!\"" #: src/custom_types/enum/enum_use.md:34 msgid "\"Advanced learners are mastering their subjects...\"" msgstr "\"상급 학습자들이 주제를 마스터하고 있습니다...\"" #: src/custom_types/enum/enum_use.md:38 msgid "// Note again the lack of scoping.\n" msgstr "// 다시 한번 스코프 지정이 없음에 주목하세요.\n" #: src/custom_types/enum/enum_use.md:39 msgid "\"Students are acquiring knowledge!\"" msgstr "\"학생들이 지식을 습득하고 있습니다!\"" #: src/custom_types/enum/enum_use.md:40 msgid "\"Teachers are spreading knowledge!\"" msgstr "\"교사들이 지식을 전파하고 있습니다!\"" #: src/custom_types/enum/enum_use.md:47 msgid "[`match`](../../flow_control/match.md) and [`use`](../../mod/use.md)" msgstr "[`match`](../../flow_control/match.md)와 [`use`](../../mod/use.md)" #: src/custom_types/enum/c_like.md:3 msgid "`enum` can also be used as C-like enums." msgstr "`enum`은 C 스타일의 열거형으로도 사용될 수 있습니다." #: src/custom_types/enum/c_like.md:8 msgid "// enum with implicit discriminator (starts at 0)\n" msgstr "// 암시적 식별자(0부터 시작)를 가진 열거형\n" #: src/custom_types/enum/c_like.md:15 msgid "// enum with explicit discriminator\n" msgstr "// 명시적 식별자를 가진 열거형\n" #: src/custom_types/enum/c_like.md:24 msgid "// `enums` can be cast as integers.\n" msgstr "// `enum`은 정수로 형변환(cast)될 수 있습니다.\n" #: src/custom_types/enum/c_like.md:25 msgid "\"zero is {}\"" msgstr "\"0은 {}입니다\"" #: src/custom_types/enum/c_like.md:26 msgid "\"one is {}\"" msgstr "\"1은 {}입니다\"" #: src/custom_types/enum/c_like.md:28 msgid "\"roses are #{:06x}\"" msgstr "\"장미는 #{:06x}색입니다\"" #: src/custom_types/enum/c_like.md:29 msgid "\"violets are #{:06x}\"" msgstr "\"제비꽃은 #{:06x}색입니다\"" #: src/custom_types/enum/c_like.md:35 msgid "[casting](../../types/cast.md)" msgstr "[형변환](../../types/cast.md)" #: src/custom_types/enum/testcase_linked_list.md:3 msgid "A common way to implement a linked-list is via `enums`:" msgstr "연결 리스트를 구현하는 일반적인 방법은 `enums`를 사용하는 것입니다:" #: src/custom_types/enum/testcase_linked_list.md:9 msgid "" "// Cons: Tuple struct that wraps an element and a pointer to the next node\n" msgstr "// Cons: 요소와 다음 노드에 대한 포인터를 감싸는 튜플 구조체\n" #: src/custom_types/enum/testcase_linked_list.md:11 msgid "// Nil: A node that signifies the end of the linked list\n" msgstr "// Nil: 연결 리스트의 끝을 나타내는 노드\n" #: src/custom_types/enum/testcase_linked_list.md:14 msgid "// Methods can be attached to an enum\n" msgstr "// 열거형에 메서드를 붙일 수 있습니다\n" #: src/custom_types/enum/testcase_linked_list.md:17 msgid "// Create an empty list\n" msgstr "// 빈 리스트를 생성합니다\n" #: src/custom_types/enum/testcase_linked_list.md:19 msgid "// `Nil` has type `List`\n" msgstr "// `Nil`은 `List` 타입을 가집니다\n" #: src/custom_types/enum/testcase_linked_list.md:23 msgid "" "// Consume a list, and return the same list with a new element at its front\n" msgstr "" "// 리스트를 소비하고, 그 앞에 새로운 요소가 추가된 동일한 리스트를 반환합니" "다\n" #: src/custom_types/enum/testcase_linked_list.md:25 msgid "// `Cons` also has type List\n" msgstr "// `Cons` 역시 `List` 타입을 가집니다\n" #: src/custom_types/enum/testcase_linked_list.md:29 msgid "// Return the length of the list\n" msgstr "// 리스트의 길이를 반환합니다\n" #: src/custom_types/enum/testcase_linked_list.md:31 msgid "" "// `self` has to be matched, because the behavior of this method\n" " // depends on the variant of `self`\n" " // `self` has type `&List`, and `*self` has type `List`, matching on " "a\n" " // concrete type `T` is preferred over a match on a reference `&T`\n" " // after Rust 2018 you can use self here and tail (with no ref) " "below as well,\n" " // rust will infer &s and ref tail.\n" " // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" msgstr "" "// 메서드의 동작이 `self`의 변체에 따라 달라지므로 `self`에 대해 매치(match)" "를 수행해야 합니다.\n" " // `self`는 `&List` 타입이고, `*self`는 `List` 타입입니다. 구체적인 " "타입 `T`에 대한 매칭이\n" " // 참조 `&T`에 대한 매칭보다 선호됩니다.\n" " // Rust 2018 이후에는 여기서 self를 사용하고 아래에서 tail(ref 없이)" "을 사용할 수도 있습니다.\n" " // Rust가 &s와 ref tail을 추론할 것입니다.\n" " // 참고: https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" #: src/custom_types/enum/testcase_linked_list.md:39 msgid "" "// Can't take ownership of the tail, because `self` is borrowed;\n" " // instead take a reference to the tail\n" " // And it's a non-tail recursive call which may cause stack " "overflow for long lists.\n" msgstr "" "// `self`가 빌려온 상태이므로 꼬리(tail)의 소유권을 가질 수 없습니다.\n" " // 대신 꼬리에 대한 참조를 가져옵니다.\n" " // 그리고 이것은 꼬리 재귀가 아닌 호출이므로 긴 리스트의 경우 스" "택 오버플로우가 발생할 수 있습니다.\n" #: src/custom_types/enum/testcase_linked_list.md:43 msgid "// Base Case: An empty list has zero length\n" msgstr "// 기저 사례(Base Case): 빈 리스트의 길이는 0입니다\n" #: src/custom_types/enum/testcase_linked_list.md:48 msgid "// Return representation of the list as a (heap allocated) string\n" msgstr "// 리스트를 (힙에 할당된) 문자열 표현으로 반환합니다\n" #: src/custom_types/enum/testcase_linked_list.md:52 msgid "" "// `format!` is similar to `print!`, but returns a heap\n" " // allocated string instead of printing to the console\n" msgstr "" "// `format!`은 `print!`와 유사하지만, 콘솔에 출력하는 대신\n" " // 힙에 할당된 문자열을 반환합니다\n" #: src/custom_types/enum/testcase_linked_list.md:54 src/generics/impl.md:44 msgid "\"{}, {}\"" msgstr "\"{}, {}\"" #: src/custom_types/enum/testcase_linked_list.md:57 msgid "\"Nil\"" msgstr "\"Nil\"" #: src/custom_types/enum/testcase_linked_list.md:64 msgid "// Create an empty linked list\n" msgstr "// 빈 연결 리스트를 생성합니다\n" #: src/custom_types/enum/testcase_linked_list.md:67 msgid "// Prepend some elements\n" msgstr "// 몇 가지 요소를 앞에 추가합니다\n" #: src/custom_types/enum/testcase_linked_list.md:72 msgid "// Show the final state of the list\n" msgstr "// 리스트의 최종 상태를 보여줍니다\n" #: src/custom_types/enum/testcase_linked_list.md:73 msgid "\"linked list has length: {}\"" msgstr "\"연결 리스트의 길이는 {}입니다\"" #: src/custom_types/enum/testcase_linked_list.md:80 msgid "[`Box`](../../std/box.md) and [methods](../../fn/methods.md)" msgstr "[`Box`](../../std/box.md)와 [메서드](../../fn/methods.md)" #: src/custom_types/constants.md:3 msgid "" "Rust has two different types of constants which can be declared in any scope " "including global. Both require explicit type annotation:" msgstr "" "Rust에는 전역 범위를 포함한 모든 범위에서 선언할 수 있는 두 가지 유형의 상수" "가 있습니다. 둘 다 명시적인 타입 어노테이션이 필요합니다:" #: src/custom_types/constants.md:6 msgid "`const`: An unchangeable value (the common case)." msgstr "`const`: 변경할 수 없는 값 (일반적인 경우)." #: src/custom_types/constants.md:7 msgid "" "`static`: A possibly mutable variable with [`'static`](../scope/lifetime/" "static_lifetime.md) lifetime. The static lifetime is inferred and does not " "have to be specified. Accessing or modifying a mutable static variable is " "[`unsafe`](../unsafe.md)." msgstr "" "`static`: [`'static`](../scope/lifetime/static_lifetime.md) 라이프타임을 가" "진, 가변적일 수 있는 변수입니다. static 라이프타임은 추론되므로 명시할 필요" "는 없습니다. 가변적인 static 변수에 접근하거나 수정하는 것은 [`unsafe`](../" "unsafe.md)합니다." #: src/custom_types/constants.md:12 msgid "// Globals are declared outside all other scopes.\n" msgstr "// 전역 변수는 다른 모든 범위의 바깥에 선언됩니다.\n" #: src/custom_types/constants.md:13 msgid "\"Rust\"" msgstr "\"러스트\"" #: src/custom_types/constants.md:17 msgid "// Access constant in some function\n" msgstr "// 어떤 함수 내에서 상수에 접근\n" #: src/custom_types/constants.md:24 msgid "// Access constant in the main thread\n" msgstr "// 메인 스레드에서 상수에 접근\n" #: src/custom_types/constants.md:25 msgid "\"This is {}\"" msgstr "\"이것은 {}입니다\"" #: src/custom_types/constants.md:26 msgid "\"The threshold is {}\"" msgstr "\"임계값은 {}입니다\"" #: src/custom_types/constants.md:27 msgid "\"{} is {}\"" msgstr "\"{}은(는) {}입니다\"" #: src/custom_types/constants.md:27 msgid "\"big\"" msgstr "\"큰\"" #: src/custom_types/constants.md:27 msgid "\"small\"" msgstr "\"작은\"" #: src/custom_types/constants.md:29 msgid "// Error! Cannot modify a `const`.\n" msgstr "// 에러! `const`는 수정할 수 없습니다.\n" #: src/custom_types/constants.md:31 src/variable_bindings/scope.md:22 #: src/variable_bindings/declare.md:27 src/variable_bindings/freeze.md:16 #: src/types/cast.md:19 src/types/cast.md:28 src/flow_control/for.md:95 #: src/scope/borrow.md:41 src/scope/borrow/mut.md:52 src/std/vec.md:32 #: src/std/vec.md:45 src/std/hash/hashset.md:48 msgid "// FIXME ^ Comment out this line\n" msgstr "// FIXME ^ 이 줄을 주석 처리하세요\n" #: src/custom_types/constants.md:37 msgid "" "[The `const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/" "text/0246-const-vs-static.md), [`'static` lifetime](../scope/lifetime/" "static_lifetime.md)" msgstr "" "[`const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/text/" "0246-const-vs-static.md), [`'static` 라이프타임](../scope/lifetime/" "static_lifetime.md)" #: src/variable_bindings.md:3 msgid "" "Rust provides type safety via static typing. Variable bindings can be type " "annotated when declared. However, in most cases, the compiler will be able " "to infer the type of the variable from the context, heavily reducing the " "annotation burden." msgstr "" "Rust는 정적 타이핑을 통해 타입 안전성을 제공합니다. 변수 바인딩은 선언 시 타" "입 어노테이션을 할 수 있습니다. 하지만 대부분의 경우, 컴파일러는 문맥으로부" "터 변수의 타입을 추론할 수 있어 어노테이션의 부담을 크게 줄여줍니다." #: src/variable_bindings.md:8 msgid "" "Values (like literals) can be bound to variables, using the `let` binding." msgstr "값(리터럴 등)은 `let` 바인딩을 사용하여 변수에 바인딩될 수 있습니다." #: src/variable_bindings.md:16 msgid "// copy `an_integer` into `copied_integer`\n" msgstr "// `an_integer`를 `copied_integer`로 복사합니다\n" #: src/variable_bindings.md:19 msgid "\"An integer: {:?}\"" msgstr "\"정수: {:?}\"" #: src/variable_bindings.md:20 msgid "\"A boolean: {:?}\"" msgstr "\"불리언: {:?}\"" #: src/variable_bindings.md:21 msgid "\"Meet the unit value: {:?}\"" msgstr "\"유닛 값을 만나보세요: {:?}\"" #: src/variable_bindings.md:23 msgid "" "// The compiler warns about unused variable bindings; these warnings can\n" " // be silenced by prefixing the variable name with an underscore\n" msgstr "" "// 컴파일러는 사용되지 않는 변수 바인딩에 대해 경고를 보냅니다. 이러한 경고" "는\n" " // 변수 이름 앞에 밑줄을 붙여서 비활성화할 수 있습니다.\n" #: src/variable_bindings.md:28 msgid "" "// FIXME ^ Prefix with an underscore to suppress the warning\n" " // Please note that warnings may not be shown in a browser\n" msgstr "" "// FIXME ^ 경고를 억제하기 위해 밑줄을 접두사로 붙이세요\n" " // 브라우저에서는 경고가 표시되지 않을 수 있음에 유의하세요\n" #: src/variable_bindings/mut.md:3 msgid "" "Variable bindings are immutable by default, but this can be overridden using " "the `mut` modifier." msgstr "" "변수 바인딩은 기본적으로 불변(immutable)이지만, `mut` 수식어를 사용하여 이를 " "재정의할 수 있습니다." #: src/variable_bindings/mut.md:11 msgid "\"Before mutation: {}\"" msgstr "\"변경 전: {}\"" #: src/variable_bindings/mut.md:13 msgid "// Ok\n" msgstr "// 좋습니다\n" #: src/variable_bindings/mut.md:16 msgid "\"After mutation: {}\"" msgstr "\"변경 후: {}\"" #: src/variable_bindings/mut.md:18 msgid "// Error! Cannot assign a new value to an immutable variable\n" msgstr "// 에러! 불변 변수에는 새로운 값을 할당할 수 없습니다\n" #: src/variable_bindings/mut.md:23 msgid "The compiler will throw a detailed diagnostic about mutability errors." msgstr "컴파일러는 가변성 에러에 대해 상세한 진단을 제공할 것입니다." #: src/variable_bindings/scope.md:3 msgid "" "Variable bindings have a scope, and are constrained to live in a _block_. A " "block is a collection of statements enclosed by braces `{}`." msgstr "" "변수 바인딩은 스코프(범위)를 가지며, _블록_ 내에 거주하도록 제한됩니다. 블록" "은 중괄호 `{}`로 둘러싸인 문장들의 모음입니다." #: src/variable_bindings/scope.md:8 msgid "// This binding lives in the main function\n" msgstr "// 이 바인딩은 메인 함수에 거주합니다\n" #: src/variable_bindings/scope.md:11 msgid "// This is a block, and has a smaller scope than the main function\n" msgstr "// 이것은 블록이며, 메인 함수보다 더 작은 스코프를 가집니다\n" #: src/variable_bindings/scope.md:13 msgid "// This binding only exists in this block\n" msgstr "// 이 바인딩은 이 블록 내에만 존재합니다\n" #: src/variable_bindings/scope.md:16 msgid "\"inner short: {}\"" msgstr "\"내부 short: {}\"" #: src/variable_bindings/scope.md:18 msgid "// End of the block\n" msgstr "// 블록의 끝\n" #: src/variable_bindings/scope.md:20 msgid "// Error! `short_lived_binding` doesn't exist in this scope\n" msgstr "// 에러! `short_lived_binding`은 이 스코프에 존재하지 않습니다\n" #: src/variable_bindings/scope.md:21 msgid "\"outer short: {}\"" msgstr "\"외부 short: {}\"" #: src/variable_bindings/scope.md:24 msgid "\"outer long: {}\"" msgstr "\"외부 long: {}\"" #: src/variable_bindings/scope.md:28 msgid "" "Also, [variable shadowing](https://en.wikipedia.org/wiki/Variable_shadowing) " "is allowed." msgstr "" "또한, [변수 섀도잉](https://en.wikipedia.org/wiki/Variable_shadowing)이 허용" "됩니다." #: src/variable_bindings/scope.md:35 msgid "\"before being shadowed: {}\"" msgstr "\"섀도잉 전: {}\"" #: src/variable_bindings/scope.md:37 msgid "// This binding *shadows* the outer one\n" msgstr "// 이 바인딩은 외부 바인딩을 *섀도잉*합니다\n" #: src/variable_bindings/scope.md:38 msgid "\"abc\"" msgstr "\"abc\"" #: src/variable_bindings/scope.md:40 msgid "\"shadowed in inner block: {}\"" msgstr "\"내부 블록에서 섀도잉됨: {}\"" #: src/variable_bindings/scope.md:42 msgid "\"outside inner block: {}\"" msgstr "\"내부 블록 밖: {}\"" #: src/variable_bindings/scope.md:44 msgid "// This binding *shadows* the previous binding\n" msgstr "// 이 바인딩은 이전 바인딩을 *섀도잉*합니다\n" #: src/variable_bindings/scope.md:46 msgid "\"shadowed in outer block: {}\"" msgstr "\"외부 블록에서 섀도잉됨: {}\"" #: src/variable_bindings/declare.md:3 msgid "" "It is possible to declare variable bindings first and initialize them later, " "but all variable bindings must be initialized before they are used: the " "compiler forbids use of uninitialized variable bindings, as it would lead to " "undefined behavior." msgstr "" "변수 바인딩을 먼저 선언하고 나중에 초기화하는 것이 가능하지만, 모든 변수 바인" "딩은 사용되기 전에 초기화되어야 합니다. 컴파일러는 정의되지 않은 동작을 초래" "할 수 있는 초기화되지 않은 변수 바인딩의 사용을 금지합니다." #: src/variable_bindings/declare.md:5 msgid "" "It is not common to declare a variable binding and initialize it later in " "the function. It is more difficult for a reader to find the initialization " "when initialization is separated from declaration. It is common to declare " "and initialize a variable binding near where the variable will be used." msgstr "" "변수 바인딩을 선언하고 나중에 함수 내에서 초기화하는 것은 일반적이지 않습니" "다. 선언과 초기화가 분리되어 있으면 독자가 초기화 지점을 찾기 더 어렵기 때문" "입니다. 변수가 사용될 위치 근처에서 선언과 초기화를 함께 하는 것이 일반적입니" "다." #: src/variable_bindings/declare.md:11 msgid "// Declare a variable binding\n" msgstr "// 변수 바인딩 선언\n" #: src/variable_bindings/declare.md:17 msgid "// Initialize the binding\n" msgstr "// 바인딩 초기화\n" #: src/variable_bindings/declare.md:21 msgid "\"a binding: {}\"" msgstr "\"바인딩 a: {}\"" #: src/variable_bindings/declare.md:25 msgid "// Error! Use of uninitialized binding\n" msgstr "// 에러! 초기화되지 않은 바인딩 사용\n" #: src/variable_bindings/declare.md:26 src/variable_bindings/declare.md:31 msgid "\"another binding: {}\"" msgstr "\"또 다른 바인딩: {}\"" #: src/variable_bindings/freeze.md:3 msgid "" "When data is bound by the same name immutably, it also _freezes_. _Frozen_ " "data can't be modified until the immutable binding goes out of scope:" msgstr "" "데이터가 동일한 이름으로 불변하게 바인딩되면, 해당 데이터는 _동결(freeze)_됩" "니다. _동결된_ 데이터는 불변 바인딩이 스코프를 벗어날 때까지 수정할 수 없습니" "다." #: src/variable_bindings/freeze.md:11 msgid "// Shadowing by immutable `_mutable_integer`\n" msgstr "// 불변 `_mutable_integer`에 의한 섀도잉\n" #: src/variable_bindings/freeze.md:14 msgid "// Error! `_mutable_integer` is frozen in this scope\n" msgstr "// 에러! `_mutable_integer`는 이 스코프에서 동결되었습니다\n" #: src/variable_bindings/freeze.md:18 msgid "// `_mutable_integer` goes out of scope\n" msgstr "// `_mutable_integer`가 스코프를 벗어납니다\n" #: src/variable_bindings/freeze.md:21 msgid "// Ok! `_mutable_integer` is not frozen in this scope\n" msgstr "// 좋습니다! `_mutable_integer`는 이 스코프에서 동결되지 않았습니다\n" #: src/types.md:3 msgid "" "Rust provides several mechanisms to change or define the type of primitive " "and user defined types. The following sections cover:" msgstr "" "Rust는 기본 타입과 사용자 정의 타입의 타입을 변경하거나 정의하기 위한 여러 메" "커니즘을 제공합니다. 다음 섹션에서는 다음을 다룹니다:" #: src/types.md:6 msgid "[Casting](types/cast.md) between primitive types" msgstr "기본 타입 간의 [형변환(Casting)](types/cast.md)" #: src/types.md:7 msgid "Specifying the desired type of [literals](types/literals.md)" msgstr "[리터럴](types/literals.md)의 원하는 타입을 지정하는 법" #: src/types.md:8 msgid "Using [type inference](types/inference.md)" msgstr "[타입 추론(type inference)](types/inference.md) 사용" #: src/types.md:9 msgid "[Aliasing](types/alias.md) types" msgstr "타입 [별칭(Aliasing)](types/alias.md)" #: src/types/cast.md:3 msgid "" "Rust provides no implicit type conversion (coercion) between primitive " "types. But, explicit type conversion (casting) can be performed using the " "`as` keyword." msgstr "" "Rust는 기본 타입 간의 암시적 타입 변환(강제)을 제공하지 않습니다. 하지만 " "`as` 키워드를 사용하여 명시적 타입 변환(캐스팅)을 수행할 수 있습니다." #: src/types/cast.md:6 msgid "" "Rules for converting between integral types follow C conventions generally, " "except in cases where C has undefined behavior. The behavior of all casts " "between integral types is well defined in Rust." msgstr "" "정수 타입 간의 변환 규칙은 일반적으로 C 언어의 관례를 따르지만, C에서 정의되" "지 않은 동작(undefined behavior)이 발생하는 경우는 예외입니다. Rust에서 정수 " "타입 간의 모든 캐스팅 동작은 잘 정의되어 있습니다." #: src/types/cast.md:11 msgid "// Suppress all errors from casts which overflow.\n" msgstr "// 오버플로우가 발생하는 캐스팅으로 인한 모든 에러를 억제합니다.\n" #: src/types/cast.md:17 msgid "// Error! No implicit conversion\n" msgstr "// 에러! 암시적 변환 없음\n" #: src/types/cast.md:21 msgid "// Explicit conversion\n" msgstr "// 명시적 변환\n" #: src/types/cast.md:25 msgid "" "// Error! There are limitations in conversion rules.\n" " // A float cannot be directly converted to a char.\n" msgstr "" "// 에러! 변환 규칙에 제한이 있습니다.\n" " // 부동 소수점은 문자로 직접 변환할 수 없습니다.\n" #: src/types/cast.md:30 msgid "\"Casting: {} -> {} -> {}\"" msgstr "\"형변환: {} -> {} -> {}\"" #: src/types/cast.md:32 msgid "" "// when casting any value to an unsigned type, T,\n" " // T::MAX + 1 is added or subtracted until the value\n" " // fits into the new type ONLY when the #![allow(overflowing_literals)]\n" " // lint is specified like above. Otherwise there will be a compiler " "error.\n" msgstr "" "// 값을 부호 없는 타입 T로 캐스팅할 때, #![allow(overflowing_literals)]\n" " // 린트가 위와 같이 지정된 경우에만 값이 새로운 타입에 맞을 때까지\n" " // T::MAX + 1을 더하거나 뺍니다. 그렇지 않으면 컴파일 에러가 발생합니" "다.\n" #: src/types/cast.md:37 msgid "// 1000 already fits in a u16\n" msgstr "// 1000은 이미 u16에 들어맞습니다\n" #: src/types/cast.md:38 msgid "\"1000 as a u16 is: {}\"" msgstr "\"1000을 u16으로 변환하면: {}\"" #: src/types/cast.md:40 msgid "" "// 1000 - 256 - 256 - 256 = 232\n" " // Under the hood, the first 8 least significant bits (LSB) are kept,\n" " // while the rest towards the most significant bit (MSB) get truncated.\n" msgstr "" "// 1000 - 256 - 256 - 256 = 232\n" " // 내부적으로는 첫 8개의 최하위 비트(LSB)는 유지되고,\n" " // 최상위 비트(MSB) 쪽의 나머지 비트들은 잘려 나갑니다.\n" #: src/types/cast.md:43 src/types/cast.md:62 msgid "\"1000 as a u8 is : {}\"" msgstr "\"1000을 u8로 변환하면 : {}\"" #: src/types/cast.md:44 msgid "// -1 + 256 = 255\n" msgstr "// -1 + 256 = 255\n" #: src/types/cast.md:45 msgid "\" -1 as a u8 is : {}\"" msgstr "\" -1을 u8로 변환하면 : {}\"" #: src/types/cast.md:47 msgid "// For positive numbers, this is the same as the modulus\n" msgstr "// 양수의 경우, 이는 나머지 연산(modulus)과 동일합니다\n" #: src/types/cast.md:48 msgid "\"1000 mod 256 is : {}\"" msgstr "\"1000 mod 256은 : {}\"" #: src/types/cast.md:50 msgid "" "// When casting to a signed type, the (bitwise) result is the same as\n" " // first casting to the corresponding unsigned type. If the most " "significant\n" " // bit of that value is 1, then the value is negative.\n" msgstr "" "// 부호 있는 타입으로 캐스팅할 때, (비트 단위) 결과는 먼저\n" " // 대응하는 부호 없는 타입으로 캐스팅하는 것과 같습니다. 만약 그 값의\n" " // 최상위 비트가 1이면, 그 값은 음수입니다.\n" #: src/types/cast.md:54 msgid "// Unless it already fits, of course.\n" msgstr "// 물론 이미 들어맞는 경우는 제외합니다.\n" #: src/types/cast.md:55 msgid "\" 128 as a i16 is: {}\"" msgstr "\" 128을 i16으로 변환하면: {}\"" #: src/types/cast.md:57 msgid "" "// In boundary case 128 value in 8-bit two's complement representation is " "-128\n" msgstr "" "// 경계 케이스의 경우, 8비트 2의 보수 표현에서 128이라는 값은 -128입니다.\n" #: src/types/cast.md:58 msgid "\" 128 as a i8 is : {}\"" msgstr "\" 128을 i8로 변환하면 : {}\"" #: src/types/cast.md:60 msgid "" "// repeating the example above\n" " // 1000 as u8 -> 232\n" msgstr "" "// 위 예제를 반복합니다\n" " // 1000을 u8로 변환 -> 232\n" #: src/types/cast.md:63 msgid "" "// and the value of 232 in 8-bit two's complement representation is -24\n" msgstr "// 그리고 8비트 2의 보수 표현에서 232라는 값은 -24입니다.\n" #: src/types/cast.md:64 msgid "\" 232 as a i8 is : {}\"" msgstr "\" 232를 i8로 변환하면 : {}\"" #: src/types/cast.md:66 msgid "" "// Since Rust 1.45, the `as` keyword performs a *saturating cast*\n" " // when casting from float to int. If the floating point value exceeds\n" " // the upper bound or is less than the lower bound, the returned value\n" " // will be equal to the bound crossed.\n" msgstr "" "// Rust 1.45부터, 부동 소수점을 정수로 캐스팅할 때 `as` 키워드는\n" " // *포화 캐스팅(saturating cast)*을 수행합니다. 부동 소수점 값이\n" " // 상한을 초과하거나 하한보다 작으면, 반환되는 값은 해당 경계값이 됩니" "다.\n" #: src/types/cast.md:71 msgid "// 300.0 as u8 is 255\n" msgstr "// 300.0을 u8로 변환하면 255입니다\n" #: src/types/cast.md:72 src/types/cast.md:83 msgid "\" 300.0 as u8 is : {}\"" msgstr "\" 300.0을 u8로 변환하면 : {}\"" #: src/types/cast.md:73 msgid "// -100.0 as u8 is 0\n" msgstr "// -100.0을 u8로 변환하면 0입니다\n" #: src/types/cast.md:74 src/types/cast.md:85 msgid "\"-100.0 as u8 is : {}\"" msgstr "\"-100.0을 u8로 변환하면 : {}\"" #: src/types/cast.md:75 src/types/cast.md:86 msgid "// nan as u8 is 0\n" msgstr "// nan을 u8로 변환하면 0입니다\n" #: src/types/cast.md:76 src/types/cast.md:87 msgid "\" nan as u8 is : {}\"" msgstr "\" nan을 u8로 변환하면 : {}\"" #: src/types/cast.md:78 msgid "" "// This behavior incurs a small runtime cost and can be avoided\n" " // with unsafe methods, however the results might overflow and\n" " // return **unsound values**. Use these methods wisely:\n" msgstr "" "// 이러한 동작은 약간의 런타임 비용을 발생시키며, unsafe 메서드를 사용하여\n" " // 피할 수 있습니다. 하지만 결과가 오버플로우되어 **불건전한 값(unsound " "values)**을\n" " // 반환할 수 있습니다. 이러한 메서드들은 현명하게 사용하세요:\n" #: src/types/cast.md:82 msgid "// 300.0 as u8 is 44\n" msgstr "// 300.0을 u8로 변환하면 44입니다\n" #: src/types/cast.md:84 msgid "// -100.0 as u8 is 156\n" msgstr "// -100.0을 u8로 변환하면 156입니다\n" #: src/types/literals.md:3 msgid "" "Numeric literals can be type annotated by adding the type as a suffix. As an " "example, to specify that the literal `42` should have the type `i32`, write " "`42i32`." msgstr "" "숫자 리터럴은 타입 이름을 접미사로 추가하여 타입 어노테이션을 할 수 있습니" "다. 예를 들어, 리터럴 `42`가 `i32` 타입을 가져야 함을 지정하려면 `42i32`라고 " "씁니다." #: src/types/literals.md:6 msgid "" "The type of unsuffixed numeric literals will depend on how they are used. If " "no constraint exists, the compiler will use `i32` for integers, and `f64` " "for floating-point numbers." msgstr "" "접미사가 없는 숫자 리터럴의 타입은 어떻게 사용되느냐에 따라 달라집니다. 아무" "런 제약이 없다면 컴파일러는 정수에 대해서는 `i32`를, 부동 소수점 숫자에 대해" "서는 `f64`를 사용합니다." #: src/types/literals.md:12 msgid "// Suffixed literals, their types are known at initialization\n" msgstr "// 접미사가 붙은 리터럴은 초기화 시 그 타입을 알 수 있습니다.\n" #: src/types/literals.md:17 msgid "// Unsuffixed literals, their types depend on how they are used\n" msgstr "" "// 접미사가 없는 리터럴의 타입은 어떻게 사용되느냐에 따라 달라집니다.\n" #: src/types/literals.md:21 msgid "// `size_of_val` returns the size of a variable in bytes\n" msgstr "// `size_of_val`은 변수의 크기를 바이트 단위로 반환합니다.\n" #: src/types/literals.md:22 msgid "\"size of `x` in bytes: {}\"" msgstr "`x`의 바이트 크기: {}" #: src/types/literals.md:23 msgid "\"size of `y` in bytes: {}\"" msgstr "`y`의 바이트 크기: {}" #: src/types/literals.md:24 msgid "\"size of `z` in bytes: {}\"" msgstr "`z`의 바이트 크기: {}" #: src/types/literals.md:25 msgid "\"size of `i` in bytes: {}\"" msgstr "`i`의 바이트 크기: {}" #: src/types/literals.md:26 msgid "\"size of `f` in bytes: {}\"" msgstr "`f`의 바이트 크기: {}" #: src/types/literals.md:30 msgid "" "There are some concepts used in the previous code that haven't been " "explained yet, here's a brief explanation for the impatient readers:" msgstr "" "앞선 코드에서 아직 설명되지 않은 몇 가지 개념이 사용되었습니다. 성급한 독자들" "을 위한 간단한 설명은 다음과 같습니다:" #: src/types/literals.md:33 msgid "" "`std::mem::size_of_val` is a function, but called with its _full path_. Code " "can be split in logical units called _modules_. In this case, the " "`size_of_val` function is defined in the `mem` module, and the `mem` module " "is defined in the `std` _crate_. For more details, see [modules](../mod.md) " "and [crates](../crates.md)." msgstr "" "`std::mem::size_of_val`은 함수이지만, _전체 경로(full path)_를 사용하여 호출" "되었습니다. 코드는 _모듈_이라고 불리는 논리적 단위로 나뉠 수 있습니다. 이 경" "우, `size_of_val` 함수는 `mem` 모듈에 정의되어 있고, `mem` 모듈은 `std` _크레" "이트_에 정의되어 있습니다. 자세한 내용은 [모듈](../mod.md) 및 [크레이트](../" "crates.md)를 참조하세요." #: src/types/inference.md:3 msgid "" "The type inference engine is pretty smart. It does more than looking at the " "type of the value expression during an initialization. It also looks at how " "the variable is used afterwards to infer its type. Here's an advanced " "example of type inference:" msgstr "" "타입 추론 엔진은 꽤 똑똑합니다. 초기화 중에 값 표현식의 타입을 살펴보는 것 이" "상의 일을 합니다. 또한 변수가 이후에 어떻게 사용되는지를 보고 타입을 추론합니" "다. 다음은 타입 추론의 심화 예시입니다:" #: src/types/inference.md:10 msgid "" "// Because of the annotation, the compiler knows that `elem` has type u8.\n" msgstr "// 어노테이션 덕분에 컴파일러는 `elem`이 u8 타입임을 압니다.\n" #: src/types/inference.md:13 msgid "// Create an empty vector (a growable array).\n" msgstr "// 빈 벡터(가변 크기 배열)를 생성합니다.\n" #: src/types/inference.md:15 msgid "" "// At this point the compiler doesn't know the exact type of `vec`, it\n" " // just knows that it's a vector of something (`Vec<_>`).\n" msgstr "" "// 이 시점에서 컴파일러는 `vec`의 정확한 타입을 알지 못하며,\n" " // 단지 무언가의 벡터(`Vec<_>`)라는 것만 압니다.\n" #: src/types/inference.md:18 msgid "// Insert `elem` in the vector.\n" msgstr "// 벡터에 `elem`을 삽입합니다.\n" #: src/types/inference.md:20 msgid "" "// Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec`)\n" " // TODO ^ Try commenting out the `vec.push(elem)` line\n" msgstr "" "// 아하! 이제 컴파일러는 `vec`이 `u8`들의 벡터(`Vec`)임을 압니다.\n" " // TODO ^ `vec.push(elem)` 줄을 주석 처리해 보세요\n" #: src/types/inference.md:27 msgid "" "No type annotation of variables was needed, the compiler is happy and so is " "the programmer!" msgstr "" "변수의 타입 어노테이션이 필요하지 않았습니다. 컴파일러도 만족하고 프로그래머" "도 행복합니다!" #: src/types/alias.md:3 msgid "" "The `type` statement can be used to give a new name to an existing type. " "Types must have `UpperCamelCase` names, or the compiler will raise a " "warning. The exception to this rule are the primitive types: `usize`, `f32`, " "etc." msgstr "" "`type` 문을 사용하면 기존 타입에 새로운 이름을 부여할 수 있습니다. 타입 이름" "은 `UpperCamelCase`여야 하며, 그렇지 않으면 컴파일러가 경고를 보냅니다. 이 규" "칙의 예외는 기본 타입인 `usize`, `f32` 등입니다." #: src/types/alias.md:8 msgid "// `NanoSecond`, `Inch`, and `U64` are new names for `u64`.\n" msgstr "// `NanoSecond`, `Inch`, `U64`는 `u64`를 가리키는 새로운 이름입니다.\n" #: src/types/alias.md:14 msgid "// `NanoSecond` = `Inch` = `U64` = `u64`.\n" msgstr "// `NanoSecond` = `Inch` = `U64` = `u64`입니다.\n" #: src/types/alias.md:18 msgid "" "// Note that type aliases *don't* provide any extra type safety, because\n" " // aliases are *not* new types\n" msgstr "" "// 타입 별칭은 새로운 타입이 아니기 때문에, 추가적인 타입 안전성을\n" " // 제공하지 않는다는 점에 유의하세요.\n" #: src/types/alias.md:20 msgid "\"{} nanoseconds + {} inches = {} unit?\"" msgstr "\"{} 나노초 + {} 인치 = {} 유닛?\"" #: src/types/alias.md:27 msgid "" "The main use of aliases is to reduce boilerplate; for example the " "`io::Result` type is an alias for the `Result` type." msgstr "" "별칭의 주요 용도는 보일러플레이트(boilerplate)를 줄이는 것입니다. 예를 들어 " "`io::Result` 타입은 `Result` 타입의 별칭입니다." #: src/types/alias.md:32 msgid "[Attributes](../attribute.md)" msgstr "[속성](../attribute.md)" #: src/conversion.md:3 msgid "" "Primitive types can be converted to each other through [casting](types/" "cast.md)." msgstr "" "기본 타입들은 [캐스팅(casting)](types/cast.md)을 통해 서로 변환될 수 있습니" "다." #: src/conversion.md:5 msgid "" "Rust addresses conversion between custom types (i.e., `struct` and `enum`) " "by the use of [traits](trait.md). The generic conversions will use the " "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`Into`]" "(https://doc.rust-lang.org/std/convert/trait.Into.html) traits. However " "there are more specific ones for the more common cases, in particular when " "converting to and from `String`s." msgstr "" "Rust는 [트레이트(traits)](trait.md)를 사용하여 사용자 정의 타입(예: " "`struct`, `enum`) 간의 변환을 처리합니다. 범용 변환에는 [`From`](https://" "doc.rust-lang.org/std/convert/trait.From.html)과 [`Into`](https://doc.rust-" "lang.org/std/convert/trait.Into.html) 트레이트를 사용합니다. 하지만 더 흔한 " "경우, 특히 `String`과의 상호 변환을 위한 더 구체적인 트레이트들이 존재합니다." #: src/conversion/from_into.md:3 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) traits are " "inherently linked, and this is actually part of its implementation. If you " "are able to convert type A from type B, then it should be easy to believe " "that we should be able to convert type B to type A." msgstr "" "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [`Into`]" "(https://doc.rust-lang.org/std/convert/trait.Into.html) 트레이트는 본질적으" "로 연결되어 있으며, 이는 실제로 구현의 일부입니다. 만약 타입 B로부터 타입 A" "를 만들 수 있다면(`From`), 타입 B를 타입 A로 변환할 수 있다(`Into`)는 것을 쉽" "게 알 수 있습니다." #: src/conversion/from_into.md:7 msgid "`From`" msgstr "`From`" #: src/conversion/from_into.md:9 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) trait " "allows for a type to define how to create itself from another type, hence " "providing a very simple mechanism for converting between several types. " "There are numerous implementations of this trait within the standard library " "for conversion of primitive and common types." msgstr "" "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) 트레이트는 " "한 타입이 다른 타입으로부터 자신을 생성하는 방법을 정의할 수 있게 하여, 여러 " "타입 간의 변환을 위한 매우 단순한 메커니즘을 제공합니다. 표준 라이브러리에는 " "기본 타입 및 일반적인 타입의 변환을 위해 이 트레이트가 수없이 많이 구현되어 " "있습니다." #: src/conversion/from_into.md:14 msgid "For example we can easily convert a `str` into a `String`" msgstr "예를 들어, `str`을 `String`으로 쉽게 변환할 수 있습니다." #: src/conversion/from_into.md:21 msgid "We can do something similar for defining a conversion for our own type." msgstr "" "우리는 자신의 타입에 대한 변환을 정의하기 위해 유사한 작업을 수행할 수 있습니" "다." #: src/conversion/from_into.md:39 src/conversion/from_into.md:68 #: src/conversion/from_into.md:98 msgid "\"My number is {:?}\"" msgstr "\"제 숫자는 {:?}입니다\"" #: src/conversion/from_into.md:43 msgid "`Into`" msgstr "`Into`" #: src/conversion/from_into.md:45 msgid "" "The [`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) trait is " "simply the reciprocal of the `From` trait. It defines how to convert a type " "into another type." msgstr "" "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) 트레이트는 단" "순히 `From` 트레이트의 반대입니다. 이는 한 타입을 다른 타입으로 변환하는 방법" "을 정의합니다." #: src/conversion/from_into.md:48 msgid "" "Calling `into()` typically requires us to specify the result type as the " "compiler is unable to determine this most of the time." msgstr "" "`into()`를 호출할 때는 일반적으로 결과 타입을 지정해야 합니다. 대부분의 경우 " "컴파일러가 이를 결정할 수 없기 때문입니다." #: src/conversion/from_into.md:66 msgid "// Try removing the type annotation\n" msgstr "// 타입 어노테이션을 제거해 보세요\n" #: src/conversion/from_into.md:72 msgid "`From` and `Into` are interchangeable" msgstr "`From`과 `Into`는 상호 교환 가능합니다" #: src/conversion/from_into.md:74 msgid "" "`From` and `Into` are designed to be complementary. We do not need to " "provide an implementation for both traits. If you have implemented the " "`From` trait for your type, `Into` will call it when necessary. Note, " "however, that the converse is not true: implementing `Into` for your type " "will not automatically provide it with an implementation of `From`." msgstr "" "`From`과 `Into`는 상호 보완적으로 설계되었습니다. 두 트레이트 모두에 대해 구" "현을 제공할 필요는 없습니다. 만약 자신의 타입에 대해 `From` 트레이트를 구현했" "다면, `Into`는 필요할 때 이를 호출할 것입니다. 하지만 그 반대는 성립하지 않음" "에 유의하세요. 즉, 자신의 타입에 대해 `Into`를 구현한다고 해서 `From` 구현이 " "자동으로 제공되지는 않습니다." #: src/conversion/from_into.md:86 msgid "// Define `From`\n" msgstr "// `From` 정의\n" #: src/conversion/from_into.md:96 msgid "// use `Into`\n" msgstr "// `Into` 사용\n" #: src/conversion/try_from_try_into.md:3 msgid "" "Similar to [`From` and `Into`](from_into.html), [`TryFrom`](https://doc.rust-" "lang.org/std/convert/trait.TryFrom.html) and [`TryInto`](https://doc.rust-" "lang.org/std/convert/trait.TryInto.html) are generic traits for converting " "between types. Unlike `From`/`Into`, the `TryFrom`/`TryInto` traits are used " "for fallible conversions, and as such, return [`Result`](https://doc.rust-" "lang.org/std/result/enum.Result.html)s." msgstr "" "[`From`과 `Into`](from_into.html)와 유사하게, [`TryFrom`](https://doc.rust-" "lang.org/std/convert/trait.TryFrom.html)과 [`TryInto`](https://doc.rust-" "lang.org/std/convert/trait.TryInto.html)는 타입 간 변환을 위한 제네릭 트레이" "트입니다. `From`/`Into`와 달리, `TryFrom`/`TryInto` 트레이트는 실패할 가능성" "이 있는 변환에 사용되며, 따라서 [`Result`](https://doc.rust-lang.org/std/" "result/enum.Result.html)를 반환합니다." #: src/conversion/try_from_try_into.md:33 msgid "// TryFrom\n" msgstr "// TryFrom\n" #: src/conversion/try_from_try_into.md:38 msgid "// TryInto\n" msgstr "// TryInto\n" #: src/conversion/string.md:1 msgid "To and from Strings" msgstr "문자열 상호 변환" #: src/conversion/string.md:3 msgid "Converting to String" msgstr "문자열로 변환하기" #: src/conversion/string.md:5 msgid "" "To convert any type to a `String` is as simple as implementing the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "for the type. Rather than doing so directly, you should implement the " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html) trait " "which automatically provides [`ToString`](https://doc.rust-lang.org/std/" "string/trait.ToString.html) and also allows printing the type as discussed " "in the section on [`print!`](../hello/print.md)." msgstr "" "어떤 타입을 `String`으로 변환하는 것은 해당 타입에 대해 [`ToString`](https://" "doc.rust-lang.org/std/string/trait.ToString.html) 트레이트를 구현하는 것만큼 " "간단합니다. 직접 구현하기보다는 [`fmt::Display`](https://doc.rust-lang.org/" "std/fmt/trait.Display.html) 트레이트를 구현하는 것이 좋습니다. 이는 자동으로 " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html)을 제공" "할 뿐만 아니라, [`print!`](../hello/print.md) 섹션에서 다룬 것처럼 해당 타입" "을 출력할 수 있게 해줍니다." #: src/conversion/string.md:19 msgid "\"Circle of radius {}\"" msgstr "\"반지름이 {}인 원\"" #: src/conversion/string.md:29 msgid "Parsing a String" msgstr "문자열 파싱하기" #: src/conversion/string.md:31 msgid "" "It's useful to convert strings into many types, but one of the more common " "string operations is to convert them from string to number. The idiomatic " "approach to this is to use the [`parse`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) function and either to arrange for type " "inference or to specify the type to parse using the 'turbofish' syntax. Both " "alternatives are shown in the following example." msgstr "" "문자열을 여러 타입으로 변환하는 것은 유용하지만, 가장 흔한 작업 중 하나는 문" "자열을 숫자로 변환하는 것입니다. 이에 대한 관용적인 방법은 [`parse`](https://" "doc.rust-lang.org/std/primitive.str.html#method.parse) 함수를 사용하는 것이" "며, 타입 추론을 이용하거나 'turbofish' 구문을 사용하여 파싱할 타입을 지정할 " "수 있습니다. 다음 예제에 두 가지 방식이 모두 나와 있습니다." #: src/conversion/string.md:37 msgid "" "This will convert the string into the type specified as long as the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait is " "implemented for that type. This is implemented for numerous types within the " "standard library." msgstr "" "해당 타입에 대해 [`FromStr`](https://doc.rust-lang.org/std/str/" "trait.FromStr.html) 트레이트가 구현되어 있다면 문자열을 지정된 타입으로 변환" "합니다. 표준 라이브러리의 수많은 타입에 대해 이 트레이트가 구현되어 있습니다." #: src/conversion/string.md:43 src/std_misc/process/wait.md:10 msgid "\"5\"" msgstr "\"5\"" #: src/conversion/string.md:44 src/error/result.md:33 src/error/result.md:68 #: src/error/result/result_map.md:42 src/error/result/result_map.md:75 #: src/error/result/result_alias.md:36 src/error/result/early_returns.md:36 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:67 msgid "\"10\"" msgstr "\"10\"" #: src/conversion/string.md:47 msgid "\"Sum: {:?}\"" msgstr "\"합계: {:?}\"" #: src/conversion/string.md:51 msgid "" "To obtain this functionality on a user defined type simply implement the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "that type." msgstr "" "사용자 정의 타입에서 이 기능을 사용하려면 해당 타입에 대해 [`FromStr`]" "(https://doc.rust-lang.org/std/str/trait.FromStr.html) 트레이트를 구현하기만 " "하면 됩니다." #: src/conversion/string.md:74 msgid "\" 3 \"" msgstr "\" 3 \"" #: src/expression.md:3 msgid "A Rust program is (mostly) made up of a series of statements:" msgstr "Rust 프로그램은 (대부분) 일련의 문장(statements)으로 구성됩니다:" #: src/expression.md:7 msgid "" "// statement\n" " // statement\n" " // statement\n" msgstr "" "// 문장\n" " // 문장\n" " // 문장\n" #: src/expression.md:13 msgid "" "There are a few kinds of statements in Rust. The most common two are " "declaring a variable binding, and using a `;` with an expression:" msgstr "" "Rust에는 몇 가지 종류의 문장이 있습니다. 가장 흔한 두 가지는 변수 바인딩을 선" "언하는 것과 표현식에 `;`를 사용하는 것입니다:" #: src/expression.md:18 msgid "// variable binding\n" msgstr "// 변수 바인딩\n" #: src/expression.md:21 msgid "// expression;\n" msgstr "// 표현식;\n" #: src/expression.md:28 msgid "" "Blocks are expressions too, so they can be used as values in assignments. " "The last expression in the block will be assigned to the place expression " "such as a local variable. However, if the last expression of the block ends " "with a semicolon, the return value will be `()`." msgstr "" "블록도 표현식이므로 할당 시 값으로 사용될 수 있습니다. 블록의 마지막 표현식" "은 로컬 변수와 같은 장소 표현식(place expression)에 할당됩니다. 하지만 블록" "의 마지막 표현식이 세미콜론으로 끝나면 반환 값은 `()`가 됩니다." #: src/expression.md:41 msgid "// This expression will be assigned to `y`\n" msgstr "// 이 표현식은 `y`에 할당됩니다\n" #: src/expression.md:46 msgid "" "// The semicolon suppresses this expression and `()` is assigned to `z`\n" msgstr "// 세미콜론이 이 표현식을 억제하여 `z`에는 `()`가 할당됩니다\n" #: src/expression.md:50 msgid "\"x is {:?}\"" msgstr "\"x는 {:?}입니다\"" #: src/expression.md:51 msgid "\"y is {:?}\"" msgstr "\"y는 {:?}입니다\"" #: src/expression.md:52 msgid "\"z is {:?}\"" msgstr "\"z는 {:?}입니다\"" #: src/flow_control.md:3 msgid "" "An integral part of any programming language are ways to modify control " "flow: `if`/`else`, `for`, and others. Let's talk about them in Rust." msgstr "" "모든 프로그래밍 언어의 필수적인 부분은 제어 흐름을 수정하는 방법입니다: `if`/" "`else`, `for` 등. Rust에서의 제어 흐름에 대해 이야기해 봅시다." #: src/flow_control/if_else.md:3 msgid "" "Branching with `if`\\-`else` is similar to other languages. Unlike many of " "them, the boolean condition doesn't need to be surrounded by parentheses, " "and each condition is followed by a block. `if`\\-`else` conditionals are " "expressions, and, all branches must return the same type." msgstr "" "`if`\\-`else`를 사용한 분기는 다른 언어와 유사합니다. 많은 언어와 달리 불리" "언 조건은 괄호로 둘러쌀 필요가 없으며, 각 조건 뒤에는 블록이 옵니다. `if`\\-" "`else` 조건문은 표현식이며, 모든 분기는 동일한 타입을 반환해야 합니다." #: src/flow_control/if_else.md:13 msgid "\"{} is negative\"" msgstr "\"{}은(는) 음수입니다\"" #: src/flow_control/if_else.md:15 msgid "\"{} is positive\"" msgstr "\"{}은(는) 양수입니다\"" #: src/flow_control/if_else.md:17 msgid "\"{} is zero\"" msgstr "\"{}은(는) 0입니다\"" #: src/flow_control/if_else.md:22 msgid "\", and is a small number, increase ten-fold\"" msgstr "\", 그리고 작은 수이므로 10배 증가시킵니다\"" #: src/flow_control/if_else.md:24 msgid "// This expression returns an `i32`.\n" msgstr "// 이 표현식은 `i32`를 반환합니다.\n" #: src/flow_control/if_else.md:27 msgid "\", and is a big number, halve the number\"" msgstr "\", 그리고 큰 수이므로 반으로 나눕니다\"" #: src/flow_control/if_else.md:29 msgid "// This expression must return an `i32` as well.\n" msgstr "// 이 표현식 또한 `i32`를 반환해야 합니다.\n" #: src/flow_control/if_else.md:31 msgid "// TODO ^ Try suppressing this expression with a semicolon.\n" msgstr "// TODO ^ 세미콜론을 사용하여 이 표현식을 억제해 보세요.\n" #: src/flow_control/if_else.md:33 msgid "" "// ^ Don't forget to put a semicolon here! All `let` bindings need it.\n" msgstr "" "// ^ 여기에 세미콜론을 넣는 것을 잊지 마세요! 모든 `let` 바인딩에 필요합니" "다.\n" #: src/flow_control/if_else.md:35 src/flow_control/match.md:35 msgid "\"{} -> {}\"" msgstr "\"{} -> {}\"" #: src/flow_control/loop.md:3 msgid "Rust provides a `loop` keyword to indicate an infinite loop." msgstr "Rust는 무한 루프를 나타내기 위해 `loop` 키워드를 제공합니다." #: src/flow_control/loop.md:5 msgid "" "The `break` statement can be used to exit a loop at anytime, whereas the " "`continue` statement can be used to skip the rest of the iteration and start " "a new one." msgstr "" "`break` 문은 언제든지 루프를 종료하는 데 사용할 수 있으며, `continue` 문은 나" "머지 반복을 건너뛰고 새로운 반복을 시작하는 데 사용될 수 있습니다." #: src/flow_control/loop.md:13 msgid "\"Let's count until infinity!\"" msgstr "\"무한대까지 세어봅시다!\"" #: src/flow_control/loop.md:15 msgid "// Infinite loop\n" msgstr "// 무한 루프\n" #: src/flow_control/loop.md:20 msgid "\"three\"" msgstr "\"3\"" #: src/flow_control/loop.md:22 msgid "// Skip the rest of this iteration\n" msgstr "// 이번 반복의 나머지를 건너뜁니다\n" #: src/flow_control/loop.md:29 msgid "\"OK, that's enough\"" msgstr "\"좋아요, 그만하면 됐습니다\"" #: src/flow_control/loop.md:31 msgid "// Exit this loop\n" msgstr "// 이 루프를 종료합니다\n" #: src/flow_control/loop/nested.md:3 msgid "" "It's possible to `break` or `continue` outer loops when dealing with nested " "loops. In these cases, the loops must be annotated with some `'label`, and " "the label must be passed to the `break`/`continue` statement." msgstr "" "중첩 루프를 다룰 때 외부 루프를 `break`하거나 `continue`하는 것이 가능합니" "다. 이 경우 루프에는 어떤 `'label`을 붙여야 하며, 해당 레이블은 `break`/" "`continue` 문에 전달되어야 합니다." #: src/flow_control/loop/nested.md:12 msgid "\"Entered the outer loop\"" msgstr "\"외부 루프에 진입했습니다\"" #: src/flow_control/loop/nested.md:15 msgid "\"Entered the inner loop\"" msgstr "\"내부 루프에 진입했습니다\"" #: src/flow_control/loop/nested.md:17 msgid "" "// This would break only the inner loop\n" " //break;\n" msgstr "" "// 이것은 내부 루프만 종료시킵니다\n" " //break;\n" #: src/flow_control/loop/nested.md:20 msgid "// This breaks the outer loop\n" msgstr "// 이것은 외부 루프를 종료시킵니다\n" #: src/flow_control/loop/nested.md:24 msgid "\"This point will never be reached\"" msgstr "\"이 지점에는 결코 도달하지 않습니다\"" #: src/flow_control/loop/nested.md:27 msgid "\"Exited the outer loop\"" msgstr "\"외부 루프에서 나갔습니다\"" #: src/flow_control/loop/return.md:3 msgid "" "One of the uses of a `loop` is to retry an operation until it succeeds. If " "the operation returns a value though, you might need to pass it to the rest " "of the code: put it after the `break`, and it will be returned by the `loop` " "expression." msgstr "" "성공할 때까지 작업을 재시도하는 것이 `loop`의 용도 중 하나입니다. 만약 작업" "이 값을 반환한다면, 이를 코드의 나머지 부분으로 전달해야 할 수도 있습니다. " "`break` 뒤에 값을 넣으면 `loop` 표현식에 의해 그 값이 반환됩니다." #: src/flow_control/while.md:3 msgid "" "The `while` keyword can be used to run a loop while a condition is true." msgstr "" "`while` 키워드는 조건이 참(true)인 동안 루프를 실행하는 데 사용될 수 있습니" "다." #: src/flow_control/while.md:5 msgid "" "Let's write the infamous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) " "using a `while` loop." msgstr "" "악명 높은 [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz)를 `while` 루프" "를 사용하여 작성해 봅시다." #: src/flow_control/while.md:9 msgid "// A counter variable\n" msgstr "// 카운터 변수\n" #: src/flow_control/while.md:12 msgid "// Loop while `n` is less than 101\n" msgstr "// `n`이 101보다 작은 동안 루프 실행\n" #: src/flow_control/while.md:15 src/flow_control/for.md:17 #: src/flow_control/for.md:37 src/fn.md:34 msgid "\"fizzbuzz\"" msgstr "\"fizzbuzz\"" #: src/flow_control/while.md:17 src/flow_control/for.md:19 #: src/flow_control/for.md:39 src/fn.md:36 msgid "\"fizz\"" msgstr "\"fizz\"" #: src/flow_control/while.md:19 src/flow_control/for.md:21 #: src/flow_control/for.md:41 src/fn.md:38 msgid "\"buzz\"" msgstr "\"buzz\"" #: src/flow_control/while.md:24 msgid "// Increment counter\n" msgstr "// 카운터 증가\n" #: src/flow_control/for.md:1 msgid "for loops" msgstr "for 루프" #: src/flow_control/for.md:5 msgid "" "The `for in` construct can be used to iterate through an `Iterator`. One of " "the easiest ways to create an iterator is to use the range notation `a..b`. " "This yields values from `a` (inclusive) to `b` (exclusive) in steps of one." msgstr "" "`for in` 구문은 `Iterator`를 통해 반복하는 데 사용될 수 있습니다. 이터레이터" "를 만드는 가장 쉬운 방법 중 하나는 범위 표기법 `a..b`를 사용하는 것입니다. 이" "는 `a`(포함)부터 `b`(미포함)까지의 값을 1씩 증가시키며 생성합니다." #: src/flow_control/for.md:10 msgid "Let's write FizzBuzz using `for` instead of `while`." msgstr "`while` 대신 `for`를 사용하여 FizzBuzz를 작성해 봅시다." #: src/flow_control/for.md:14 src/flow_control/for.md:34 msgid "// `n` will take the values: 1, 2, ..., 100 in each iteration\n" msgstr "// 각 반복에서 `n`은 1, 2, ..., 100의 값을 갖게 됩니다.\n" #: src/flow_control/for.md:29 msgid "" "Alternatively, `a..=b` can be used for a range that is inclusive on both " "ends. The above can be written as:" msgstr "" "또는 양쪽 끝을 모두 포함하는 범위에는 `a..=b`를 사용할 수 있습니다. 위의 코드" "는 다음과 같이 작성될 수 있습니다:" #: src/flow_control/for.md:49 msgid "for and iterators" msgstr "for와 이터레이터" #: src/flow_control/for.md:51 msgid "" "The `for in` construct is able to interact with an `Iterator` in several " "ways. As discussed in the section on the [Iterator](../trait/iter.md) trait, " "by default the `for` loop will apply the `into_iter` function to the " "collection. However, this is not the only means of converting collections " "into iterators." msgstr "" "`for in` 구문은 여러 방식으로 `Iterator`와 상호작용할 수 있습니다. [Iterator]" "(../trait/iter.md) 트레이트 섹션에서 다룬 것처럼, 기본적으로 `for` 루프는 컬" "렉션에 `into_iter` 함수를 적용합니다. 하지만 이것이 컬렉션을 이터레이터로 변" "환하는 유일한 방법은 아닙니다." #: src/flow_control/for.md:56 msgid "" "`into_iter`, `iter` and `iter_mut` all handle the conversion of a collection " "into an iterator in different ways, by providing different views on the data " "within." msgstr "" "`into_iter`, `iter`, `iter_mut`은 모두 내부 데이터에 대해 서로 다른 뷰를 제공" "함으로써 컬렉션을 이터레이터로 변환하는 작업을 서로 다른 방식으로 처리합니다." #: src/flow_control/for.md:60 msgid "" "`iter` - This borrows each element of the collection through each iteration. " "Thus leaving the collection untouched and available for reuse after the loop." msgstr "" "`iter` - 매 반복마다 컬렉션의 각 요소를 빌려옵니다. 따라서 컬렉션은 수정되지 " "않은 상태로 유지되며 루프 이후에도 재사용할 수 있습니다." #: src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Frank\"" msgstr "\"프랭크\"" #: src/flow_control/for.md:65 src/flow_control/for.md:69 #: src/flow_control/for.md:85 src/flow_control/for.md:89 #: src/flow_control/for.md:104 src/flow_control/for.md:108 msgid "\"Ferris\"" msgstr "\"페리스\"" #: src/flow_control/for.md:69 src/flow_control/for.md:89 #: src/flow_control/for.md:108 msgid "\"There is a rustacean among us!\"" msgstr "\"우리 중에 러스타시안(rustacean)이 있습니다!\"" #: src/flow_control/for.md:70 msgid "// TODO ^ Try deleting the & and matching just \"Ferris\"\n" msgstr "// TODO ^ &를 삭제하고 그냥 \"Ferris\"와 매칭해 보세요\n" #: src/flow_control/for.md:71 src/flow_control/for.md:90 msgid "\"Hello {}\"" msgstr "\"안녕 {}\"" #: src/flow_control/for.md:75 src/flow_control/for.md:94 #: src/flow_control/for.md:113 msgid "\"names: {:?}\"" msgstr "\"이름들: {:?}\"" #: src/flow_control/for.md:79 msgid "" "`into_iter` - This consumes the collection so that on each iteration the " "exact data is provided. Once the collection has been consumed it is no " "longer available for reuse as it has been 'moved' within the loop." msgstr "" "`into_iter` - 컬렉션을 소비(consume)하여 각 반복마다 실제 데이터를 제공합니" "다. 컬렉션이 소비되면 루프 내에서 '이동(moved)'된 것이므로 더 이상 재사용할 " "수 없습니다." #: src/flow_control/for.md:99 msgid "" "`iter_mut` - This mutably borrows each element of the collection, allowing " "for the collection to be modified in place." msgstr "" "`iter_mut` - 컬렉션의 각 요소를 가변적으로 빌려와서, 컬렉션을 제자리에서 수정" "할 수 있게 합니다." #: src/flow_control/for.md:109 msgid "\"Hello\"" msgstr "\"안녕\"" #: src/flow_control/for.md:117 msgid "" "In the above snippets note the type of `match` branch, that is the key " "difference in the types of iteration. The difference in type then of course " "implies differing actions that are able to be performed." msgstr "" "위의 스니펫에서 `match` 분기의 타입에 주목하세요. 이것이 반복 방식의 핵심적" "인 차이점입니다. 타입의 차이는 물론 수행할 수 있는 작업의 차이를 의미합니다." #: src/flow_control/for.md:123 msgid "[Iterator](../trait/iter.md)" msgstr "[Iterator](../trait/iter.md)" #: src/flow_control/match.md:3 msgid "" "Rust provides pattern matching via the `match` keyword, which can be used " "like a C `switch`. The first matching arm is evaluated and all possible " "values must be covered." msgstr "" "Rust는 `match` 키워드를 통해 패턴 매칭을 제공하며, 이는 C의 `switch`처럼 사용" "될 수 있습니다. 첫 번째로 매칭되는 팔(arm)이 실행되며, 가능한 모든 값을 다뤄" "야 합니다." #: src/flow_control/match.md:10 msgid "// TODO ^ Try different values for `number`\n" msgstr "// TODO ^ `number`에 다른 값을 넣어보세요\n" #: src/flow_control/match.md:12 msgid "\"Tell me about {}\"" msgstr "\"{}에 대해 알려주세요\"" #: src/flow_control/match.md:14 msgid "// Match a single value\n" msgstr "// 단일 값 매칭\n" #: src/flow_control/match.md:15 msgid "\"One!\"" msgstr "\"1입니다!\"" #: src/flow_control/match.md:16 msgid "// Match several values\n" msgstr "// 여러 값 매칭\n" #: src/flow_control/match.md:17 msgid "\"This is a prime\"" msgstr "\"이것은 소수입니다\"" #: src/flow_control/match.md:18 msgid "" "// TODO ^ Try adding 13 to the list of prime values\n" " // Match an inclusive range\n" msgstr "" "// TODO ^ 소수 목록에 13을 추가해 보세요\n" " // 포함 범위를 매칭\n" #: src/flow_control/match.md:20 msgid "\"A teen\"" msgstr "\"10대입니다\"" #: src/flow_control/match.md:21 msgid "// Handle the rest of cases\n" msgstr "// 나머지 경우 처리\n" #: src/flow_control/match.md:22 msgid "\"Ain't special\"" msgstr "\"특별할 것 없습니다\"" #: src/flow_control/match.md:23 msgid "// TODO ^ Try commenting out this catch-all arm\n" msgstr "" "// TODO ^ 이 모든 경우를 처리하는 팔(catch-all arm)을 주석 처리해 보세요\n" #: src/flow_control/match.md:27 msgid "// Match is an expression too\n" msgstr "// Match도 표현식입니다\n" #: src/flow_control/match.md:29 msgid "// The arms of a match must cover all the possible values\n" msgstr "// match의 팔들은 가능한 모든 값을 다뤄야 합니다\n" #: src/flow_control/match.md:32 msgid "// TODO ^ Try commenting out one of these arms\n" msgstr "// TODO ^ 이 팔들 중 하나를 주석 처리해 보세요\n" #: src/flow_control/match/destructuring.md:3 msgid "A `match` block can destructure items in a variety of ways." msgstr "" "`match` 블록은 다양한 방식으로 아이템을 구조 분해(destructure)할 수 있습니다." #: src/flow_control/match/destructuring.md:5 msgid "[Destructuring Tuples](destructuring/destructure_tuple.md)" msgstr "[튜플 구조 분해](destructuring/destructure_tuple.md)" #: src/flow_control/match/destructuring.md:6 msgid "[Destructuring Arrays and Slices](destructuring/destructure_slice.md)" msgstr "[배열과 슬라이스 구조 분해](destructuring/destructure_slice.md)" #: src/flow_control/match/destructuring.md:7 msgid "[Destructuring Enums](destructuring/destructure_enum.md)" msgstr "[열거형 구조 분해](destructuring/destructure_enum.md)" #: src/flow_control/match/destructuring.md:8 msgid "[Destructuring Pointers](destructuring/destructure_pointers.md)" msgstr "[포인터 구조 분해](destructuring/destructure_pointers.md)" #: src/flow_control/match/destructuring.md:9 msgid "[Destructuring Structures](destructuring/destructure_structures.md)" msgstr "[구조체 구조 분해](destructuring/destructure_structures.md)" #: src/flow_control/match/destructuring.md:19 msgid "" "[The Rust Reference for Destructuring](https://doc.rust-lang.org/reference/" "patterns.html#r-patterns.destructure)" msgstr "" "[구조 분해에 관한 Rust 레퍼런스](https://doc.rust-lang.org/reference/" "patterns.html#r-patterns.destructure)" #: src/flow_control/match/destructuring/destructure_tuple.md:3 msgid "Tuples can be destructured in a `match` as follows:" msgstr "튜플은 `match`에서 다음과 같이 구조 분해될 수 있습니다:" #: src/flow_control/match/destructuring/destructure_tuple.md:8 msgid "// TODO ^ Try different values for `triple`\n" msgstr "// TODO ^ `triple`에 다른 값을 넣어보세요\n" #: src/flow_control/match/destructuring/destructure_tuple.md:10 msgid "\"Tell me about {:?}\"" msgstr "\"{:?}에 대해 알려주세요\"" #: src/flow_control/match/destructuring/destructure_tuple.md:11 msgid "// Match can be used to destructure a tuple\n" msgstr "// match를 사용하여 튜플을 구조 분해할 수 있습니다\n" #: src/flow_control/match/destructuring/destructure_tuple.md:13 msgid "// Destructure the second and third elements\n" msgstr "// 두 번째와 세 번째 요소를 구조 분해합니다\n" #: src/flow_control/match/destructuring/destructure_tuple.md:14 msgid "\"First is `0`, `y` is {:?}, and `z` is {:?}\"" msgstr "\"첫 번째는 `0`이고, `y`는 {:?}, `z`는 {:?}입니다\"" #: src/flow_control/match/destructuring/destructure_tuple.md:15 msgid "\"First is `1` and the rest doesn't matter\"" msgstr "\"첫 번째는 `1`이고 나머지는 상관없습니다\"" #: src/flow_control/match/destructuring/destructure_tuple.md:16 msgid "\"last is `2` and the rest doesn't matter\"" msgstr "\"마지막은 `2`이고 나머지는 상관없습니다\"" #: src/flow_control/match/destructuring/destructure_tuple.md:17 msgid "\"First is `3`, last is `4`, and the rest doesn't matter\"" msgstr "\"첫 번째는 `3`, 마지막은 `4`이며 나머지는 상관없습니다\"" #: src/flow_control/match/destructuring/destructure_tuple.md:18 msgid "// `..` can be used to ignore the rest of the tuple\n" msgstr "// `..`을 사용하여 튜플의 나머지를 무시할 수 있습니다\n" #: src/flow_control/match/destructuring/destructure_tuple.md:19 msgid "\"It doesn't matter what they are\"" msgstr "\"그것들이 무엇이든 상관없습니다\"" #: src/flow_control/match/destructuring/destructure_tuple.md:20 msgid "// `_` means don't bind the value to a variable\n" msgstr "// `_`는 값을 변수에 바인딩하지 않음을 의미합니다\n" #: src/flow_control/match/destructuring/destructure_tuple.md:27 msgid "[Tuples](../../../primitives/tuples.md)" msgstr "[튜플](../../../primitives/tuples.md)" #: src/flow_control/match/destructuring/destructure_slice.md:3 msgid "Like tuples, arrays and slices can be destructured this way:" msgstr "" "튜플과 마찬가지로, 배열과 슬라이스도 다음과 같은 방식으로 구조 분해될 수 있습" "니다:" #: src/flow_control/match/destructuring/destructure_slice.md:7 msgid "// Try changing the values in the array, or make it a slice!\n" msgstr "// 배열의 값을 변경하거나 슬라이스로 만들어 보세요!\n" #: src/flow_control/match/destructuring/destructure_slice.md:11 msgid "" "// Binds the second and the third elements to the respective variables\n" msgstr "// 두 번째와 세 번째 요소를 각각의 변수에 바인딩합니다\n" #: src/flow_control/match/destructuring/destructure_slice.md:13 msgid "\"array[0] = 0, array[1] = {}, array[2] = {}\"" msgstr "\"array[0] = 0, array[1] = {}, array[2] = {}\"" #: src/flow_control/match/destructuring/destructure_slice.md:15 msgid "// Single values can be ignored with _\n" msgstr "// 단일 값은 _로 무시할 수 있습니다\n" #: src/flow_control/match/destructuring/destructure_slice.md:17 msgid "\"array[0] = 1, array[2] = {} and array[1] was ignored\"" msgstr "\"array[0] = 1, array[2] = {} 이고 array[1]은 무시되었습니다\"" #: src/flow_control/match/destructuring/destructure_slice.md:21 msgid "// You can also bind some and ignore the rest\n" msgstr "// 일부만 바인딩하고 나머지는 무시할 수도 있습니다\n" #: src/flow_control/match/destructuring/destructure_slice.md:23 msgid "\"array[0] = -1, array[1] = {} and all the other ones were ignored\"" msgstr "\"array[0] = -1, array[1] = {} 이고 다른 모든 것들은 무시되었습니다\"" #: src/flow_control/match/destructuring/destructure_slice.md:26 msgid "" "// The code below would not compile\n" " // [-1, second] => ...\n" msgstr "" "// 아래 코드는 컴파일되지 않습니다\n" " // [-1, second] => ...\n" #: src/flow_control/match/destructuring/destructure_slice.md:29 msgid "" "// Or store them in another array/slice (the type depends on\n" " // that of the value that is being matched against)\n" msgstr "" "// 또는 다른 배열/슬라이스에 저장할 수도 있습니다 (타입은 매칭되는 값의 타입" "에 따라 달라집니다)\n" #: src/flow_control/match/destructuring/destructure_slice.md:32 msgid "\"array[0] = 3, array[1] = {} and the other elements were {:?}\"" msgstr "\"array[0] = 3, array[1] = {} 이고 다른 요소들은 {:?}입니다\"" #: src/flow_control/match/destructuring/destructure_slice.md:36 msgid "" "// Combining these patterns, we can, for example, bind the first and\n" " // last values, and store the rest of them in a single array\n" msgstr "" "// 이러한 패턴들을 결합하여, 예를 들어 첫 번째와 마지막 값을 바인딩하고 나머" "지는 하나의 배열에 저장할 수 있습니다\n" #: src/flow_control/match/destructuring/destructure_slice.md:39 msgid "\"array[0] = {}, middle = {:?}, array[2] = {}\"" msgstr "\"array[0] = {}, middle = {:?}, array[2] = {}\"" #: src/flow_control/match/destructuring/destructure_slice.md:48 msgid "" "[Arrays and Slices](../../../primitives/array.md) and [Binding](../" "binding.md) for `@` sigil" msgstr "" "[배열과 슬라이스](../../../primitives/array.md) 그리고 `@` 기호를 사용한 [바" "인딩](../binding.md)" #: src/flow_control/match/destructuring/destructure_enum.md:3 msgid "An `enum` is destructured similarly:" msgstr "`enum`도 비슷하게 구조 분해됩니다:" #: src/flow_control/match/destructuring/destructure_enum.md:6 msgid "" "// `allow` required to silence warnings because only\n" "// one variant is used.\n" msgstr "" "// 단 하나의 변체만 사용되므로 경고를 억제하기 위해 `allow`가 필요합니다.\n" #: src/flow_control/match/destructuring/destructure_enum.md:10 msgid "// These 3 are specified solely by their name.\n" msgstr "// 이 세 가지는 오직 이름으로만 지정됩니다.\n" #: src/flow_control/match/destructuring/destructure_enum.md:14 msgid "// These likewise tie `u32` tuples to different names: color models.\n" msgstr "" "// 이들은 마찬가지로 `u32` 튜플을 서로 다른 이름(컬러 모델)에 연결합니다.\n" #: src/flow_control/match/destructuring/destructure_enum.md:24 msgid "// TODO ^ Try different variants for `color`\n" msgstr "// TODO ^ `color`에 다른 변체들을 넣어보세요\n" #: src/flow_control/match/destructuring/destructure_enum.md:26 msgid "\"What color is it?\"" msgstr "\"이것은 무슨 색인가요?\"" #: src/flow_control/match/destructuring/destructure_enum.md:27 msgid "// An `enum` can be destructured using a `match`.\n" msgstr "// `match`를 사용하여 `enum`을 구조 분해할 수 있습니다.\n" #: src/flow_control/match/destructuring/destructure_enum.md:29 msgid "\"The color is Red!\"" msgstr "\"빨간색입니다!\"" #: src/flow_control/match/destructuring/destructure_enum.md:30 msgid "\"The color is Blue!\"" msgstr "\"파란색입니다!\"" #: src/flow_control/match/destructuring/destructure_enum.md:31 msgid "\"The color is Green!\"" msgstr "\"초록색입니다!\"" #: src/flow_control/match/destructuring/destructure_enum.md:33 msgid "\"Red: {}, green: {}, and blue: {}!\"" msgstr "\"빨강: {}, 초록: {}, 파랑: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:35 msgid "\"Hue: {}, saturation: {}, value: {}!\"" msgstr "\"색상: {}, 채도: {}, 명도: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:37 msgid "\"Hue: {}, saturation: {}, lightness: {}!\"" msgstr "\"색상: {}, 채도: {}, 밝기: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:39 msgid "\"Cyan: {}, magenta: {}, yellow: {}!\"" msgstr "\"청록: {}, 자주: {}, 노랑: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:41 msgid "\"Cyan: {}, magenta: {}, yellow: {}, key (black): {}!\"" msgstr "\"청록: {}, 자주: {}, 노랑: {}, 검정: {}!\"" #: src/flow_control/match/destructuring/destructure_enum.md:43 msgid "// Don't need another arm because all variants have been examined\n" msgstr "// 모든 변체를 검사했으므로 다른 팔(arm)은 필요하지 않습니다.\n" #: src/flow_control/match/destructuring/destructure_enum.md:50 msgid "" "[`#[allow(...)]`](../../../attribute/unused.md), [color models](https://" "en.wikipedia.org/wiki/Color_model) and [`enum`](../../../custom_types/" "enum.md)" msgstr "" "[`#[allow(...)]`](../../../attribute/unused.md), [컬러 모델](https://" "en.wikipedia.org/wiki/Color_model) 및 [`enum`](../../../custom_types/enum.md)" #: src/flow_control/match/destructuring/destructure_pointers.md:3 msgid "" "For pointers, a distinction needs to be made between destructuring and " "dereferencing as they are different concepts which are used differently from " "languages like C/C++." msgstr "" "포인터의 경우, 구조 분해(destructuring)와 역참조(dereferencing)를 구분해야 합" "니다. 이들은 C/C++와 같은 언어와는 다르게 사용되는 서로 다른 개념이기 때문입" "니다." #: src/flow_control/match/destructuring/destructure_pointers.md:7 msgid "Dereferencing uses `*`" msgstr "역참조는 `*`를 사용합니다" #: src/flow_control/match/destructuring/destructure_pointers.md:8 msgid "Destructuring uses `&`, `ref`, and `ref mut`" msgstr "구조 분해는 `&`, `ref`, `ref mut`을 사용합니다" #: src/flow_control/match/destructuring/destructure_pointers.md:12 msgid "" "// Assign a reference of type `i32`. The `&` signifies there\n" " // is a reference being assigned.\n" msgstr "" "// `i32` 타입의 참조를 할당합니다. `&`는 참조가 할당되고 있음을 나타냅니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:17 msgid "" "// If `reference` is pattern matched against `&val`, it results\n" " // in a comparison like:\n" " // `&i32`\n" " // `&val`\n" " // ^ We see that if the matching `&`s are dropped, then the `i32`\n" " // should be assigned to `val`.\n" msgstr "" "// 만약 `reference`를 `&val`에 대해 패턴 매칭하면, 다음과 같은 비교 결과가 됩" "니다:\n" "// `&i32`\n" "// `&val`\n" "// ^ 매칭되는 `&`들을 떼어내면, `i32`가 `val`에 할당되어야 함을 알 수 있습니" "다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:23 msgid "\"Got a value via destructuring: {:?}\"" msgstr "\"구조 분해를 통해 값을 얻었습니다: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:26 msgid "// To avoid the `&`, you dereference before matching.\n" msgstr "// `&`를 피하려면, 매칭하기 전에 역참조를 수행합니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:28 msgid "\"Got a value via dereferencing: {:?}\"" msgstr "\"역참조를 통해 값을 얻었습니다: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:31 msgid "" "// What if you don't start with a reference? `reference` was a `&`\n" " // because the right side was already a reference. This is not\n" " // a reference because the right side is not one.\n" msgstr "" "// 참조로 시작하지 않는다면 어떨까요? `reference`는 오른쪽이 이미\n" "// 참조였기 때문에 `&`였습니다. 이것은 오른쪽이 참조가 아니기 때문에\n" "// 참조가 아닙니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:36 msgid "" "// Rust provides `ref` for exactly this purpose. It modifies the\n" " // assignment so that a reference is created for the element; this\n" " // reference is assigned.\n" msgstr "" "// Rust는 정확히 이 목적을 위해 `ref`를 제공합니다. 이는 할당 방식을\n" "// 수정하여 요소에 대한 참조가 생성되도록 하며, 이 참조가 할당됩니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:41 msgid "" "// Accordingly, by defining 2 values without references, references\n" " // can be retrieved via `ref` and `ref mut`.\n" msgstr "" "// 따라서, 참조가 없는 두 값을 정의함으로써, `ref`와 `ref mut`를 통해 참조를 " "가져올 수 있습니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:46 msgid "// Use `ref` keyword to create a reference.\n" msgstr "// 참조를 생성하려면 `ref` 키워드를 사용합니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:48 msgid "\"Got a reference to a value: {:?}\"" msgstr "\"값에 대한 참조를 얻었습니다: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:51 msgid "// Use `ref mut` similarly.\n" msgstr "// `ref mut`도 비슷하게 사용합니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:54 msgid "" "// Got a reference. Gotta dereference it before we can\n" " // add anything to it.\n" msgstr "" "// 참조를 얻었습니다. 여기에 무언가를 더하기 전에\n" "// 역참조를 해야 합니다.\n" #: src/flow_control/match/destructuring/destructure_pointers.md:57 msgid "\"We added 10. `mut_value`: {:?}\"" msgstr "\"10을 더했습니다. `mut_value`: {:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:65 msgid "[The ref pattern](../../../scope/borrow/ref.md)" msgstr "[ref 패턴](../../../scope/borrow/ref.md)" #: src/flow_control/match/destructuring/destructure_structures.md:3 msgid "Similarly, a `struct` can be destructured as shown:" msgstr "마찬가지로, `struct`는 다음과 같이 구조 분해될 수 있습니다:" #: src/flow_control/match/destructuring/destructure_structures.md:12 msgid "// Try changing the values in the struct to see what happens\n" msgstr "// 구조체의 값을 변경하여 어떤 일이 일어나는지 확인해 보세요\n" #: src/flow_control/match/destructuring/destructure_structures.md:16 msgid "\"First of x is 1, b = {}, y = {} \"" msgstr "\"x의 첫 번째는 1이고, b = {}, y = {} 입니다\"" #: src/flow_control/match/destructuring/destructure_structures.md:18 msgid "" "// you can destructure structs and rename the variables,\n" " // the order is not important\n" msgstr "" "// 구조체를 구조 분해하고 변수 이름을 바꿀 수 있으며, 순서는 중요하지 않습니" "다\n" #: src/flow_control/match/destructuring/destructure_structures.md:20 msgid "\"y is 2, i = {:?}\"" msgstr "\"y는 2이고, i = {:?}입니다\"" #: src/flow_control/match/destructuring/destructure_structures.md:22 msgid "// and you can also ignore some variables:\n" msgstr "// 그리고 일부 변수를 무시할 수도 있습니다:\n" #: src/flow_control/match/destructuring/destructure_structures.md:23 msgid "\"y = {}, we don't care about x\"" msgstr "\"y = {}이며, x는 신경 쓰지 않습니다\"" #: src/flow_control/match/destructuring/destructure_structures.md:24 msgid "" "// this will give an error: pattern does not mention field `x`\n" " //Foo { y } => println!(\"y = {}\", y),\n" msgstr "" "// 이것은 에러를 발생시킵니다: 패턴에 `x` 필드가 언급되지 않았습니다\n" "//Foo { y } => println!(\"y = {}\", y),\n" #: src/flow_control/match/destructuring/destructure_structures.md:30 msgid "// You do not need a match block to destructure structs:\n" msgstr "" "// 구조체를 구조 분해하기 위해 반드시 match 블록이 필요한 것은 아닙니다:\n" #: src/flow_control/match/destructuring/destructure_structures.md:32 msgid "\"Outside: x0 = {x0:?}, y0 = {y0}\"" msgstr "\"외부: x0 = {x0:?}, y0 = {y0}\"" #: src/flow_control/match/destructuring/destructure_structures.md:34 msgid "// Destructuring works with nested structs as well:\n" msgstr "// 구조 분해는 중첩된 구조체에서도 작동합니다:\n" #: src/flow_control/match/destructuring/destructure_structures.md:41 msgid "\"Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}\"" msgstr "\"중첩됨: nested_x = {nested_x:?}, nested_y = {nested_y:?}\"" #: src/flow_control/match/destructuring/destructure_structures.md:47 msgid "[Structs](../../../custom_types/structs.md)" msgstr "[구조체](../../../custom_types/structs.md)" #: src/flow_control/match/guard.md:3 msgid "A `match` _guard_ can be added to filter the arm." msgstr "" "매치 팔(arm)을 필터링하기 위해 `match` _가드(guard)_를 추가할 수 있습니다." #: src/flow_control/match/guard.md:14 msgid "// ^ TODO try different values for `temperature`\n" msgstr "// ^ TODO `temperature`에 다른 값을 시도해 보세요\n" #: src/flow_control/match/guard.md:17 msgid "\"{}C is above 30 Celsius\"" msgstr "\"{}C는 섭씨 30도 초과입니다\"" #: src/flow_control/match/guard.md:18 msgid "// The `if condition` part ^ is a guard\n" msgstr "// `if 조건` 부분 ^ 이 가드입니다\n" #: src/flow_control/match/guard.md:19 msgid "\"{}C is equal to or below 30 Celsius\"" msgstr "\"{}C는 섭씨 30도 이하입니다\"" #: src/flow_control/match/guard.md:21 msgid "\"{}F is above 86 Fahrenheit\"" msgstr "\"{}F는 화씨 86도 초과입니다\"" #: src/flow_control/match/guard.md:22 msgid "\"{}F is equal to or below 86 Fahrenheit\"" msgstr "\"{}F는 화씨 86도 이하입니다\"" #: src/flow_control/match/guard.md:27 msgid "" "Note that the compiler won't take guard conditions into account when " "checking if all patterns are covered by the match expression." msgstr "" "컴파일러는 매치 표현식이 모든 패턴을 다루고 있는지 확인할 때 가드 조건을 고려" "하지 않는다는 점에 유의하세요." #: src/flow_control/match/guard.md:35 msgid "\"Zero\"" msgstr "\"0\"" #: src/flow_control/match/guard.md:36 msgid "\"Greater than zero\"" msgstr "\"0보다 큼\"" #: src/flow_control/match/guard.md:37 msgid "" "// _ => unreachable!(\"Should never happen.\"),\n" " // TODO ^ uncomment to fix compilation\n" msgstr "" "// _ => unreachable!(\"절대 일어날 수 없는 일입니다.\"),\n" "// TODO ^ 컴파일을 수정하려면 주석을 해제하세요\n" #: src/flow_control/match/guard.md:45 msgid "" "[Tuples](../../primitives/tuples.md) [Enums](../../custom_types/enum.md)" msgstr "" "[튜플](../../primitives/tuples.md) [열거형](../../custom_types/enum.md)" #: src/flow_control/match/binding.md:3 msgid "" "Indirectly accessing a variable makes it impossible to branch and use that " "variable without re-binding. `match` provides the `@` sigil for binding " "values to names:" msgstr "" "변수에 간접적으로 접근하면 재바인딩 없이 해당 변수를 분기하고 사용하는 것이 " "불가능합니다. `match`는 값을 이름에 바인딩하기 위한 `@` 기호를 제공합니다:" #: src/flow_control/match/binding.md:8 msgid "// A function `age` which returns a `u32`.\n" msgstr "// `u32`를 반환하는 `age` 함수.\n" #: src/flow_control/match/binding.md:14 msgid "\"Tell me what type of person you are\"" msgstr "\"당신이 어떤 종류의 사람인지 말해주세요\"" #: src/flow_control/match/binding.md:17 msgid "\"I haven't celebrated my first birthday yet\"" msgstr "\"아직 첫 번째 생일을 맞이하지 않았습니다\"" #: src/flow_control/match/binding.md:18 msgid "" "// Could `match` 1 ..= 12 directly but then what age\n" " // would the child be?\n" " // Could `match` n and use an `if` guard, but would\n" " // not contribute to exhaustiveness checks.\n" " // (Although in this case that would not matter since\n" " // a \"catch-all\" pattern is present at the bottom)\n" " // Instead, bind to `n` for the sequence of 1 ..= 12.\n" " // Now the age can be reported.\n" msgstr "" "// 1 ..= 12를 직접 `match`할 수 있지만, 그러면\n" "// 아이의 나이가 몇 살인지 알 수 있을까요?\n" "// n을 `match`하고 `if` 가드를 사용할 수 있지만,\n" "// 이는 철저함(exhaustiveness) 검사에 기여하지 않습니다.\n" "// (비록 이 경우에는 하단에 \"catch-all\" 패턴이 있어 상관없지만요)\n" "// 대신, 1 ..= 12 시퀀스에 대해 `n`에 바인딩합니다.\n" "// 이제 나이를 보고할 수 있습니다.\n" #: src/flow_control/match/binding.md:26 msgid "\"I'm a child of age {:?}\"" msgstr "\"저는 {:?}살인 어린이입니다\"" #: src/flow_control/match/binding.md:27 src/flow_control/match/binding.md:29 msgid "\"I'm a teen of age {:?}\"" msgstr "\"저는 {:?}살인 청소년입니다\"" #: src/flow_control/match/binding.md:28 msgid "// A similar binding can be done when matching several values.\n" msgstr "// 여러 값을 매칭할 때도 유사한 바인딩을 수행할 수 있습니다.\n" #: src/flow_control/match/binding.md:30 msgid "// Nothing bound. Return the result.\n" msgstr "// 바인딩된 것이 없습니다. 결과를 반환합니다.\n" #: src/flow_control/match/binding.md:31 msgid "\"I'm an old person of age {:?}\"" msgstr "\"저는 {:?}살인 어르신입니다\"" #: src/flow_control/match/binding.md:36 msgid "" "You can also use binding to \"destructure\" `enum` variants, such as " "`Option`:" msgstr "" "또한 `Option`과 같은 `enum` 변체를 \"구조 분해\"하기 위해 바인딩을 사용할 수 " "있습니다:" #: src/flow_control/match/binding.md:45 msgid "" "// Got `Some` variant, match if its value, bound to `n`,\n" " // is equal to 42.\n" " // Could also use `Some(42)` and print `\"The Answer: 42!\"`\n" " // but that would require changing `42` in 2 spots should\n" " // you ever wish to change it.\n" " // Could also use `Some(n) if n == 42` and print `\"The Answer: {n}!" "\"`\n" " // but that would not contribute to exhaustiveness checks.\n" " // (Although in this case that would not matter since\n" " // the next arm is a \"catch-all\" pattern)\n" msgstr "" "// `Some` 변체를 얻었을 때, `n`에 바인딩된 그 값이\n" "// 42와 같은지 매칭합니다.\n" "// `Some(42)`를 사용하여 `\"정답: 42!\"`를 출력할 수도 있지만,\n" "// 그러면 나중에 값을 바꾸고 싶을 때 두 군데를 수정해야 합니다.\n" "// `Some(n) if n == 42`를 사용하여 `\"정답: {n}!\"`를 출력할 수도 있지만,\n" "// 이는 철저함 검사에 기여하지 않습니다.\n" "// (비록 이 경우에는 다음 팔이 \"catch-all\" 패턴이라 상관없지만요)\n" #: src/flow_control/match/binding.md:54 msgid "\"The Answer: {}!\"" msgstr "\"정답: {}!\"" #: src/flow_control/match/binding.md:55 msgid "// Match any other number.\n" msgstr "// 다른 모든 숫자 매칭.\n" #: src/flow_control/match/binding.md:56 msgid "\"Not interesting... {}\"" msgstr "\"흥미롭지 않네요... {}\"" #: src/flow_control/match/binding.md:57 msgid "// Match anything else (`None` variant).\n" msgstr "// 그 외의 모든 경우(`None` 변체) 매칭.\n" #: src/flow_control/match/binding.md:65 msgid "" "[`functions`](../../fn.md), [`enums`](../../custom_types/enum.md) and " "[`Option`](../../std/option.md)" msgstr "" "[`함수`](../../fn.md), [`열거형`](../../custom_types/enum.md) 그리고 " "[`Option`](../../std/option.md)" #: src/flow_control/if_let.md:3 msgid "" "For some use cases, when matching enums, `match` is awkward. For example:" msgstr "" "어떤 경우에는 열거형을 매칭할 때 `match`가 어색할 수 있습니다. 예를 들어:" #: src/flow_control/if_let.md:6 src/flow_control/while_let.md:7 #: src/flow_control/while_let.md:35 msgid "// Make `optional` of type `Option`\n" msgstr "// `Option` 타입의 `optional` 생성\n" #: src/flow_control/if_let.md:10 msgid "\"This is a really long string and `{:?}`\"" msgstr "\"이것은 정말 긴 문자열이며 `{:?}`입니다\"" #: src/flow_control/if_let.md:12 msgid "" "// ^ Required because `match` is exhaustive. Doesn't it seem\n" " // like wasted space?\n" msgstr "" "// ^ `match`는 철저해야(exhaustive) 하기 때문에 필요합니다. 공간 낭비처럼\n" "// 보이진 않나요?\n" #: src/flow_control/if_let.md:18 msgid "" "`if let` is cleaner for this use case and in addition allows various failure " "options to be specified:" msgstr "" "이런 경우 `if let`이 더 깔끔하며, 추가로 다양한 실패 옵션을 지정할 수 있습니" "다:" #: src/flow_control/if_let.md:23 msgid "// All have type `Option`\n" msgstr "// 모두 `Option` 타입입니다\n" #: src/flow_control/if_let.md:28 msgid "" "// The `if let` construct reads: \"if `let` destructures `number` into\n" " // `Some(i)`, evaluate the block (`{}`).\n" msgstr "" "// `if let` 구문은 다음과 같이 읽힙니다: \"만약 `let`이 `number`를\n" "// `Some(i)`로 구조 분해한다면, 블록(`{}`)을 실행하라.\"\n" #: src/flow_control/if_let.md:31 src/flow_control/if_let.md:36 #: src/flow_control/if_let.md:46 msgid "\"Matched {:?}!\"" msgstr "\"{:?}가 매칭되었습니다!\"" #: src/flow_control/if_let.md:34 msgid "// If you need to specify a failure, use an else:\n" msgstr "// 실패한 경우를 지정해야 한다면, else를 사용하세요:\n" #: src/flow_control/if_let.md:38 msgid "// Destructure failed. Change to the failure case.\n" msgstr "// 구조 분해에 실패했습니다. 실패 사례로 전환합니다.\n" #: src/flow_control/if_let.md:39 src/flow_control/if_let.md:50 msgid "\"Didn't match a number. Let's go with a letter!\"" msgstr "\"숫자와 매칭되지 않았습니다. 문자로 해봅시다!\"" #: src/flow_control/if_let.md:42 msgid "// Provide an altered failing condition.\n" msgstr "// 변경된 실패 조건을 제공합니다.\n" #: src/flow_control/if_let.md:47 msgid "" "// Destructure failed. Evaluate an `else if` condition to see if the\n" " // alternate failure branch should be taken:\n" msgstr "" "// 구조 분해에 실패했습니다. 다른 실패 분기를 타야 하는지\n" "// `else if` 조건을 평가합니다:\n" #: src/flow_control/if_let.md:52 msgid "// The condition evaluated false. This branch is the default:\n" msgstr "// 조건이 거짓(false)으로 평가되었습니다. 이 분기가 기본입니다:\n" #: src/flow_control/if_let.md:53 msgid "\"I don't like letters. Let's go with an emoticon :)!\"" msgstr "\"문자는 별로예요. 이모티콘 :)으로 가봅시다!\"" #: src/flow_control/if_let.md:58 msgid "In the same way, `if let` can be used to match any enum value:" msgstr "" "같은 방식으로, `if let`은 모든 열거형 값을 매칭하는 데 사용될 수 있습니다:" #: src/flow_control/if_let.md:61 msgid "// Our example enum\n" msgstr "// 예제 열거형\n" #: src/flow_control/if_let.md:69 msgid "// Create example variables\n" msgstr "// 예제 변수 생성\n" #: src/flow_control/if_let.md:74 src/flow_control/if_let.md:110 msgid "// Variable a matches Foo::Bar\n" msgstr "// 변수 a는 Foo::Bar와 매칭됩니다\n" #: src/flow_control/if_let.md:76 src/flow_control/if_let.md:113 msgid "\"a is foobar\"" msgstr "\"a는 foobar입니다\"" #: src/flow_control/if_let.md:79 msgid "" "// Variable b does not match Foo::Bar\n" " // So this will print nothing\n" msgstr "" "// 변수 b는 Foo::Bar와 매칭되지 않습니다\n" "// 따라서 아무것도 출력되지 않습니다\n" #: src/flow_control/if_let.md:82 msgid "\"b is foobar\"" msgstr "\"b는 foobar입니다\"" #: src/flow_control/if_let.md:85 msgid "" "// Variable c matches Foo::Qux which has a value\n" " // Similar to Some() in the previous example\n" msgstr "" "// 변수 c는 값을 가진 Foo::Qux와 매칭됩니다\n" "// 앞선 예제의 Some()과 유사합니다\n" #: src/flow_control/if_let.md:88 msgid "\"c is {}\"" msgstr "\"c는 {}입니다\"" #: src/flow_control/if_let.md:91 msgid "// Binding also works with `if let`\n" msgstr "// 바인딩은 `if let`에서도 작동합니다\n" #: src/flow_control/if_let.md:93 msgid "\"c is one hundred\"" msgstr "\"c는 100입니다\"" #: src/flow_control/if_let.md:98 msgid "" "Another benefit is that `if let` allows us to match non-parameterized enum " "variants. This is true even in cases where the enum doesn't implement or " "derive `PartialEq`. In such cases `if Foo::Bar == a` would fail to compile, " "because instances of the enum cannot be equated, however `if let` will " "continue to work." msgstr "" "또 다른 장점은 `if let`을 사용하면 파라미터가 없는 열거형 변체도 매칭할 수 있" "다는 점입니다. 이는 열거형이 `PartialEq`를 구현하거나 유도하지 않는 경우에도 " "마찬가지입니다. 이러한 경우 `if Foo::Bar == a`는 열거형 인스턴스를 비교할 수 " "없기 때문에 컴파일에 실패하지만, `if let`은 계속 작동합니다." #: src/flow_control/if_let.md:100 msgid "Would you like a challenge? Fix the following example to use `if let`:" msgstr "도전해 보시겠습니까? 다음 예제를 `if let`을 사용하도록 수정해 보세요:" #: src/flow_control/if_let.md:103 msgid "" "// This enum purposely neither implements nor derives PartialEq.\n" "// That is why comparing Foo::Bar == a fails below.\n" msgstr "" "// 이 열거형은 의도적으로 PartialEq를 구현하거나 유도(derive)하지 않았습니" "다.\n" "// 그래서 아래에서 Foo::Bar == a 를 비교하는 것이 실패합니다.\n" #: src/flow_control/if_let.md:112 msgid "// ^-- this causes a compile-time error. Use `if let` instead.\n" msgstr "" "// ^-- 이것은 컴파일 타임 에러를 발생시킵니다. 대신 `if let`을 사용하세요.\n" #: src/flow_control/if_let.md:120 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/160)" msgstr "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), 그리고 [RFC]" "(https://github.com/rust-lang/rfcs/pull/160)" #: src/flow_control/let_else.md:3 msgid "🛈 stable since: rust 1.65" msgstr "🛈 안정화 버전: rust 1.65" #: src/flow_control/let_else.md:5 msgid "" "🛈 you can target specific edition by compiling like this `rustc --" "edition=2021 main.rs`" msgstr "" "🛈 다음과 같이 컴파일하여 특정 에디션을 타겟팅할 수 있습니다: `rustc --" "edition=2021 main.rs`" #: src/flow_control/let_else.md:8 msgid "" "With `let`\\-`else`, a refutable pattern can match and bind variables in the " "surrounding scope like a normal `let`, or else diverge (e.g. `break`, " "`return`, `panic!`) when the pattern doesn't match." msgstr "" "`let`\\-`else`를 사용하면, 일반적인 `let`처럼 주변 스코프에서 변수를 매칭하" "고 바인딩할 수 있으며, 패턴이 매칭되지 않을 경우 분기(예: `break`, `return`, " "`panic!`)할 수 있습니다." #: src/flow_control/let_else.md:16 src/flow_control/let_else.md:39 #: src/std/str.md:41 msgid "' '" msgstr "' '" #: src/flow_control/let_else.md:18 src/flow_control/let_else.md:42 msgid "\"Can't segment count item pair: '{s}'\"" msgstr "\"카운트 아이템 쌍을 분리할 수 없습니다: '{s}'\"" #: src/flow_control/let_else.md:21 src/flow_control/let_else.md:47 msgid "\"Can't parse integer: '{count_str}'\"" msgstr "\"정수를 파싱할 수 없습니다: '{count_str}'\"" #: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52 msgid "\"3 chairs\"" msgstr "\"3 chairs\"" #: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52 msgid "\"chairs\"" msgstr "\"chairs\"" #: src/flow_control/let_else.md:31 msgid "" "The scope of name bindings is the main thing that makes this different from " "`match` or `if let`\\-`else` expressions. You could previously approximate " "these patterns with an unfortunate bit of repetition and an outer `let`:" msgstr "" "이름 바인딩의 스코프는 이것이 `match`나 `if let`\\-`else` 표현식과 다른 주요 " "점입니다. 이전에는 외부 `let`과 약간의 반복을 통해 이러한 패턴을 흉내 낼 수 " "있었습니다:" #: src/flow_control/let_else.md:57 msgid "" "[option](../std/option.md), [match](./match.md), [if let](./if_let.md) and " "the [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)." msgstr "" "[option](../std/option.md), [match](./match.md), [if let](./if_let.md) 그리" "고 [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)." #: src/flow_control/while_let.md:3 msgid "" "Similar to `if let`, `while let` can make awkward `match` sequences more " "tolerable. Consider the following sequence that increments `i`:" msgstr "" "`if let`과 유사하게, `while let`은 어색한 `match` 시퀀스를 더 견딜만하게 만들" "어 줍니다. `i`를 증가시키는 다음 시퀀스를 고려해 보세요:" #: src/flow_control/while_let.md:9 msgid "// Repeatedly try this test.\n" msgstr "// 이 테스트를 반복해서 시도합니다.\n" #: src/flow_control/while_let.md:13 msgid "// If `optional` destructures, evaluate the block.\n" msgstr "// 만약 `optional`이 구조 분해된다면, 블록을 평가합니다.\n" #: src/flow_control/while_let.md:16 src/flow_control/while_let.md:42 msgid "\"Greater than 9, quit!\"" msgstr "\"9보다 큽니다, 종료!\"" #: src/flow_control/while_let.md:19 src/flow_control/while_let.md:45 msgid "\"`i` is `{:?}`. Try again.\"" msgstr "\"`i`는 `{:?}`입니다. 다시 시도하세요.\"" #: src/flow_control/while_let.md:22 msgid "// ^ Requires 3 indentations!\n" msgstr "// ^ 3단계의 들여쓰기가 필요합니다!\n" #: src/flow_control/while_let.md:24 msgid "// Quit the loop when the destructure fails:\n" msgstr "// 구조 분해에 실패하면 루프를 종료합니다:\n" #: src/flow_control/while_let.md:26 msgid "// ^ Why should this be required? There must be a better way!\n" msgstr "// ^ 왜 이것이 필요할까요? 분명 더 좋은 방법이 있을 것입니다!\n" #: src/flow_control/while_let.md:31 msgid "Using `while let` makes this sequence much nicer:" msgstr "`while let`을 사용하면 이 시퀀스가 훨씬 깔끔해집니다:" #: src/flow_control/while_let.md:38 msgid "" "// This reads: \"while `let` destructures `optional` into\n" " // `Some(i)`, evaluate the block (`{}`). Else `break`.\n" msgstr "" "// 다음과 같이 읽힙니다: \"`let`이 `optional`을 `Some(i)`로\n" "// 구조 분해하는 동안, 블록(`{}`)을 실행하라. 그 외에는 `break` 하라.\"\n" #: src/flow_control/while_let.md:48 msgid "" "// ^ Less rightward drift and doesn't require\n" " // explicitly handling the failing case.\n" msgstr "" "// ^ 오른쪽으로의 들여쓰기가 줄어들었으며 실패 사례를\n" "// 명시적으로 처리할 필요가 없습니다.\n" #: src/flow_control/while_let.md:51 msgid "" "// ^ `if let` had additional optional `else`/`else if`\n" " // clauses. `while let` does not have these.\n" msgstr "" "// ^ `if let`에는 추가적인 선택 사항인 `else`/`else if` 절이\n" "// 있었지만, `while let`에는 이러한 것들이 없습니다.\n" #: src/flow_control/while_let.md:58 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/214)" msgstr "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), 그리고 [RFC]" "(https://github.com/rust-lang/rfcs/pull/214)" #: src/fn.md:3 msgid "" "Functions are declared using the `fn` keyword. Its arguments are type " "annotated, just like variables, and, if the function returns a value, the " "return type must be specified after an arrow `->`." msgstr "" "함수는 `fn` 키워드를 사용하여 선언됩니다. 인자는 변수와 마찬가지로 타입 어노" "테이션이 필요하며, 함수가 값을 반환하는 경우 반환 타입은 화살표 `->` 뒤에 지" "정해야 합니다." #: src/fn.md:7 msgid "" "The final expression in the function will be used as return value. " "Alternatively, the `return` statement can be used to return a value earlier " "from within the function, even from inside loops or `if` statements." msgstr "" "함수의 마지막 표현식은 반환 값으로 사용됩니다. 또는 `return` 문을 사용하여 루" "프나 `if` 문 내부를 포함하여 함수 내에서 더 일찍 값을 반환할 수 있습니다." #: src/fn.md:11 msgid "Let's rewrite FizzBuzz using functions!" msgstr "함수를 사용하여 FizzBuzz를 다시 작성해 봅시다!" #: src/fn.md:14 msgid "" "// Unlike C/C++, there's no restriction on the order of function " "definitions\n" msgstr "// C/C++와 달리, 함수 정의 순서에는 제한이 없습니다.\n" #: src/fn.md:16 msgid "// We can use this function here, and define it somewhere later\n" msgstr "// 여기서 이 함수를 사용하고, 나중에 어딘가에서 정의할 수 있습니다.\n" #: src/fn.md:19 msgid "// Function that returns a boolean value\n" msgstr "// 불리언 값을 반환하는 함수\n" #: src/fn.md:22 msgid "// Corner case, early return\n" msgstr "// 예외 케이스, 조기 반환\n" #: src/fn.md:27 msgid "// This is an expression, the `return` keyword is not necessary here\n" msgstr "// 이것은 표현식이며, 여기서는 `return` 키워드가 필요하지 않습니다.\n" #: src/fn.md:30 msgid "" "// Functions that \"don't\" return a value, actually return the unit type " "`()`\n" msgstr "" "// 값을 반환하지 \"않는\" 함수는 실제로는 유닛 타입 `()`를 반환합니다.\n" #: src/fn.md:43 msgid "" "// When a function returns `()`, the return type can be omitted from the\n" "// signature\n" msgstr "" "// 함수가 `()`를 반환할 때, 시그니처에서 반환 타입을 생략할 수 있습니다.\n" #: src/fn/methods.md:1 msgid "Associated functions & Methods" msgstr "연관 함수와 메서드" #: src/fn/methods.md:3 msgid "" "Some functions are connected to a particular type. These come in two forms: " "associated functions, and methods. Associated functions are functions that " "are defined on a type generally, while methods are associated functions that " "are called on a particular instance of a type." msgstr "" "일부 함수는 특정 타입과 연결되어 있습니다. 이들은 연관 함수와 메서드라는 두 " "가지 형태로 제공됩니다. 연관 함수는 일반적으로 타입 상에 정의된 함수인 반면, " "메서드는 특정 타입의 인스턴스에서 호출되는 연관 함수입니다." #: src/fn/methods.md:13 msgid "" "// Implementation block, all `Point` associated functions & methods go in " "here\n" msgstr "" "// 구현(Implementation) 블록으로, 모든 `Point` 연관 함수와 메서드가 여기에 들" "어갑니다.\n" #: src/fn/methods.md:16 msgid "" "// This is an \"associated function\" because this function is associated " "with\n" " // a particular type, that is, Point.\n" " //\n" " // Associated functions don't need to be called with an instance.\n" " // These functions are generally used like constructors.\n" msgstr "" "// 이것은 이 함수가 특정 타입인 Point와 연관되어 있기 때문에\n" "// \"연관 함수\"라고 불립니다.\n" "//\n" "// 연관 함수는 인스턴스를 통해 호출될 필요가 없습니다.\n" "// 이러한 함수들은 일반적으로 생성자처럼 사용됩니다.\n" #: src/fn/methods.md:25 msgid "// Another associated function, taking two arguments:\n" msgstr "// 두 개의 인자를 받는 또 다른 연관 함수:\n" #: src/fn/methods.md:37 msgid "" "// This is a method\n" " // `&self` is sugar for `self: &Self`, where `Self` is the type of the\n" " // caller object. In this case `Self` = `Rectangle`\n" msgstr "" "// 이것은 메서드입니다\n" "// `&self`는 `self: &Self`를 줄여 쓴 것인데, 여기서 `Self`는\n" "// 호출 객체의 타입을 의미합니다. 이 경우 `Self` = `Rectangle`입니다.\n" #: src/fn/methods.md:41 msgid "// `self` gives access to the struct fields via the dot operator\n" msgstr "" "// `self`는 점(dot) 연산자를 통해 구조체 필드에 대한 접근을 제공합니다.\n" #: src/fn/methods.md:45 msgid "" "// `abs` is a `f64` method that returns the absolute value of the\n" " // caller\n" msgstr "// `abs`는 호출자의 절댓값을 반환하는 `f64` 메서드입니다.\n" #: src/fn/methods.md:57 msgid "" "// This method requires the caller object to be mutable\n" " // `&mut self` desugars to `self: &mut Self`\n" msgstr "" "// 이 메서드는 호출 객체가 가변적일 것을 요구합니다\n" "// `&mut self`는 `self: &mut Self`로 풀어서 쓸 수 있습니다.\n" #: src/fn/methods.md:67 msgid "// `Pair` owns resources: two heap allocated integers\n" msgstr "// `Pair`는 리소스를 소유합니다: 힙에 할당된 두 개의 정수\n" #: src/fn/methods.md:72 msgid "" "// This method \"consumes\" the resources of the caller object\n" " // `self` desugars to `self: Self`\n" msgstr "" "// 이 메서드는 호출 객체의 리소스를 \"소비\"합니다\n" "// `self`는 `self: Self`로 풀어서 쓸 수 있습니다.\n" #: src/fn/methods.md:75 msgid "// Destructure `self`\n" msgstr "// `self` 구조 분해\n" #: src/fn/methods.md:78 msgid "\"Destroying Pair({}, {})\"" msgstr "\"Pair({}, {}) 파괴 중\"" #: src/fn/methods.md:80 msgid "// `first` and `second` go out of scope and get freed\n" msgstr "// `first`와 `second`는 스코프를 벗어나며 해제됩니다.\n" #: src/fn/methods.md:86 msgid "// Associated functions are called using double colons\n" msgstr "// 연관 함수는 이중 콜론을 사용하여 호출됩니다.\n" #: src/fn/methods.md:91 msgid "" "// Methods are called using the dot operator\n" " // Note that the first argument `&self` is implicitly passed, i.e.\n" " // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`\n" msgstr "" "// 메서드는 점 연산자를 사용하여 호출됩니다.\n" "// 첫 번째 인자인 `&self`는 암시적으로 전달됩니다. 즉,\n" "// `rectangle.perimeter()`는 `Rectangle::perimeter(&rectangle)`와 동일합니" "다.\n" #: src/fn/methods.md:94 msgid "\"Rectangle perimeter: {}\"" msgstr "\"사각형 둘레: {}\"" #: src/fn/methods.md:95 msgid "\"Rectangle area: {}\"" msgstr "\"사각형 넓이: {}\"" #: src/fn/methods.md:102 msgid "" "// Error! `rectangle` is immutable, but this method requires a mutable\n" " // object\n" " //rectangle.translate(1.0, 0.0);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `rectangle`은 불변이지만, 이 메서드는 가변 객체를 요구합니다.\n" "// rectangle.translate(1.0, 0.0);\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/fn/methods.md:107 msgid "// Okay! Mutable objects can call mutable methods\n" msgstr "// 좋습니다! 가변 객체는 가변 메서드를 호출할 수 있습니다\n" #: src/fn/methods.md:114 msgid "" "// Error! Previous `destroy` call \"consumed\" `pair`\n" " //pair.destroy();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! 이전의 `destroy` 호출이 `pair`를 \"소비\"했습니다\n" "// pair.destroy();\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/fn/closures.md:3 msgid "" "Closures are functions that can capture the enclosing environment. For " "example, a closure that captures the `x` variable:" msgstr "" "클로저는 감싸고 있는 환경을 캡처할 수 있는 함수입니다. 예를 들어, `x` 변수를 " "캡처하는 클로저는 다음과 같습니다:" #: src/fn/closures.md:10 msgid "" "The syntax and capabilities of closures make them very convenient for on the " "fly usage. Calling a closure is exactly like calling a function. However, " "both input and return types _can_ be inferred and input variable names " "_must_ be specified." msgstr "" "클로저의 구문과 기능은 즉석에서 사용하기에 매우 편리합니다. 클로저를 호출하" "는 것은 함수를 호출하는 것과 똑같습니다. 하지만 입력 및 반환 타입은 추론될 " "수 있으며, 입력 변수 이름은 반드시 지정되어야 합니다." #: src/fn/closures.md:15 msgid "Other characteristics of closures include:" msgstr "클로저의 다른 특징들은 다음과 같습니다:" #: src/fn/closures.md:17 msgid "using `||` instead of `()` around input variables." msgstr "입력 변수 주위에 `()` 대신 `||`를 사용합니다." #: src/fn/closures.md:18 msgid "" "optional body delimitation (`{}`) for a single line expression (mandatory " "otherwise)." msgstr "" "한 줄 표현식의 경우 본문 구분 기호(`{}`)는 선택 사항입니다 (그 외의 경우는 필" "수)." #: src/fn/closures.md:19 msgid "the ability to capture the outer environment variables." msgstr "외부 환경 변수를 캡처하는 능력." #: src/fn/closures.md:25 msgid "" "// A regular function can't refer to variables in the enclosing environment\n" " //fn function(i: i32) -> i32 { i + outer_var }\n" " // TODO: uncomment the line above and see the compiler error. The " "compiler\n" " // suggests that we define a closure instead.\n" msgstr "" "// 일반 함수는 자신을 감싸고 있는 환경의 변수를 참조할 수 없습니다\n" "// fn function(i: i32) -> i32 { i + outer_var }\n" "// TODO: 위의 줄의 주석을 해제하고 컴파일 에러를 확인해 보세요. 컴파일러는\n" "// 대신 클로저를 정의할 것을 제안합니다.\n" #: src/fn/closures.md:30 msgid "" "// Closures are anonymous, here we are binding them to references.\n" " // Annotation is identical to function annotation but is optional\n" " // as are the `{}` wrapping the body. These nameless functions\n" " // are assigned to appropriately named variables.\n" msgstr "" "// 클로저는 익명이며, 여기서는 참조에 바인딩하고 있습니다.\n" "// 어노테이션은 함수의 어노테이션과 동일하지만 선택 사항이며,\n" "// 본문을 감싸는 `{}` 역시 선택 사항입니다. 이 이름 없는 함수들은\n" "// 적절하게 이름 붙여진 변수들에 할당됩니다.\n" #: src/fn/closures.md:37 msgid "// Call the closures.\n" msgstr "// 클로저를 호출합니다.\n" #: src/fn/closures.md:38 msgid "\"closure_annotated: {}\"" msgstr "\"어노테이션된 클로저: {}\"" #: src/fn/closures.md:39 msgid "\"closure_inferred: {}\"" msgstr "\"추론된 클로저: {}\"" #: src/fn/closures.md:40 msgid "" "// Once closure's type has been inferred, it cannot be inferred again with " "another type.\n" " //println!(\"cannot reuse closure_inferred with another type: {}\", " "closure_inferred(42i64));\n" " // TODO: uncomment the line above and see the compiler error.\n" msgstr "" "// 클로저의 타입이 한 번 추론되면, 다른 타입으로 다시 추론될 수 없습니다.\n" "// println!(\"다른 타입으로 closure_inferred를 재사용할 수 없습니다: {}\", " "closure_inferred(42i64));\n" "// TODO: 위의 줄의 주석을 해제하고 컴파일 에러를 확인해 보세요.\n" #: src/fn/closures.md:44 msgid "" "// A closure taking no arguments which returns an `i32`.\n" " // The return type is inferred.\n" msgstr "" "// 인자를 받지 않고 `i32`를 반환하는 클로저입니다.\n" "// 반환 타입은 추론됩니다.\n" #: src/fn/closures.md:47 msgid "\"closure returning one: {}\"" msgstr "\"1을 반환하는 클로저: {}\"" #: src/fn/closures/capture.md:3 msgid "" "Closures are inherently flexible and will do what the functionality requires " "to make the closure work without annotation. This allows capturing to " "flexibly adapt to the use case, sometimes moving and sometimes borrowing. " "Closures can capture variables:" msgstr "" "클로저는 본질적으로 유연하며, 어노테이션 없이도 클로저가 작동하는 데 필요한 " "기능을 수행합니다. 이를 통해 캡처 방식이 사용 사례에 따라 유연하게 적응할 수 " "있으며, 때로는 이동(move)하고 때로는 빌림(borrow)을 수행합니다. 클로저는 다음" "과 같은 방식으로 변수를 캡처할 수 있습니다:" #: src/fn/closures/capture.md:8 msgid "by reference: `&T`" msgstr "참조에 의한 방식: `&T`" #: src/fn/closures/capture.md:9 msgid "by mutable reference: `&mut T`" msgstr "가변 참조에 의한 방식: `&mut T`" #: src/fn/closures/capture.md:10 msgid "by value: `T`" msgstr "값에 의한 방식: `T`" #: src/fn/closures/capture.md:12 msgid "" "They preferentially capture variables by reference and only go lower when " "required." msgstr "" "클로저는 가급적 참조로 변수를 캡처하며, 필요한 경우에만 더 낮은 수준(이동 등)" "으로 내려갑니다." #: src/fn/closures/capture.md:19 msgid "\"green\"" msgstr "\"초록\"" #: src/fn/closures/capture.md:21 msgid "" "// A closure to print `color` which immediately borrows (`&`) `color` and\n" " // stores the borrow and closure in the `print` variable. It will " "remain\n" " // borrowed until `print` is used the last time.\n" " //\n" " // `println!` only requires arguments by immutable reference so it " "doesn't\n" " // impose anything more restrictive.\n" msgstr "" "// `color`를 출력하는 클로저입니다. 이 클로저는 즉시 `color`를 빌리고(`&`)\n" "// 그 빌림과 클로저를 `print` 변수에 저장합니다. `print`가 마지막으로\n" "// 사용될 때까지 빌린 상태가 유지됩니다.\n" "//\n" "// `println!`은 인자로 불변 참조만 요구하므로 더 이상의 제약을\n" "// 가하지 않습니다.\n" #: src/fn/closures/capture.md:27 msgid "\"`color`: {}\"" msgstr "\"`color`: {}\"" #: src/fn/closures/capture.md:29 msgid "// Call the closure using the borrow.\n" msgstr "// 빌림을 사용하여 클로저를 호출합니다.\n" #: src/fn/closures/capture.md:32 msgid "" "// `color` can be borrowed immutably again, because the closure only holds\n" " // an immutable reference to `color`.\n" msgstr "" "// 클로저가 `color`에 대한 불변 참조만 가지고 있기 때문에,\n" "// `color`를 다시 불변으로 빌릴 수 있습니다.\n" #: src/fn/closures/capture.md:37 msgid "// A move or reborrow is allowed after the final use of `print`\n" msgstr "" "// `print`를 마지막으로 사용한 후에는 이동(move)이나 다시 빌리는 것이 허용됩" "니다\n" #: src/fn/closures/capture.md:42 msgid "" "// A closure to increment `count` could take either `&mut count` or `count`\n" " // but `&mut count` is less restrictive so it takes that. Immediately\n" " // borrows `count`.\n" " //\n" " // A `mut` is required on `inc` because a `&mut` is stored inside. " "Thus,\n" " // calling the closure mutates `count` which requires a `mut`.\n" msgstr "" "// `count`를 증가시키는 클로저는 `&mut count`나 `count` 중 하나를 취할 수 있" "지만,\n" "// `&mut count`가 덜 제한적이므로 이를 취합니다. 즉시 `count`를 빌립니다.\n" "//\n" "// 내부에 `&mut`가 저장되어 있기 때문에 `inc`에 `mut`가 필요합니다. 따라서\n" "// 클로저를 호출하면 `count`가 수정되며, 이를 위해 `mut`가 필요합니다.\n" #: src/fn/closures/capture.md:50 msgid "\"`count`: {}\"" msgstr "\"`count`: {}\"" #: src/fn/closures/capture.md:53 msgid "// Call the closure using a mutable borrow.\n" msgstr "// 가변 빌림을 사용하여 클로저를 호출합니다.\n" #: src/fn/closures/capture.md:56 msgid "" "// The closure still mutably borrows `count` because it is called later.\n" " // An attempt to reborrow will lead to an error.\n" " // let _reborrow = &count;\n" " // ^ TODO: try uncommenting this line.\n" msgstr "" "// 클로저가 나중에 호출되기 때문에 여전히 `count`를 가변적으로 빌리고 있습니" "다.\n" "// 다시 빌리려는 시도는 에러를 발생시킵니다.\n" "// let _reborrow = &count;\n" "// ^ TODO: 이 줄의 주석을 해제해 보세요.\n" #: src/fn/closures/capture.md:62 msgid "" "// The closure no longer needs to borrow `&mut count`. Therefore, it is\n" " // possible to reborrow without an error\n" msgstr "" "// 클로저가 더 이상 `&mut count`를 빌릴 필요가 없습니다. 따라서\n" "// 에러 없이 다시 빌리는 것이 가능합니다.\n" #: src/fn/closures/capture.md:67 msgid "// A non-copy type.\n" msgstr "// 복사(copy)되지 않는 타입.\n" #: src/fn/closures/capture.md:70 msgid "" "// `mem::drop` requires `T` so this must take by value. A copy type\n" " // would copy into the closure leaving the original untouched.\n" " // A non-copy must move and so `movable` immediately moves into\n" " // the closure.\n" msgstr "" "// `mem::drop`은 `T`를 요구하므로 값을 가져와야 합니다. 복사 타입은\n" "// 원본을 그대로 둔 채 클로저 내부로 복사될 것입니다.\n" "// 복사되지 않는 타입은 이동(move)해야 하므로 `movable`은 즉시\n" "// 클로저 내부로 이동됩니다.\n" #: src/fn/closures/capture.md:75 msgid "\"`movable`: {:?}\"" msgstr "\"`movable`: {:?}\"" #: src/fn/closures/capture.md:79 msgid "// `consume` consumes the variable so this can only be called once.\n" msgstr "// `consume`은 변수를 소비하므로 한 번만 호출될 수 있습니다.\n" #: src/fn/closures/capture.md:81 msgid "" "// consume();\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" "// consume();\n" "// ^ TODO: 이 줄의 주석을 해제해 보세요.\n" #: src/fn/closures/capture.md:86 msgid "" "Using `move` before vertical pipes forces closure to take ownership of " "captured variables:" msgstr "" "수직 바(`||`) 앞에 `move`를 사용하면 클로저가 캡처된 변수의 소유권을 강제로 " "갖게 됩니다:" #: src/fn/closures/capture.md:91 msgid "// `Vec` has non-copy semantics.\n" msgstr "// `Vec`은 복사되지 않는 세맨틱을 가집니다.\n" #: src/fn/closures/capture.md:99 msgid "" "// println!(\"There're {} elements in vec\", haystack.len());\n" " // ^ Uncommenting above line will result in compile-time error\n" " // because borrow checker doesn't allow re-using variable after it\n" " // has been moved.\n" msgstr "" "// println!(\"vec에는 {}개의 요소가 있습니다\", haystack.len());\n" "// ^ 위의 줄의 주석을 해제하면 컴파일 타임 에러가 발생합니다.\n" "// 빌림 검사기(borrow checker)가 이동된 후의 변수 재사용을 허용하지 않기 때문" "입니다.\n" #: src/fn/closures/capture.md:104 msgid "" "// Removing `move` from closure's signature will cause closure\n" " // to borrow _haystack_ variable immutably, hence _haystack_ is still\n" " // available and uncommenting above line will not cause an error.\n" msgstr "" "// 클로저의 시그니처에서 `move`를 제거하면 클로저가 `haystack` 변수를\n" "// 불변으로 빌리게 되므로, `haystack`을 여전히 사용할 수 있고\n" "// 위의 줄의 주석을 해제해도 에러가 발생하지 않습니다.\n" #: src/fn/closures/capture.md:112 msgid "" "[`Box`](../../std/box.md) and [`std::mem::drop`](https://doc.rust-lang.org/" "std/mem/fn.drop.html)" msgstr "" "[`Box`](../../std/box.md)와 [`std::mem::drop`](https://doc.rust-lang.org/std/" "mem/fn.drop.html)" #: src/fn/closures/input_parameters.md:3 msgid "" "While Rust chooses how to capture variables on the fly mostly without type " "annotation, this ambiguity is not allowed when writing functions. When " "taking a closure as an input parameter, the closure's complete type must be " "annotated using one of a few `traits`, and they're determined by what the " "closure does with captured value. In order of decreasing restriction, they " "are:" msgstr "" "Rust는 대부분 타입 어노테이션 없이 즉석에서 변수를 캡처하는 방식을 선택하지" "만, 함수를 작성할 때는 이러한 모호함이 허용되지 않습니다. 클로저를 입력 파라" "미터로 받을 때, 클로저의 전체 타입은 몇 가지 `트레이트` 중 하나를 사용하여 어" "노테이션되어야 하며, 이는 클로저가 캡처된 값으로 무엇을 하는지에 따라 결정됩" "니다. 제약이 강한 순서대로 나열하면 다음과 같습니다:" #: src/fn/closures/input_parameters.md:10 msgid "`Fn`: the closure uses the captured value by reference (`&T`)" msgstr "`Fn`: 클로저가 캡처된 값을 참조(`&T`)로 사용합니다" #: src/fn/closures/input_parameters.md:11 msgid "" "`FnMut`: the closure uses the captured value by mutable reference (`&mut T`)" msgstr "`FnMut`: 클로저가 캡처된 값을 가변 참조(`&mut T`)로 사용합니다" #: src/fn/closures/input_parameters.md:12 msgid "`FnOnce`: the closure uses the captured value by value (`T`)" msgstr "`FnOnce`: 클로저가 캡처된 값을 값(`T`)으로 사용합니다" #: src/fn/closures/input_parameters.md:14 msgid "" "On a variable-by-variable basis, the compiler will capture variables in the " "least restrictive manner possible." msgstr "" "변수별로 컴파일러는 가능한 가장 제약이 적은 방식으로 변수를 캡처합니다." #: src/fn/closures/input_parameters.md:17 msgid "" "For instance, consider a parameter annotated as `FnOnce`. This specifies " "that the closure _may_ capture by `&T`, `&mut T`, or `T`, but the compiler " "will ultimately choose based on how the captured variables are used in the " "closure." msgstr "" "예를 들어, `FnOnce`로 어노테이션된 파라미터를 생각해 보세요. 이는 클로저가 " "`&T`, `&mut T`, 또는 `T`로 캡처할 수 있음을 나타내지만, 컴파일러는 최종적으" "로 클로저 내에서 캡처된 변수가 어떻게 사용되는지에 따라 선택합니다." #: src/fn/closures/input_parameters.md:22 msgid "" "This is because if a move is possible, then any type of borrow should also " "be possible. Note that the reverse is not true. If the parameter is " "annotated as `Fn`, then capturing variables by `&mut T` or `T` are not " "allowed. However, `&T` is allowed." msgstr "" "이동(move)이 가능하다면 어떤 유형의 빌림(borrow)도 가능해야 하기 때문입니다. " "그 반대는 성립하지 않음에 유의하세요. 파라미터가 `Fn`으로 어노테이션된 경우, " "`&mut T`나 `T`로 변수를 캡처하는 것은 허용되지 않습니다. 하지만 `&T`는 허용됩" "니다." #: src/fn/closures/input_parameters.md:27 msgid "" "In the following example, try swapping the usage of `Fn`, `FnMut`, and " "`FnOnce` to see what happens:" msgstr "" "다음 예제에서 `Fn`, `FnMut`, `FnOnce`의 사용을 서로 바꿔보며 어떤 일이 일어나" "는지 확인해 보세요:" #: src/fn/closures/input_parameters.md:31 msgid "" "// A function which takes a closure as an argument and calls it.\n" "// denotes that F is a \"Generic type parameter\"\n" msgstr "" "// 클로저를 인자로 받아 호출하는 함수입니다.\n" "// 는 F가 \"제네릭 타입 파라미터\"임을 나타냅니다.\n" #: src/fn/closures/input_parameters.md:34 msgid "// The closure takes no input and returns nothing.\n" msgstr "// 이 클로저는 입력을 받지 않고 아무것도 반환하지 않습니다.\n" #: src/fn/closures/input_parameters.md:36 msgid "// ^ TODO: Try changing this to `Fn` or `FnMut`.\n" msgstr "// ^ TODO: 이를 `Fn`이나 `FnMut`로 변경해 보세요.\n" #: src/fn/closures/input_parameters.md:40 msgid "// A function which takes a closure and returns an `i32`.\n" msgstr "// 클로저를 받아 `i32`를 반환하는 함수입니다.\n" #: src/fn/closures/input_parameters.md:43 msgid "// The closure takes an `i32` and returns an `i32`.\n" msgstr "// 이 클로저는 `i32`를 받아 `i32`를 반환합니다.\n" #: src/fn/closures/input_parameters.md:53 msgid "" "// A non-copy type.\n" " // `to_owned` creates owned data from borrowed one\n" msgstr "" "// 복사되지 않는 타입.\n" "// `to_owned`는 빌려온 데이터로부터 소유권이 있는 데이터를 생성합니다.\n" #: src/fn/closures/input_parameters.md:55 msgid "\"goodbye\"" msgstr "\"잘 가요\"" #: src/fn/closures/input_parameters.md:57 msgid "" "// Capture 2 variables: `greeting` by reference and\n" " // `farewell` by value.\n" msgstr "" "// 두 개의 변수를 캡처합니다: `greeting`은 참조로, `farewell`은 값으로.\n" #: src/fn/closures/input_parameters.md:60 msgid "// `greeting` is by reference: requires `Fn`.\n" msgstr "// `greeting`은 참조에 의한 방식입니다: `Fn`이 필요합니다.\n" #: src/fn/closures/input_parameters.md:61 msgid "\"I said {}.\"" msgstr "\"저는 {}라고 말했습니다.\"" #: src/fn/closures/input_parameters.md:63 msgid "" "// Mutation forces `farewell` to be captured by\n" " // mutable reference. Now requires `FnMut`.\n" msgstr "" "// 수정을 위해 `farewell`을 가변 참조로 캡처해야 합니다.\n" "// 이제 `FnMut`가 필요합니다.\n" #: src/fn/closures/input_parameters.md:65 msgid "\"!!!\"" msgstr "\"!!!\"" #: src/fn/closures/input_parameters.md:66 msgid "\"Then I screamed {}.\"" msgstr "\"그러고 나서 저는 {}라고 소리쳤습니다.\"" #: src/fn/closures/input_parameters.md:67 msgid "\"Now I can sleep. zzzzz\"" msgstr "\"이제 잘 수 있겠네요. zzzzz\"" #: src/fn/closures/input_parameters.md:69 msgid "" "// Manually calling drop forces `farewell` to\n" " // be captured by value. Now requires `FnOnce`.\n" msgstr "" "// 수동으로 drop을 호출하면 `farewell`을 값으로\n" "// 캡처해야 합니다. 이제 `FnOnce`가 필요합니다.\n" #: src/fn/closures/input_parameters.md:74 msgid "// Call the function which applies the closure.\n" msgstr "// 클로저를 적용하는 함수를 호출합니다.\n" #: src/fn/closures/input_parameters.md:77 msgid "// `double` satisfies `apply_to_3`'s trait bound\n" msgstr "// `double`은 `apply_to_3`의 트레이트 바운드를 만족합니다\n" #: src/fn/closures/input_parameters.md:80 msgid "\"3 doubled: {}\"" msgstr "\"3의 두 배: {}\"" #: src/fn/closures/input_parameters.md:86 msgid "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md), " "[where](../../generics/where.md) and [`FnOnce`](https://doc.rust-lang.org/" "std/ops/trait.FnOnce.html)" msgstr "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [제네릭](../../generics.md), " "[where](../../generics/where.md) 및 [`FnOnce`](https://doc.rust-lang.org/std/" "ops/trait.FnOnce.html)" #: src/fn/closures/anonymity.md:3 msgid "" "Closures succinctly capture variables from enclosing scopes. Does this have " "any consequences? It surely does. Observe how using a closure as a function " "parameter requires [generics](../../generics.md), which is necessary because " "of how they are defined:" msgstr "" "클로저는 자신을 감싸고 있는 스코프에서 변수를 간결하게 캡처합니다. 이것이 어" "떤 결과를 초래할까요? 분명히 결과가 있습니다. 클로저를 함수 파라미터로 사용" "할 때 [제네릭](../../generics.md)이 왜 필요한지, 클로저가 어떻게 정의되는지" "를 통해 살펴보세요:" #: src/fn/closures/anonymity.md:9 msgid "// `F` must be generic.\n" msgstr "// `F`는 제네릭이어야 합니다.\n" #: src/fn/closures/anonymity.md:16 msgid "" "When a closure is defined, the compiler implicitly creates a new anonymous " "structure to store the captured variables inside, meanwhile implementing the " "functionality via one of the `traits`: `Fn`, `FnMut`, or `FnOnce` for this " "unknown type. This type is assigned to the variable which is stored until " "calling." msgstr "" "클로저가 정의될 때, 컴파일러는 내부에 캡처된 변수를 저장하기 위해 새로운 익" "명 구조체를 암시적으로 생성하며, 동시에 이 알 수 없는 타입에 대해 `Fn`, " "`FnMut`, 또는 `FnOnce` 트레이트 중 하나를 통해 기능을 구현합니다. 이 타입은 " "변수에 할당되어 호출될 때까지 저장됩니다." #: src/fn/closures/anonymity.md:22 msgid "" "Since this new type is of unknown type, any usage in a function will require " "generics. However, an unbounded type parameter `` would still be " "ambiguous and not be allowed. Thus, bounding by one of the `traits`: `Fn`, " "`FnMut`, or `FnOnce` (which it implements) is sufficient to specify its type." msgstr "" "이 새로운 타입은 알 수 없는 타입이므로, 함수에서 사용할 때는 제네릭이 필요합" "니다. 하지만 제약이 없는 타입 파라미터 ``는 여전히 모호하므로 허용되지 않" "습니다. 따라서 클로저가 구현하는 `Fn`, `FnMut`, 또는 `FnOnce` 트레이트 중 하" "나로 바운딩하는 것이 그 타입을 지정하기에 충분합니다." #: src/fn/closures/anonymity.md:28 msgid "" "// `F` must implement `Fn` for a closure which takes no\n" "// inputs and returns nothing - exactly what is required\n" "// for `print`.\n" msgstr "" "// `F`는 입력이 없고 아무것도 반환하지 않는 클로저를 위해\n" "// `Fn`을 구현해야 합니다. 이는 정확히 `print`에 요구되는 사항입니다.\n" #: src/fn/closures/anonymity.md:39 msgid "" "// Capture `x` into an anonymous type and implement\n" " // `Fn` for it. Store it in `print`.\n" msgstr "" "// `x`를 익명 타입으로 캡처하고 그에 대해 `Fn`을 구현합니다.\n" "// 이를 `print`에 저장합니다.\n" #: src/fn/closures/anonymity.md:49 msgid "" "[A thorough analysis](https://huonw.github.io/blog/2015/05/finding-closure-" "in-rust/), [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`]" "(https://doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://" "doc.rust-lang.org/std/ops/trait.FnOnce.html)" msgstr "" "[철저한 분석](https://huonw.github.io/blog/2015/05/finding-closure-in-" "rust/), [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`]" "(https://doc.rust-lang.org/std/ops/trait.FnMut.html), 그리고 [`FnOnce`]" "(https://doc.rust-lang.org/std/ops/trait.FnOnce.html)" #: src/fn/closures/input_functions.md:3 msgid "" "Since closures may be used as arguments, you might wonder if the same can be " "said about functions. And indeed they can! If you declare a function that " "takes a closure as parameter, then any function that satisfies the trait " "bound of that closure can be passed as a parameter." msgstr "" "클로저가 인자로 사용될 수 있으므로, 함수에 대해서도 똑같이 말할 수 있는지 궁" "금할 것입니다. 실제로 가능합니다! 클로저를 파라미터로 받는 함수를 선언하면, " "해당 클로저의 트레이트 바운드를 만족하는 모든 함수를 파라미터로 전달할 수 있" "습니다." #: src/fn/closures/input_functions.md:9 msgid "" "// Define a function which takes a generic `F` argument\n" "// bounded by `Fn`, and calls it\n" msgstr "" "// `Fn`으로 바운딩된 제네릭 `F` 인자를 받아\n" "// 호출하는 함수를 정의합니다\n" #: src/fn/closures/input_functions.md:14 msgid "// Define a wrapper function satisfying the `Fn` bound\n" msgstr "// `Fn` 바운드를 만족하는 래퍼 함수를 정의합니다\n" #: src/fn/closures/input_functions.md:17 msgid "\"I'm a function!\"" msgstr "\"저는 함수입니다!\"" #: src/fn/closures/input_functions.md:21 msgid "// Define a closure satisfying the `Fn` bound\n" msgstr "// `Fn` 바운드를 만족하는 클로저를 정의합니다\n" #: src/fn/closures/input_functions.md:22 msgid "\"I'm a closure!\"" msgstr "\"저는 클로저입니다!\"" #: src/fn/closures/input_functions.md:29 msgid "" "As an additional note, the `Fn`, `FnMut`, and `FnOnce` `traits` dictate how " "a closure captures variables from the enclosing scope." msgstr "" "추가로, `Fn`, `FnMut`, `FnOnce` 트레이트는 클로저가 주변 스코프에서 변수를 캡" "처하는 방식을 결정합니다." #: src/fn/closures/input_functions.md:34 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" msgstr "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), 그리고 [`FnOnce`](https://" "doc.rust-lang.org/std/ops/trait.FnOnce.html)" #: src/fn/closures/output_parameters.md:3 msgid "" "Closures as input parameters are possible, so returning closures as output " "parameters should also be possible. However, anonymous closure types are, by " "definition, unknown, so we have to use `impl Trait` to return them." msgstr "" "클로저를 입력 파라미터로 사용하는 것이 가능하므로, 클로저를 출력 파라미터로 " "반환하는 것도 가능해야 합니다. 하지만 익명 클로저 타입은 정의상 알 수 없으므" "로, 이를 반환하려면 `impl Trait`를 사용해야 합니다." #: src/fn/closures/output_parameters.md:8 msgid "The valid traits for returning a closure are:" msgstr "클로저를 반환하기 위해 유효한 트레이트들은 다음과 같습니다:" #: src/fn/closures/output_parameters.md:10 msgid "`Fn`" msgstr "`Fn`" #: src/fn/closures/output_parameters.md:11 msgid "`FnMut`" msgstr "`FnMut`" #: src/fn/closures/output_parameters.md:12 msgid "`FnOnce`" msgstr "`FnOnce`" #: src/fn/closures/output_parameters.md:14 msgid "" "Beyond this, the `move` keyword must be used, which signals that all " "captures occur by value. This is required because any captures by reference " "would be dropped as soon as the function exited, leaving invalid references " "in the closure." msgstr "" "이 외에도, 모든 캡처가 값에 의해 발생함을 나타내는 `move` 키워드를 반드시 사" "용해야 합니다. 이는 참조에 의한 캡처가 함수가 종료되는 즉시 드롭되어 클로저" "에 유효하지 않은 참조를 남기기 때문에 필요합니다." #: src/fn/closures/output_parameters.md:21 msgid "\"Fn\"" msgstr "\"Fn\"" #: src/fn/closures/output_parameters.md:23 #: src/fn/closures/output_parameters.md:29 #: src/fn/closures/output_parameters.md:35 msgid "\"This is a: {}\"" msgstr "\"이것은 {}입니다\"" #: src/fn/closures/output_parameters.md:27 msgid "\"FnMut\"" msgstr "\"FnMut\"" #: src/fn/closures/output_parameters.md:33 msgid "\"FnOnce\"" msgstr "\"FnOnce\"" #: src/fn/closures/output_parameters.md:51 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md) " "and [impl Trait](../../trait/impl_trait.md)." msgstr "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [제네릭](../../generics.md) 및 " "[impl Trait](../../trait/impl_trait.md)." #: src/fn/closures/closure_examples.md:3 msgid "" "This section contains a few examples of using closures from the `std` " "library." msgstr "" "이 섹션에는 `std` 라이브러리의 클로저를 사용하는 몇 가지 예제가 포함되어 있습" "니다." #: src/fn/closures/closure_examples/iter_any.md:3 msgid "" "`Iterator::any` is a function which when passed an iterator, will return " "`true` if any element satisfies the predicate. Otherwise `false`. Its " "signature:" msgstr "" "`Iterator::any`는 이터레이터가 주어졌을 때, 어떤 요소라도 서술어(predicate)" "를 만족하면 `true`를 반환하는 함수입니다. 그렇지 않으면 `false`를 반환합니" "다. 시그니처는 다음과 같습니다:" #: src/fn/closures/closure_examples/iter_any.md:9 #: src/fn/closures/closure_examples/iter_find.md:9 msgid "// The type being iterated over.\n" msgstr "// 반복되는 요소의 타입.\n" #: src/fn/closures/closure_examples/iter_any.md:12 msgid "" "// `any` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" "// `any`는 `&mut self`를 취하므로 호출자는 빌려지거나\n" "// 수정될 수 있지만, 소비(consume)되지는 않습니다.\n" #: src/fn/closures/closure_examples/iter_any.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `Self::Item` is the closure parameter " "type,\n" " // which is determined by the iterator (e.g., `&T` for `.iter()`,\n" " // `T` for `.into_iter()`).\n" msgstr "" "// `FnMut`는 캡처된 변수가 최대 수정될 수 있지만 소비되지는 않음을 의미합니" "다.\n" "// `Self::Item`은 클로저 파라미터 타입으로, 이터레이터에 의해 결정됩니다\n" "// (예: `.iter()`의 경우 `&T`, `.into_iter()`의 경우 `T`).\n" #: src/fn/closures/closure_examples/iter_any.md:28 msgid "// `iter()` for vecs yields `&i32`. Destructure to `i32`.\n" msgstr "" "// 벡터에 대한 `iter()`는 `&i32`를 생성합니다. `i32`로 구조 분해합니다.\n" #: src/fn/closures/closure_examples/iter_any.md:29 msgid "\"2 in vec1: {}\"" msgstr "\"vec1에 2가 있음: {}\"" #: src/fn/closures/closure_examples/iter_any.md:30 msgid "// `into_iter()` for vecs yields `i32`. No destructuring required.\n" msgstr "" "// 벡터에 대한 `into_iter()`는 `i32`를 생성합니다. 구조 분해가 필요 없습니" "다.\n" #: src/fn/closures/closure_examples/iter_any.md:31 msgid "\"2 in vec2: {}\"" msgstr "\"vec2에 2가 있음: {}\"" #: src/fn/closures/closure_examples/iter_any.md:33 msgid "" "// `iter()` only borrows `vec1` and its elements, so they can be used again\n" msgstr "" "// `iter()`는 오직 `vec1`과 그 요소들을 빌리기만 하므로, 다시 사용할 수 있습" "니다.\n" #: src/fn/closures/closure_examples/iter_any.md:34 msgid "\"vec1 len: {}\"" msgstr "\"vec1 길이: {}\"" #: src/fn/closures/closure_examples/iter_any.md:35 msgid "\"First element of vec1 is: {}\"" msgstr "\"vec1의 첫 번째 요소: {}\"" #: src/fn/closures/closure_examples/iter_any.md:36 msgid "" "// `into_iter()` does move `vec2` and its elements, so they cannot be used " "again\n" " // println!(\"First element of vec2 is: {}\", vec2[0]);\n" " // println!(\"vec2 len: {}\", vec2.len());\n" " // TODO: uncomment two lines above and see compiler errors.\n" msgstr "" "// `into_iter()`는 `vec2`와 그 요소들을 이동(move)시키므로, 다시 사용할 수 없" "습니다.\n" "// println!(\"vec2의 첫 번째 요소: {}\", vec2[0]);\n" "// println!(\"vec2 길이: {}\", vec2.len());\n" "// TODO: 위의 두 줄의 주석을 해제하고 컴파일 에러를 확인해 보세요.\n" #: src/fn/closures/closure_examples/iter_any.md:44 msgid "// `iter()` for arrays yields `&i32`.\n" msgstr "// 배열에 대한 `iter()`는 `&i32`를 생성합니다.\n" #: src/fn/closures/closure_examples/iter_any.md:45 msgid "\"2 in array1: {}\"" msgstr "\"array1에 2가 있음: {}\"" #: src/fn/closures/closure_examples/iter_any.md:46 msgid "// `into_iter()` for arrays yields `i32`.\n" msgstr "// 배열에 대한 `into_iter()`는 `i32`를 생성합니다.\n" #: src/fn/closures/closure_examples/iter_any.md:47 msgid "\"2 in array2: {}\"" msgstr "\"array2에 2가 있음: {}\"" #: src/fn/closures/closure_examples/iter_any.md:53 msgid "" "[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.any)" msgstr "" "[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.any)" #: src/fn/closures/closure_examples/iter_find.md:3 msgid "" "`Iterator::find` is a function which iterates over an iterator and searches " "for the first value which satisfies some condition. If none of the values " "satisfy the condition, it returns `None`. Its signature:" msgstr "" "`Iterator::find`는 이터레이터를 순회하며 어떤 조건을 만족하는 첫 번째 값을 찾" "는 함수입니다. 조건을 만족하는 값이 없으면 `None`을 반환합니다. 시그니처는 다" "음과 같습니다:" #: src/fn/closures/closure_examples/iter_find.md:12 msgid "" "// `find` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" "// `find`는 `&mut self`를 취하므로 호출자는 빌려지거나\n" "// 수정될 수 있지만, 소비(consume)되지는 않습니다.\n" #: src/fn/closures/closure_examples/iter_find.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `&Self::Item` states it takes\n" " // arguments to the closure by reference.\n" msgstr "" "// `FnMut`는 캡처된 변수가 최대 수정될 수 있지만 소비되지는 않음을 의미합니" "다.\n" "// `&Self::Item`은 클로저에 대한 인자를 참조로 취함을 나타냅니다.\n" #: src/fn/closures/closure_examples/iter_find.md:27 msgid "// `vec1.iter()` yields `&i32`.\n" msgstr "// `vec1.iter()`는 `&i32`를 생성합니다.\n" #: src/fn/closures/closure_examples/iter_find.md:29 msgid "// `vec2.into_iter()` yields `i32`.\n" msgstr "// `vec2.into_iter()`는 `i32`를 생성합니다.\n" #: src/fn/closures/closure_examples/iter_find.md:32 msgid "" "// `iter()` yields `&i32`, and `find` passes `&Item` to the predicate.\n" " // Since `Item = &i32`, the closure argument has type `&&i32`,\n" " // which we pattern-match to dereference down to `i32`.\n" msgstr "" "// `iter()`는 `&i32`를 생성하고, `find`는 서술어(predicate)에 `&Item`을 전달" "합니다.\n" "// `Item = &i32`이므로 클로저 인자는 `&&i32` 타입을 가지며,\n" "// 우리는 이를 패턴 매칭하여 `i32`로 역참조합니다.\n" #: src/fn/closures/closure_examples/iter_find.md:35 msgid "\"Find 2 in vec1: {:?}\"" msgstr "\"vec1에서 2 찾기: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:37 msgid "" "// `into_iter()` yields `i32`, and `find` passes `&Item` to the predicate.\n" " // Since `Item = i32`, the closure argument has type `&i32`,\n" " // which we pattern-match to dereference down to `i32`.\n" msgstr "" "// `into_iter()`는 `i32`를 생성하고, `find`는 서술어에 `&Item`을 전달합니" "다.\n" "// `Item = i32`이므로 클로저 인자는 `&i32` 타입을 가지며,\n" "// 우리는 이를 패턴 매칭하여 `i32`로 역참조합니다.\n" #: src/fn/closures/closure_examples/iter_find.md:40 msgid "\"Find 2 in vec2: {:?}\"" msgstr "\"vec2에서 2 찾기: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:45 msgid "// `array1.iter()` yields `&i32`\n" msgstr "// `array1.iter()`는 `&i32`를 생성합니다\n" #: src/fn/closures/closure_examples/iter_find.md:46 msgid "\"Find 2 in array1: {:?}\"" msgstr "\"array1에서 2 찾기: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:47 msgid "// `array2.into_iter()` yields `i32`\n" msgstr "// `array2.into_iter()`는 `i32`를 생성합니다\n" #: src/fn/closures/closure_examples/iter_find.md:48 msgid "\"Find 2 in array2: {:?}\"" msgstr "\"array2에서 2 찾기: {:?}\"" #: src/fn/closures/closure_examples/iter_find.md:52 msgid "" "`Iterator::find` gives you a reference to the item. But if you want the " "_index_ of the item, use `Iterator::position`." msgstr "" "`Iterator::find`는 아이템에 대한 참조를 제공합니다. 하지만 아이템의 인덱스를 " "원한다면 `Iterator::position`을 사용하세요." #: src/fn/closures/closure_examples/iter_find.md:59 msgid "" "// `position` passes the iterator’s `Item` by value to the predicate.\n" " // `vec.iter()` yields `&i32`, so the predicate receives `&i32`,\n" " // which we pattern-match to dereference to `i32`.\n" msgstr "" "// `position`은 이터레이터의 `Item`을 값으로 서술어에 전달합니다.\n" "// `vec.iter()`는 `&i32`를 생성하므로 서술어는 `&i32`를 받으며,\n" "// 우리는 이를 패턴 매칭하여 `i32`로 역참조합니다.\n" #: src/fn/closures/closure_examples/iter_find.md:65 msgid "" "// `vec.into_iter()` yields `i32`, so the predicate receives `i32` " "directly.\n" msgstr "" "// `vec.into_iter()`는 `i32`를 생성하므로 서술어는 `i32`를 직접 받습니다.\n" #: src/fn/closures/closure_examples/iter_find.md:73 msgid "" "[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find)" msgstr "" "[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find)" #: src/fn/closures/closure_examples/iter_find.md:75 msgid "" "[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find_map)" msgstr "" "[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find_map)" #: src/fn/closures/closure_examples/iter_find.md:77 msgid "" "[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.position)" msgstr "" "[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.position)" #: src/fn/closures/closure_examples/iter_find.md:79 msgid "" "[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.rposition)" msgstr "" "[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.rposition)" #: src/fn/hof.md:3 msgid "" "Rust provides Higher Order Functions (HOF). These are functions that take " "one or more functions and/or produce a more useful function. HOFs and lazy " "iterators give Rust its functional flavor." msgstr "" "Rust는 고차 함수(Higher Order Functions, HOF)를 제공합니다. 이들은 하나 이상" "의 함수를 인자로 받거나 더 유용한 함수를 만들어내는 함수들입니다. HOF와 게으" "른(lazy) 이터레이터는 Rust에 함수형 프로그래밍의 풍미를 더해줍니다." #: src/fn/hof.md:13 msgid "\"Find the sum of all the numbers with odd squares under 1000\"" msgstr "\"1000 미만의 홀수 제곱값들의 합 찾기\"" #: src/fn/hof.md:16 msgid "" "// Imperative approach\n" " // Declare accumulator variable\n" msgstr "" "// 명령형 접근 방식\n" "// 누적 변수 선언\n" #: src/fn/hof.md:19 msgid "// Iterate: 0, 1, 2, ... to infinity\n" msgstr "// 반복: 0, 1, 2, ... 무한대까지\n" #: src/fn/hof.md:21 msgid "// Square the number\n" msgstr "// 숫자를 제곱합니다\n" #: src/fn/hof.md:25 msgid "// Break loop if exceeded the upper limit\n" msgstr "// 상한을 초과하면 루프를 종료합니다\n" #: src/fn/hof.md:28 msgid "// Accumulate value, if it's odd\n" msgstr "// 홀수라면 값을 누적합니다\n" #: src/fn/hof.md:32 msgid "\"imperative style: {}\"" msgstr "\"명령형 스타일: {}\"" #: src/fn/hof.md:34 msgid "// Functional approach\n" msgstr "// 함수형 접근 방식\n" #: src/fn/hof.md:36 msgid "// Below upper limit\n" msgstr "// 상한 미만\n" #: src/fn/hof.md:37 msgid "// That are odd\n" msgstr "// 홀수인 것들\n" #: src/fn/hof.md:38 msgid "// Sum them\n" msgstr "// 합계를 구함\n" #: src/fn/hof.md:39 msgid "\"functional style: {}\"" msgstr "\"함수형 스타일: {}\"" #: src/fn/hof.md:43 msgid "" "[Option](https://doc.rust-lang.org/core/option/enum.Option.html) and " "[Iterator](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "implement their fair share of HOFs." msgstr "" "[Option](https://doc.rust-lang.org/core/option/enum.Option.html)과 [Iterator]" "(https://doc.rust-lang.org/core/iter/trait.Iterator.html)는 상당수의 HOF를 구" "현하고 있습니다." #: src/fn/diverging.md:3 msgid "" "Diverging functions never return. They are marked using `!`, which is an " "empty type." msgstr "" "발산 함수(Diverging functions)는 절대 반환되지 않습니다. 이들은 빈 타입인 `!`" "를 사용하여 표시됩니다." #: src/fn/diverging.md:7 src/fn/diverging.md:35 msgid "\"This call never returns.\"" msgstr "\"이 호출은 절대 반환되지 않습니다.\"" #: src/fn/diverging.md:11 msgid "" "As opposed to all the other types, this one cannot be instantiated, because " "the set of all possible values this type can have is empty. Note that, it is " "different from the `()` type, which has exactly one possible value." msgstr "" "다른 모든 타입들과 달리, 이 타입은 인스턴스화할 수 없습니다. 이 타입이 가질 " "수 있는 모든 가능한 값의 집합이 비어 있기 때문입니다. 이는 정확히 하나의 가능" "한 값을 갖는 `()` 타입과는 다르다는 점에 유의하세요." #: src/fn/diverging.md:15 msgid "" "For example, this function returns as usual, although there is no " "information in the return value." msgstr "예를 들어, 이 함수는 반환 값에 정보가 없더라도 평소와 같이 반환됩니다." #: src/fn/diverging.md:25 msgid "\"This function returns and you can see this line.\"" msgstr "\"이 함수는 반환되며 당신은 이 줄을 볼 수 있습니다.\"" #: src/fn/diverging.md:29 msgid "" "As opposed to this function, which will never return the control back to the " "caller." msgstr "반면 이 함수는 호출자에게 제어권을 절대 반환하지 않습니다." #: src/fn/diverging.md:36 msgid "\"You will never see this line!\"" msgstr "\"당신은 결코 이 줄을 볼 수 없을 것입니다!\"" #: src/fn/diverging.md:40 msgid "" "Although this might seem like an abstract concept, it is actually very " "useful and often handy. The main advantage of this type is that it can be " "cast to any other type, making it versatile in situations where an exact " "type is required, such as in match branches. This flexibility allows us to " "write code like this:" msgstr "" "이것이 추상적인 개념처럼 보일 수 있지만, 실제로는 매우 유용하며 종종 편리하" "게 사용됩니다. 이 타입의 주요 장점은 다른 어떤 타입으로도 형변환될 수 있다는 " "것이며, 이는 match 분기와 같이 정확한 타입이 요구되는 상황에서 다재다능하게 " "만들어줍니다. 이러한 유연성 덕분에 다음과 같은 코드를 작성할 수 있습니다:" #: src/fn/diverging.md:50 msgid "" "// Notice that the return type of this match expression must be u32\n" " // because of the type of the \"addition\" variable.\n" msgstr "" "// 이 match 표현식의 반환 타입은 \"addition\" 변수의 타입 때문에\n" "// 반드시 u32여야 함에 주목하세요.\n" #: src/fn/diverging.md:53 msgid "// The \"i\" variable is of type u32, which is perfectly fine.\n" msgstr "// \"i\" 변수는 u32 타입이며, 이는 완벽하게 괜찮습니다.\n" #: src/fn/diverging.md:55 msgid "" "// On the other hand, the \"continue\" expression does not return\n" " // u32, but it is still fine, because it never returns and " "therefore\n" " // does not violate the type requirements of the match " "expression.\n" msgstr "" "// 반면에 \"continue\" 표현식은 u32를 반환하지 않지만,\n" "// 결코 반환되지 않으므로 match 표현식의 타입 요구 사항을\n" "// 위반하지 않으며 여전히 괜찮습니다.\n" #: src/fn/diverging.md:64 msgid "\"Sum of odd numbers up to 9 (excluding): {}\"" msgstr "\"9 미만의 홀수들의 합: {}\"" #: src/fn/diverging.md:68 msgid "" "It is also the return type of functions that loop forever (e.g. `loop {}`) " "like network servers or functions that terminate the process (e.g. `exit()`)." msgstr "" "또한 네트워크 서버처럼 영원히 루프를 도는 함수(예: `loop {}`)나 프로세스를 종" "료하는 함수(예: `exit()`)의 반환 타입이기도 합니다." #: src/mod.md:3 msgid "" "Rust provides a powerful module system that can be used to hierarchically " "split code in logical units (modules), and manage visibility (public/" "private) between them." msgstr "" "Rust는 코드를 논리적 단위(모듈)로 계층적으로 나누고, 그들 사이의 가시성" "(public/private)을 관리하는 데 사용할 수 있는 강력한 모듈 시스템을 제공합니" "다." #: src/mod.md:7 msgid "" "A module is a collection of items: functions, structs, traits, `impl` " "blocks, and even other modules." msgstr "" "모듈은 함수, 구조체, 트레이트, `impl` 블록, 그리고 다른 모듈까지 포함하는 아" "이템들의 모음입니다." #: src/mod/visibility.md:3 msgid "" "By default, the items in a module have private visibility, but this can be " "overridden with the `pub` modifier. Only the public items of a module can be " "accessed from outside the module scope." msgstr "" "기본적으로 모듈 내의 아이템들은 비공개(private) 가시성을 가지지만, `pub` 수식" "어를 사용하여 이를 재정의할 수 있습니다. 모듈 스코프 외부에서는 모듈의 공개" "(public) 아이템만 접근할 수 있습니다." #: src/mod/visibility.md:8 msgid "// A module named `my_mod`\n" msgstr "// `my_mod`라는 이름의 모듈\n" #: src/mod/visibility.md:10 msgid "// Items in modules default to private visibility.\n" msgstr "// 모듈 내의 아이템들은 기본적으로 비공개 가시성을 가집니다.\n" #: src/mod/visibility.md:12 msgid "\"called `my_mod::private_function()`\"" msgstr "\"`my_mod::private_function()` 호출됨\"" #: src/mod/visibility.md:15 msgid "// Use the `pub` modifier to override default visibility.\n" msgstr "// 기본 가시성을 재정의하려면 `pub` 수식어를 사용하세요.\n" #: src/mod/visibility.md:17 msgid "\"called `my_mod::function()`\"" msgstr "\"`my_mod::function()` 호출됨\"" #: src/mod/visibility.md:20 msgid "" "// Items can access other items in the same module,\n" " // even when private.\n" msgstr "" "// 아이템들은 같은 모듈 내의 다른 아이템들에 접근할 수 있으며,\n" "// 이는 비공개 아이템이라도 마찬가지입니다.\n" #: src/mod/visibility.md:23 msgid "\"called `my_mod::indirect_access()`, that\\n> \"" msgstr "\"`my_mod::indirect_access()` 호출됨, 결과는\\n> \"" #: src/mod/visibility.md:27 msgid "// Modules can also be nested\n" msgstr "// 모듈은 중첩될 수도 있습니다\n" #: src/mod/visibility.md:30 msgid "\"called `my_mod::nested::function()`\"" msgstr "\"`my_mod::nested::function()` 호출됨\"" #: src/mod/visibility.md:35 msgid "\"called `my_mod::nested::private_function()`\"" msgstr "\"`my_mod::nested::private_function()` 호출됨\"" #: src/mod/visibility.md:38 msgid "" "// Functions declared using `pub(in path)` syntax are only visible\n" " // within the given path. `path` must be a parent or ancestor " "module\n" msgstr "" "// `pub(in path)` 구문을 사용하여 선언된 함수들은 오직 지정된\n" "// 경로 내에서만 보입니다. `path`는 반드시 부모 또는 조상 모듈이어야 합니" "다.\n" #: src/mod/visibility.md:41 msgid "\"called `my_mod::nested::public_function_in_my_mod()`, that\\n> \"" msgstr "\"`my_mod::nested::public_function_in_my_mod()` 호출됨, 결과는\\n> \"" #: src/mod/visibility.md:45 msgid "" "// Functions declared using `pub(self)` syntax are only visible within\n" " // the current module, which is the same as leaving them private\n" msgstr "" "// `pub(self)` 구문을 사용하여 선언된 함수들은 오직 현재 모듈\n" "// 내에서만 보이며, 이는 비공개로 두는 것과 동일합니다.\n" #: src/mod/visibility.md:48 msgid "\"called `my_mod::nested::public_function_in_nested()`\"" msgstr "\"`my_mod::nested::public_function_in_nested()` 호출됨\"" #: src/mod/visibility.md:51 msgid "" "// Functions declared using `pub(super)` syntax are only visible within\n" " // the parent module\n" msgstr "" "// `pub(super)` 구문을 사용하여 선언된 함수들은 오직 부모 모듈\n" "// 내에서만 보입니다.\n" #: src/mod/visibility.md:54 msgid "\"called `my_mod::nested::public_function_in_super_mod()`\"" msgstr "\"`my_mod::nested::public_function_in_super_mod()` 호출됨\"" #: src/mod/visibility.md:59 msgid "\"called `my_mod::call_public_function_in_my_mod()`, that\\n> \"" msgstr "\"`my_mod::call_public_function_in_my_mod()` 호출됨, 결과는\\n> \"" #: src/mod/visibility.md:61 msgid "\"> \"" msgstr "\"> \"" #: src/mod/visibility.md:65 msgid "// pub(crate) makes functions visible only within the current crate\n" msgstr "// pub(crate)는 함수를 오직 현재 크레이트 내에서만 보이게 만듭니다\n" #: src/mod/visibility.md:67 msgid "\"called `my_mod::public_function_in_crate()`\"" msgstr "\"`my_mod::public_function_in_crate()` 호출됨\"" #: src/mod/visibility.md:70 msgid "// Nested modules follow the same rules for visibility\n" msgstr "// 중첩된 모듈도 동일한 가시성 규칙을 따릅니다\n" #: src/mod/visibility.md:74 msgid "\"called `my_mod::private_nested::function()`\"" msgstr "\"`my_mod::private_nested::function()` 호출됨\"" #: src/mod/visibility.md:77 msgid "" "// Private parent items will still restrict the visibility of a child item,\n" " // even if it is declared as visible within a bigger scope.\n" msgstr "" "// 비공개 부모 아이템은 자식 아이템이 더 큰 스코프 내에서 보이도록\n" "// 선언되어 있더라도 여전히 그 가시성을 제한합니다.\n" #: src/mod/visibility.md:81 msgid "\"called `my_mod::private_nested::restricted_function()`\"" msgstr "\"`my_mod::private_nested::restricted_function()` 호출됨\"" #: src/mod/visibility.md:87 src/mod/use.md:25 src/mod/super.md:8 #: src/mod/split.md:24 msgid "\"called `function()`\"" msgstr "\"`function()` 호출됨\"" #: src/mod/visibility.md:91 msgid "" "// Modules allow disambiguation between items that have the same name.\n" msgstr "" "// 모듈은 이름이 같은 아이템들 간의 모호함을 해소할 수 있게 해줍니다.\n" #: src/mod/visibility.md:95 msgid "" "// Public items, including those inside nested modules, can be\n" " // accessed from outside the parent module.\n" msgstr "" "// 중첩된 모듈 내부에 있는 아이템을 포함한 공개 아이템들은\n" "// 부모 모듈 외부에서 접근할 수 있습니다.\n" #: src/mod/visibility.md:101 msgid "// pub(crate) items can be called from anywhere in the same crate\n" msgstr "" "// pub(crate) 아이템은 같은 크레이트 내 어디에서나 호출될 수 있습니다\n" #: src/mod/visibility.md:104 msgid "" "// pub(in path) items can only be called from within the module specified\n" " // Error! function `public_function_in_my_mod` is private\n" " //my_mod::nested::public_function_in_my_mod();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// `pub(in path)` 아이템은 오직 지정된 모듈 내에서만 호출될 수 있습니다\n" "// 에러! `public_function_in_my_mod` 함수는 비공개입니다\n" "// my_mod::nested::public_function_in_my_mod();\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/visibility.md:109 msgid "" "// Private items of a module cannot be directly accessed, even if\n" " // nested in a public module:\n" msgstr "" "// 모듈의 비공개 아이템은 공개 모듈에 중첩되어 있더라도\n" "// 직접 접근할 수 없습니다:\n" #: src/mod/visibility.md:112 msgid "" "// Error! `private_function` is private\n" " //my_mod::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `private_function`은 비공개입니다\n" "// my_mod::private_function();\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/visibility.md:116 msgid "" "// Error! `private_function` is private\n" " //my_mod::nested::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `private_function`은 비공개입니다\n" "// my_mod::nested::private_function();\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/visibility.md:120 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `private_nested`는 비공개 모듈입니다\n" "// my_mod::private_nested::function();\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/visibility.md:124 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::restricted_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `private_nested`는 비공개 모듈입니다\n" "// my_mod::private_nested::restricted_function();\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/struct_visibility.md:3 msgid "" "Structs have an extra level of visibility with their fields. The visibility " "defaults to private, and can be overridden with the `pub` modifier. This " "visibility only matters when a struct is accessed from outside the module " "where it is defined, and has the goal of hiding information (encapsulation)." msgstr "" "구조체는 필드에 대해 추가적인 수준의 가시성을 가집니다. 가시성은 기본적으로 " "비공개이며, `pub` 수식어로 재정의할 수 있습니다. 이 가시성은 구조체가 정의된 " "모듈 외부에서 접근할 때만 의미가 있으며, 정보를 숨기는 것(캡슐화)이 목적입니" "다." #: src/mod/struct_visibility.md:10 msgid "// A public struct with a public field of generic type `T`\n" msgstr "// 제네릭 타입 `T`의 공개 필드를 가진 공개 구조체\n" #: src/mod/struct_visibility.md:15 msgid "// A public struct with a private field of generic type `T`\n" msgstr "// 제네릭 타입 `T`의 비공개 필드를 가진 공개 구조체\n" #: src/mod/struct_visibility.md:21 msgid "// A public constructor method\n" msgstr "// 공개 생성자 메서드\n" #: src/mod/struct_visibility.md:31 msgid "// Public structs with public fields can be constructed as usual\n" msgstr "// 공개 필드를 가진 공개 구조체는 평소처럼 생성할 수 있습니다\n" #: src/mod/struct_visibility.md:32 msgid "\"public information\"" msgstr "\"공개 정보\"" #: src/mod/struct_visibility.md:34 msgid "// and their fields can be normally accessed.\n" msgstr "// 그리고 그 필드들에 정상적으로 접근할 수 있습니다.\n" #: src/mod/struct_visibility.md:35 msgid "\"The open box contains: {}\"" msgstr "\"열린 박스 내용물: {}\"" #: src/mod/struct_visibility.md:37 msgid "" "// Public structs with private fields cannot be constructed using field " "names.\n" " // Error! `ClosedBox` has private fields\n" " //let closed_box = my::ClosedBox { contents: \"classified " "information\" };\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 비공개 필드를 가진 공개 구조체는 필드 이름을 사용하여 생성할 수 없습니" "다.\n" "// 에러! `ClosedBox`에 비공개 필드가 있습니다\n" "// let closed_box = my::ClosedBox { contents: \"classified information\" };\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/struct_visibility.md:42 msgid "" "// However, structs with private fields can be created using\n" " // public constructors\n" msgstr "" "// 하지만 비공개 필드를 가진 구조체는 공개 생성자를 통해 생성할 수 있습니다\n" #: src/mod/struct_visibility.md:44 msgid "\"classified information\"" msgstr "\"기밀 정보\"" #: src/mod/struct_visibility.md:46 msgid "" "// and the private fields of a public struct cannot be accessed.\n" " // Error! The `contents` field is private\n" " //println!(\"The closed box contains: {}\", _closed_box.contents);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 그리고 공개 구조체의 비공개 필드에는 접근할 수 없습니다.\n" "// 에러! `contents` 필드는 비공개입니다\n" "// println!(\"닫힌 박스 내용물: {}\", _closed_box.contents);\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/mod/struct_visibility.md:55 msgid "[generics](../generics.md) and [methods](../fn/methods.md)" msgstr "[제네릭](../generics.md) 및 [메서드](../fn/methods.md)" #: src/mod/use.md:3 msgid "" "The `use` declaration can be used to bind a full path to a new name, for " "easier access. It is often used like this:" msgstr "" "`use` 선언을 사용하여 전체 경로를 새로운 이름에 바인딩하여 더 쉽게 접근할 수 " "있습니다. 다음과 같이 자주 사용됩니다:" #: src/mod/use.md:18 msgid "You can use the `as` keyword to bind imports to a different name:" msgstr "" "`as` 키워드를 사용하여 임포트(imports)를 다른 이름에 바인딩할 수 있습니다:" #: src/mod/use.md:21 msgid "// Bind the `deeply::nested::function` path to `other_function`.\n" msgstr "" "// `deeply::nested::function` 경로를 `other_function`에 바인딩합니다.\n" #: src/mod/use.md:31 msgid "\"called `deeply::nested::function()`\"" msgstr "\"`deeply::nested::function()` 호출됨\"" #: src/mod/use.md:37 msgid "// Easier access to `deeply::nested::function`\n" msgstr "// `deeply::nested::function`에 더 쉽게 접근\n" #: src/mod/use.md:40 msgid "\"Entering block\"" msgstr "\"블록 진입\"" #: src/mod/use.md:42 msgid "" "// This is equivalent to `use deeply::nested::function as function`.\n" " // This `function()` will shadow the outer one.\n" msgstr "" "// 이는 `use deeply::nested::function as function`과 동일합니다.\n" "// 이 `function()`은 외부의 것을 섀도잉합니다.\n" #: src/mod/use.md:46 msgid "" "// `use` bindings have a local scope. In this case, the\n" " // shadowing of `function()` is only in this block.\n" msgstr "" "// `use` 바인딩은 지역 스코프를 가집니다. 이 경우\n" "// `function()`의 섀도잉은 이 블록 내에서만 유효합니다.\n" #: src/mod/use.md:50 msgid "\"Leaving block\"" msgstr "\"블록 나감\"" #: src/mod/super.md:3 msgid "" "The `super` and `self` keywords can be used in the path to remove ambiguity " "when accessing items and to prevent unnecessary hardcoding of paths." msgstr "" "`super`와 `self` 키워드는 아이템에 접근할 때 모호함을 제거하고 경로의 불필요" "한 하드코딩을 방지하기 위해 경로 내에서 사용될 수 있습니다." #: src/mod/super.md:13 msgid "\"called `cool::function()`\"" msgstr "\"`cool::function()` 호출됨\"" #: src/mod/super.md:19 src/mod/split.md:49 msgid "\"called `my::function()`\"" msgstr "\"`my::function()` 호출됨\"" #: src/mod/super.md:24 msgid "\"called `my::cool::function()`\"" msgstr "\"`my::cool::function()` 호출됨\"" #: src/mod/super.md:29 msgid "// Let's access all the functions named `function` from this scope!\n" msgstr "// 이 스코프에서 `function`이라는 이름의 모든 함수에 접근해 봅시다!\n" #: src/mod/super.md:30 msgid "\"called `my::indirect_call()`, that\\n> \"" msgstr "\"`my::indirect_call()` 호출됨, 결과는\\n> \"" #: src/mod/super.md:32 msgid "" "// The `self` keyword refers to the current module scope - in this case " "`my`.\n" " // Calling `self::function()` and calling `function()` directly both " "give\n" " // the same result, because they refer to the same function.\n" msgstr "" "// `self` 키워드는 현재 모듈 스코프를 가리킵니다. 이 경우 `my`입니다.\n" "// `self::function()`을 호출하는 것과 `function()`을 직접 호출하는 것은\n" "// 동일한 함수를 가리키기 때문에 같은 결과를 냅니다.\n" #: src/mod/super.md:38 msgid "// We can also use `self` to access another module inside `my`:\n" msgstr "// `self`를 사용하여 `my` 내부의 다른 모듈에 접근할 수도 있습니다:\n" #: src/mod/super.md:41 msgid "" "// The `super` keyword refers to the parent scope (outside the `my` " "module).\n" msgstr "// `super` 키워드는 부모 스코프(`my` 모듈 외부)를 가리킵니다.\n" #: src/mod/super.md:44 msgid "" "// This will bind to the `cool::function` in the *crate* scope.\n" " // In this case the crate scope is the outermost scope.\n" msgstr "" "// 이는 *크레이트* 스코프에 있는 `cool::function`에 바인딩됩니다.\n" "// 이 경우 크레이트 스코프는 가장 바깥쪽 스코프입니다.\n" #: src/mod/split.md:3 msgid "" "Modules can be mapped to a file/directory hierarchy. Let's break down the " "[visibility example](visibility.md) in files:" msgstr "" "모듈은 파일/디렉토리 계층 구조에 매핑될 수 있습니다. [가시성 예제]" "(visibility.md)를 파일별로 나누어 봅시다:" #: src/mod/split.md:16 msgid "In `split.rs`:" msgstr "`split.rs`에서:" #: src/mod/split.md:19 msgid "" "// This declaration will look for a file named `my.rs` and will\n" "// insert its contents inside a module named `my` under this scope\n" msgstr "" "// 이 선언은 `my.rs`라는 파일을 찾아 그 내용을\n" "// 이 스코프 아래의 `my`라는 이름의 모듈로 삽입할 것입니다\n" #: src/mod/split.md:39 msgid "In `my.rs`:" msgstr "`my.rs`에서:" #: src/mod/split.md:42 msgid "" "// Similarly `mod inaccessible` and `mod nested` will locate the " "`nested.rs`\n" "// and `inaccessible.rs` files and insert them here under their respective\n" "// modules\n" msgstr "" "// 마찬가지로 `mod inaccessible`과 `mod nested`는 `nested.rs`와\n" "// `inaccessible.rs` 파일을 찾아 각각의 모듈 아래에\n" "// 삽입할 것입니다\n" #: src/mod/split.md:53 msgid "\"called `my::private_function()`\"" msgstr "\"`my::private_function()` 호출됨\"" #: src/mod/split.md:57 msgid "\"called `my::indirect_access()`, that\\n> \"" msgstr "\"`my::indirect_access()` 호출됨, 결과는\\n> \"" #: src/mod/split.md:63 msgid "In `my/nested.rs`:" msgstr "`my/nested.rs`에서:" #: src/mod/split.md:67 msgid "\"called `my::nested::function()`\"" msgstr "\"`my::nested::function()` 호출됨\"" #: src/mod/split.md:72 msgid "\"called `my::nested::private_function()`\"" msgstr "\"`my::nested::private_function()` 호출됨\"" #: src/mod/split.md:76 msgid "In `my/inaccessible.rs`:" msgstr "`my/inaccessible.rs`에서:" #: src/mod/split.md:81 msgid "\"called `my::inaccessible::public_function()`\"" msgstr "\"`my::inaccessible::public_function()` 호출됨\"" #: src/mod/split.md:85 msgid "Let's check that things still work as before:" msgstr "모든 것이 이전과 같이 여전히 잘 작동하는지 확인해 봅시다:" #: src/crates.md:3 msgid "" "A crate is a compilation unit in Rust. Whenever `rustc some_file.rs` is " "called, `some_file.rs` is treated as the _crate file_. If `some_file.rs` has " "`mod` declarations in it, then the contents of the module files would be " "inserted in places where `mod` declarations in the crate file are found, " "_before_ running the compiler over it. In other words, modules do _not_ get " "compiled individually, only crates get compiled." msgstr "" "크레이트(crate)는 Rust의 컴파일 단위입니다. `rustc some_file.rs`가 호출될 때" "마다 `some_file.rs`는 _크레이트 파일_로 처리됩니다. 만약 `some_file.rs` 내부" "에 `mod` 선언이 있다면, 컴파일러가 실행되기 _전_에 크레이트 파일에서 `mod` 선" "언이 발견된 위치에 모듈 파일의 내용이 삽입됩니다. 즉, 모듈은 개별적으로 컴파" "일되지 않으며 오직 크레이트만 컴파일됩니다." #: src/crates.md:10 msgid "" "A crate can be compiled into a binary or into a library. By default, `rustc` " "will produce a binary from a crate. This behavior can be overridden by " "passing the `--crate-type` flag to `lib`." msgstr "" "크레이트는 바이너리 또는 라이브러리로 컴파일될 수 있습니다. 기본적으로 " "`rustc`는 크레이트로부터 바이너리를 생성합니다. 이 동작은 `--crate-type` 플래" "그에 `lib`을 전달하여 재정의할 수 있습니다." #: src/crates/lib.md:3 msgid "Let's create a library, and then see how to link it to another crate." msgstr "" "라이브러리를 만든 다음, 이를 다른 크레이트와 어떻게 연결하는지 살펴봅시다." #: src/crates/lib.md:5 msgid "In `rary.rs`:" msgstr "`rary.rs`에서:" #: src/crates/lib.md:9 src/attribute/crate.md:19 msgid "\"called rary's `public_function()`\"" msgstr "rary의 `public_function()` 호출됨" #: src/crates/lib.md:13 src/attribute/crate.md:23 msgid "\"called rary's `private_function()`\"" msgstr "rary의 `private_function()` 호출됨" #: src/crates/lib.md:17 src/attribute/crate.md:27 msgid "\"called rary's `indirect_access()`, that\\n> \"" msgstr "rary의 `indirect_access()` 호출됨, 결과는\\n> \"" #: src/crates/lib.md:29 msgid "" "Libraries get prefixed with \"lib\", and by default they get named after " "their crate file, but this default name can be overridden by passing the `--" "crate-name` option to `rustc` or by using the [`crate_name` attribute](../" "attribute/crate.md)." msgstr "" "라이브러리에는 \"lib\" 접두사가 붙으며, 기본적으로 크레이트 파일의 이름을 따" "서 명명되지만, 이 기본 이름은 `rustc`에 `--crate-name` 옵션을 전달하거나 " "[`crate_name` 속성](../attribute/crate.md)을 사용하여 재정의할 수 있습니다." #: src/crates/using_lib.md:3 msgid "" "To link a crate to this new library you may use `rustc`'s `--extern` flag. " "All of its items will then be imported under a module named the same as the " "library. This module generally behaves the same way as any other module." msgstr "" "이 새로운 라이브러리에 크레이트를 연결하려면 `rustc`의 `--extern` 플래그를 사" "용할 수 있습니다. 그러면 모든 아이템은 라이브러리와 동일한 이름을 가진 모듈 " "아래로 임포트됩니다. 이 모듈은 일반적으로 다른 모듈과 동일하게 동작합니다." #: src/crates/using_lib.md:8 msgid "" "// extern crate rary; // May be required for Rust 2015 edition or earlier\n" msgstr "" "// extern crate rary; // Rust 2015 에디션 이하에서는 필요할 수 있습니다\n" #: src/crates/using_lib.md:13 msgid "" "// Error! `private_function` is private\n" " //rary::private_function();\n" msgstr "" "// 에러! `private_function`은 비공개입니다\n" "// rary::private_function();\n" #: src/cargo.md:3 msgid "" "`cargo` is the official Rust package management tool. It has lots of really " "useful features to improve code quality and developer velocity! These include" msgstr "" "`cargo`는 Rust 공식 패키지 관리 도구입니다. 코드 품질과 개발 속도를 향상시키" "기 위한 정말 유용한 기능들을 많이 가지고 있습니다! 다음과 같은 기능들이 포함" "됩니다:" #: src/cargo.md:6 msgid "" "Dependency management and integration with [crates.io](https://crates.io) " "(the official Rust package registry)" msgstr "" "[crates.io](https://crates.io) (공식 Rust 패키지 레지스트리)와의 통합 및 의존" "성 관리" #: src/cargo.md:8 msgid "Awareness of unit tests" msgstr "유닛 테스트 지원" #: src/cargo.md:9 msgid "Awareness of benchmarks" msgstr "벤치마크 지원" #: src/cargo.md:11 msgid "" "This chapter will go through some quick basics, but you can find the " "comprehensive docs in [The Cargo Book](https://doc.rust-lang.org/cargo/)." msgstr "" "이 장에서는 기본적인 사항들을 빠르게 살펴볼 것입니다. 더 자세한 문서는 [The " "Cargo Book](https://doc.rust-lang.org/cargo/)에서 찾을 수 있습니다." #: src/cargo/deps.md:3 msgid "" "Most programs have dependencies on some libraries. If you have ever managed " "dependencies by hand, you know how much of a pain this can be. Luckily, the " "Rust ecosystem comes standard with `cargo`! `cargo` can manage dependencies " "for a project." msgstr "" "대부분의 프로그램은 일부 라이브러리에 의존성을 가집니다. 의존성을 수동으로 관" "리해 본 적이 있다면 그것이 얼마나 고통스러운 일인지 알 것입니다. 다행히도 " "Rust 생태계에는 `cargo`가 표준으로 포함되어 있습니다! `cargo`는 프로젝트의 의" "존성을 관리할 수 있습니다." #: src/cargo/deps.md:8 msgid "To create a new Rust project," msgstr "새로운 Rust 프로젝트를 만들려면," #: src/cargo/deps.md:11 msgid "# A binary\n" msgstr "# 바이너리\n" #: src/cargo/deps.md:13 msgid "# A library\n" msgstr "# 라이브러리\n" #: src/cargo/deps.md:18 msgid "" "For the rest of this chapter, let's assume we are making a binary, rather " "than a library, but all of the concepts are the same." msgstr "" "이 장의 나머지 부분에서는 라이브러리가 아닌 바이너리를 만든다고 가정하겠습니" "다. 하지만 모든 개념은 동일합니다." #: src/cargo/deps.md:21 msgid "After the above commands, you should see a file hierarchy like this:" msgstr "" "위의 명령어를 실행한 후에는 다음과 같은 파일 계층 구조를 보게 될 것입니다:" #: src/cargo/deps.md:35 msgid "" "The `main.rs` is the root source file for your new `foo` project -- nothing " "new there. The `Cargo.toml` is the config file for `cargo` for this project. " "If you look inside it, you should see something like this:" msgstr "" "`main.rs`는 새로운 `foo` 프로젝트의 루트 소스 파일입니다. 특별할 것은 없습니" "다. `Cargo.toml`은 이 프로젝트에 대한 `cargo` 설정 파일입니다. 그 안을 들여다" "보면 다음과 같은 내용을 볼 수 있을 것입니다:" #: src/cargo/deps.md:39 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "```" msgstr "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "```" #: src/cargo/deps.md:48 msgid "" "The `name` field under `[package]` determines the name of the project. This " "is used by `crates.io` if you publish the crate (more later). It is also the " "name of the output binary when you compile." msgstr "" "`[package]` 아래의 `name` 필드는 프로젝트의 이름을 결정합니다. 이는 크레이트" "를 배포할 때(나중에 자세히 설명함) `crates.io`에서 사용됩니다. 또한 컴파일할 " "때 생성되는 바이너리의 이름이기도 합니다." #: src/cargo/deps.md:52 msgid "" "The `version` field is a crate version number using [Semantic Versioning]" "(http://semver.org/)." msgstr "" "`version` 필드는 [유의적 버전(Semantic Versioning)](http://semver.org/)을 사" "용하는 크레이트 버전 번호입니다." #: src/cargo/deps.md:55 msgid "" "The `authors` field is a list of authors used when publishing the crate." msgstr "`authors` 필드는 크레이트를 배포할 때 사용되는 작성자 목록입니다." #: src/cargo/deps.md:57 msgid "" "The `[dependencies]` section lets you add dependencies for your project." msgstr "" "`[dependencies]` 섹션에서는 프로젝트에 필요한 의존성을 추가할 수 있습니다." #: src/cargo/deps.md:59 msgid "" "For example, suppose that we want our program to have a great CLI. You can " "find lots of great packages on [crates.io](https://crates.io) (the official " "Rust package registry). One popular choice is [clap](https://crates.io/" "crates/clap). As of this writing, the most recent published version of " "`clap` is `2.27.1`. To add a dependency to our program, we can simply add " "the following to our `Cargo.toml` under `[dependencies]`: `clap = " "\"2.27.1\"`. And that's it! You can start using `clap` in your program." msgstr "" "예를 들어, 우리 프로그램이 멋진 CLI를 갖기를 원한다고 가정해 봅시다. " "[crates.io](https://crates.io) (공식 Rust 패키지 레지스트리)에서 훌륭한 패키" "지들을 많이 찾을 수 있습니다. 인기 있는 선택지 중 하나는 [clap](https://" "crates.io/crates/clap)입니다. 이 글을 쓰는 시점에서 `clap`의 최신 버전은 " "`2.27.1`입니다. 프로그램에 의존성을 추가하려면 `Cargo.toml`의 " "`[dependencies]` 아래에 다음과 같이 추가하면 됩니다: `clap = \"2.27.1\"`. 이" "것으로 끝입니다! 이제 프로그램에서 `clap`을 사용할 수 있습니다." #: src/cargo/deps.md:67 msgid "" "`cargo` also supports [other types of dependencies](https://doc.rust-" "lang.org/cargo/reference/specifying-dependencies.html). Here is just a small " "sampling:" msgstr "" "`cargo`는 [다른 유형의 의존성](https://doc.rust-lang.org/cargo/reference/" "specifying-dependencies.html)도 지원합니다. 다음은 몇 가지 예시입니다:" #: src/cargo/deps.md:70 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "clap = \"2.27.1\" # from crates.io\n" "rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # from online " "repo\n" "bar = { path = \"../bar\" } # from a path in the local filesystem\n" "```" msgstr "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "clap = \"2.27.1\" # crates.io에서\n" "rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # 온라인 저장" "소에서\n" "bar = { path = \"../bar\" } # 로컬 파일시스템의 경로에서\n" "```" #: src/cargo/deps.md:82 msgid "" "`cargo` is more than a dependency manager. All of the available " "configuration options are listed in the [format specification](https://" "doc.rust-lang.org/cargo/reference/manifest.html) of `Cargo.toml`." msgstr "" "`cargo`는 단순한 의존성 관리자 그 이상입니다. 사용 가능한 모든 설정 옵션은 " "`Cargo.toml`의 [형식 명세(format specification)](https://doc.rust-lang.org/" "cargo/reference/manifest.html)에 나열되어 있습니다." #: src/cargo/deps.md:86 msgid "" "To build our project we can execute `cargo build` anywhere in the project " "directory (including subdirectories!). We can also do `cargo run` to build " "and run. Notice that these commands will resolve all dependencies, download " "crates if needed, and build everything, including your crate. (Note that it " "only rebuilds what it has not already built, similar to `make`)." msgstr "" "프로젝트를 빌드하려면 프로젝트 디렉토리 어디에서나(하위 디렉토리 포함!) " "`cargo build`를 실행하면 됩니다. 또한 `cargo run`을 통해 빌드와 실행을 동시" "에 할 수도 있습니다. 이 명령어들은 모든 의존성을 해결하고, 필요한 경우 크레이" "트를 다운로드하며, 여러분의 크레이트를 포함한 모든 것을 빌드합니다. (이미 빌" "드된 것은 다시 빌드하지 않으며, 이는 `make`와 유사합니다)." #: src/cargo/deps.md:92 msgid "Voila! That's all there is to it!" msgstr "보세요! 이게 전부입니다!" #: src/cargo/conventions.md:3 msgid "In the previous chapter, we saw the following directory hierarchy:" msgstr "이전 장에서 우리는 다음과 같은 디렉터리 계층 구조를 보았습니다." #: src/cargo/conventions.md:12 msgid "" "Suppose that we wanted to have two binaries in the same project, though. " "What then?" msgstr "" "하지만 같은 프로젝트에 두 개의 바이너리를 두고 싶다면 어떨까요? 그럴 땐 어떻" "게 해야 할까요?" #: src/cargo/conventions.md:15 msgid "" "It turns out that `cargo` supports this. The default binary name is `main`, " "as we saw before, but you can add additional binaries by placing them in a " "`bin/` directory:" msgstr "" "다행히 `cargo`는 이를 지원합니다. 이전에 보았듯이 기본 바이너리 이름은 `main`" "이지만, `bin/` 디렉터리에 추가 바이너리를 배치하여 추가할 수 있습니다." #: src/cargo/conventions.md:28 msgid "" "To tell `cargo` to only compile or run this binary, we just pass `cargo` the " "`--bin my_other_bin` flag, where `my_other_bin` is the name of the binary we " "want to work with." msgstr "" "`cargo`에게 이 바이너리만 컴파일하거나 실행하도록 하려면, `cargo`에 `--bin " "my_other_bin` 플래그를 전달하면 됩니다. 여기서 `my_other_bin`은 작업하려는 바" "이너리의 이름입니다." #: src/cargo/conventions.md:32 msgid "" "In addition to extra binaries, `cargo` supports [more features](https://" "doc.rust-lang.org/cargo/guide/project-layout.html) such as benchmarks, " "tests, and examples." msgstr "" "추가 바이너리 외에도 `cargo`는 벤치마크, 테스트, 예제와 같은 [더 많은 기능]" "(https://doc.rust-lang.org/cargo/guide/project-layout.html)을 지원합니다." #: src/cargo/conventions.md:35 msgid "In the next chapter, we will look more closely at tests." msgstr "다음 장에서는 테스트에 대해 더 자세히 살펴보겠습니다." #: src/cargo/test.md:3 msgid "" "As we know testing is integral to any piece of software! Rust has first-" "class support for unit and integration testing ([see this chapter](https://" "doc.rust-lang.org/book/ch11-00-testing.html) in TRPL)." msgstr "" "우리 모두 알다시피 테스트는 모든 소프트웨어의 필수적인 부분입니다! Rust는 유" "닛 테스트와 통합 테스트를 위한 일류(first-class) 지원을 제공합니다(TRPL의 " "[이 장](https://doc.rust-lang.org/book/ch11-00-testing.html)을 참조하세요)." #: src/cargo/test.md:7 msgid "" "From the testing chapters linked above, we see how to write unit tests and " "integration tests. Organizationally, we can place unit tests in the modules " "they test and integration tests in their own `tests/` directory:" msgstr "" "위에 링크된 테스트 장들에서 유닛 테스트와 통합 테스트를 작성하는 방법을 확인" "할 수 있습니다. 구조적으로 유닛 테스트는 테스트 대상 모듈에 배치하고, 통합 테" "스트는 별도의 `tests/` 디렉터리에 배치할 수 있습니다." #: src/cargo/test.md:22 msgid "" "Each file in `tests` is a separate [integration test](https://doc.rust-" "lang.org/book/ch11-03-test-organization.html#integration-tests), i.e. a test " "that is meant to test your library as if it were being called from a " "dependent crate." msgstr "" "`tests` 내의 각 파일은 별도의 [통합 테스트](https://doc.rust-lang.org/book/" "ch11-03-test-organization.html#integration-tests)입니다. 즉, 의존성 있는 크레" "이트에서 호출되는 것처럼 라이브러리를 테스트하기 위한 것입니다." #: src/cargo/test.md:27 msgid "" "The [Testing](../testing.md) chapter elaborates on the three different " "testing styles: [Unit](../testing/unit_testing.md), [Doc](../testing/" "doc_testing.md), and [Integration](../testing/integration_testing.md)." msgstr "" "[테스트](../testing.md) 장에서는 [유닛(Unit)](../testing/unit_testing.md), " "[문서(Doc)](../testing/doc_testing.md), [통합(Integration)](../testing/" "integration_testing.md)의 세 가지 테스트 스타일에 대해 자세히 설명합니다." #: src/cargo/test.md:30 msgid "`cargo` naturally provides an easy way to run all of your tests!" msgstr "`cargo`는 당연히 모든 테스트를 실행할 수 있는 쉬운 방법을 제공합니다!" #: src/cargo/test.md:36 msgid "You should see output like this:" msgstr "다음과 같은 출력을 볼 수 있을 것입니다:" #: src/cargo/test.md:38 msgid "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" msgstr "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "``````shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" #: src/cargo/test.md:53 msgid "You can also run tests whose name matches a pattern:" msgstr "이름이 패턴과 일치하는 테스트만 실행할 수도 있습니다:" #: src/cargo/test.md:59 msgid "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" msgstr "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" #: src/cargo/test.md:72 msgid "" "One word of caution: Cargo may run multiple tests concurrently, so make sure " "that they don't race with each other." msgstr "" "한 가지 주의할 점: Cargo는 여러 테스트를 동시에 실행할 수 있으므로 서로 경쟁" "(race)하지 않도록 확인해야 합니다." #: src/cargo/test.md:75 msgid "" "One example of this concurrency causing issues is if two tests output to a " "file, such as below:" msgstr "" "이러한 동시성이 문제를 일으키는 한 가지 예는 아래와 같이 두 테스트가 하나의 " "파일에 출력하는 경우입니다:" #: src/cargo/test.md:81 msgid "// Import the necessary modules\n" msgstr "// 필요한 모듈 가져오기\n" #: src/cargo/test.md:85 msgid "// This test writes to a file\n" msgstr "// 이 테스트는 파일에 씁니다\n" #: src/cargo/test.md:88 src/cargo/test.md:105 msgid "// Opens the file ferris.txt or creates one if it doesn't exist.\n" msgstr "// ferris.txt 파일을 열거나 없으면 생성합니다.\n" #: src/cargo/test.md:92 src/cargo/test.md:109 msgid "\"ferris.txt\"" msgstr "\"ferris.txt\"" #: src/cargo/test.md:93 src/cargo/test.md:110 msgid "\"Failed to open ferris.txt\"" msgstr "\"ferris.txt를 여는 데 실패했습니다\"" #: src/cargo/test.md:95 msgid "// Print \"Ferris\" 5 times.\n" msgstr "// \"Ferris\"를 5번 출력합니다.\n" #: src/cargo/test.md:97 msgid "\"Ferris\\n\"" msgstr "\"Ferris\\n\"" #: src/cargo/test.md:98 src/cargo/test.md:115 msgid "\"Could not write to ferris.txt\"" msgstr "\"ferris.txt에 쓸 수 없습니다\"" #: src/cargo/test.md:102 msgid "// This test tries to write to the same file\n" msgstr "// 이 테스트는 동일한 파일에 쓰기를 시도합니다\n" #: src/cargo/test.md:112 msgid "// Print \"Corro\" 5 times.\n" msgstr "// \"Corro\"를 5번 출력합니다.\n" #: src/cargo/test.md:114 msgid "\"Corro\\n\"" msgstr "\"Corro\\n\"" #: src/cargo/test.md:121 msgid "Although the intent is to get the following:" msgstr "의도는 다음과 같은 결과를 얻는 것이었지만:" #: src/cargo/test.md:137 msgid "What actually gets put into `ferris.txt` is this:" msgstr "`ferris.txt`에 실제로 기록된 내용은 다음과 같습니다:" #: src/cargo/build_scripts.md:3 msgid "" "Sometimes a normal build from `cargo` is not enough. Perhaps your crate " "needs some pre-requisites before `cargo` will successfully compile, things " "like code generation, or some native code that needs to be compiled. To " "solve this problem we have build scripts that Cargo can run." msgstr "" "`cargo`의 일반적인 빌드만으로는 충분하지 않은 경우가 있습니다. 코드 생성이나 " "컴파일되어야 하는 네이티브 코드와 같이 `cargo`가 성공적으로 컴파일되기 전에 " "크레이트가 필요로 하는 전제 조건이 있을 수 있습니다. 이 문제를 해결하기 위해 " "Cargo가 실행할 수 있는 빌드 스크립트가 있습니다." #: src/cargo/build_scripts.md:8 msgid "" "To add a build script to your package it can either be specified in the " "`Cargo.toml` as follows:" msgstr "" "패키지에 빌드 스크립트를 추가하려면 다음과 같이 `Cargo.toml`에 지정할 수 있습" "니다:" #: src/cargo/build_scripts.md:11 msgid "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" msgstr "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" #: src/cargo/build_scripts.md:17 msgid "" "Otherwise Cargo will look for a `build.rs` file in the project directory by " "default." msgstr "" "그렇지 않으면 Cargo는 기본적으로 프로젝트 디렉토리에서 `build.rs` 파일을 찾습" "니다." #: src/cargo/build_scripts.md:20 msgid "How to use a build script" msgstr "빌드 스크립트 사용 방법" #: src/cargo/build_scripts.md:22 msgid "" "The build script is simply another Rust file that will be compiled and " "invoked prior to compiling anything else in the package. Hence it can be " "used to fulfill pre-requisites of your crate." msgstr "" "빌드 스크립트는 단순히 또 다른 Rust 파일로, 패키지의 다른 어떤 것을 컴파일하" "기 전에 먼저 컴파일되고 호출됩니다. 따라서 크레이트의 전제 조건을 충족시키는 " "데 사용할 수 있습니다." #: src/cargo/build_scripts.md:26 msgid "" "Cargo provides the script with inputs via environment variables [specified " "here](https://doc.rust-lang.org/cargo/reference/environment-" "variables.html#environment-variables-cargo-sets-for-build-scripts) that can " "be used." msgstr "" "Cargo는 스크립트에서 사용할 수 있는 환경 변수([여기에 명시됨](https://" "doc.rust-lang.org/cargo/reference/environment-variables.html#environment-" "variables-cargo-sets-for-build-scripts))를 통해 입력을 제공합니다." #: src/cargo/build_scripts.md:29 msgid "" "The script provides output via stdout. All lines printed are written to " "`target/debug/build//output`. Further, lines prefixed with `cargo:` " "will be interpreted by Cargo directly and hence can be used to define " "parameters for the package's compilation." msgstr "" "스크립트는 stdout을 통해 출력을 제공합니다. 출력된 모든 줄은 `target/debug/" "build//output`에 기록됩니다. 또한, `cargo:`로 시작하는 줄은 Cargo에 의" "해 직접 해석되어 패키지 컴파일을 위한 매개변수를 정의하는 데 사용될 수 있습니" "다." #: src/cargo/build_scripts.md:34 msgid "" "For further specification and examples have a read of the [Cargo " "specification](https://doc.rust-lang.org/cargo/reference/build-scripts.html)." msgstr "" "추가적인 사양과 예제는 [Cargo 사양서](https://doc.rust-lang.org/cargo/" "reference/build-scripts.html)를 읽어보세요." #: src/attribute.md:3 msgid "" "An attribute is metadata applied to some module, crate or item. This " "metadata can be used to/for:" msgstr "" "속성(attribute)은 모듈, 크레이트 또는 아이템에 적용되는 메타데이터입니다. 이 " "메타데이터는 다음과 같은 용도로 사용될 수 있습니다:" #: src/attribute.md:8 msgid "[conditional compilation of code](attribute/cfg.md)" msgstr "코드의 [조건부 컴파일](attribute/cfg.md)" #: src/attribute.md:9 msgid "" "[set crate name, version and type (binary or library)](attribute/crate.md)" msgstr "" "[크레이트 이름, 버전 및 유형(바이너리 또는 라이브러리) 설정](attribute/" "crate.md)" #: src/attribute.md:10 msgid "" "disable [lints](https://en.wikipedia.org/wiki/Lint_%28software%29) (warnings)" msgstr "" "[린트(lints)](https://en.wikipedia.org/wiki/Lint_%28software%29) (경고) 비활" "성화" #: src/attribute.md:11 msgid "enable compiler features (macros, glob imports, etc.)" msgstr "컴파일러 기능(매크로, glob 임포트 등) 활성화" #: src/attribute.md:12 msgid "link to a foreign library" msgstr "외부 라이브러리 링크" #: src/attribute.md:13 msgid "mark functions as unit tests" msgstr "함수를 유닛 테스트로 표시" #: src/attribute.md:14 msgid "mark functions that will be part of a benchmark" msgstr "벤치마크의 일부가 될 함수 표시" #: src/attribute.md:15 msgid "" "[attribute like macros](https://doc.rust-lang.org/book/ch19-06-" "macros.html#attribute-like-macros)" msgstr "" "[속성형 매크로](https://doc.rust-lang.org/book/ch19-06-macros.html#attribute-" "like-macros)" #: src/attribute.md:17 msgid "" "Attributes look like `#[outer_attribute]` or `#![inner_attribute]`, with the " "difference between them being where they apply." msgstr "" "속성은 `#[outer_attribute]` 또는 `#![inner_attribute]`와 같은 형태를 띠며, " "이 둘의 차이점은 적용되는 위치에 있습니다." #: src/attribute.md:20 msgid "" "`#[outer_attribute]` applies to the [item](https://doc.rust-lang.org/stable/" "reference/items.html) immediately following it. Some examples of items are: " "a function, a module declaration, a constant, a structure, an enum. Here is " "an example where attribute `#[derive(Debug)]` applies to the struct " "`Rectangle`:" msgstr "" "`#[outer_attribute]`는 바로 뒤에 오는 [아이템](https://doc.rust-lang.org/" "stable/reference/items.html)에 적용됩니다. 아이템의 예로는 함수, 모듈 선언, " "상수, 구조체, 열거형 등이 있습니다. 다음은 `#[derive(Debug)]` 속성이 " "`Rectangle` 구조체에 적용된 예시입니다:" #: src/attribute.md:34 msgid "" "`#![inner_attribute]` applies to the enclosing [item](https://doc.rust-" "lang.org/stable/reference/items.html) (typically a module or a crate). In " "other words, this attribute is interpreted as applying to the entire scope " "in which it's placed. Here is an example where `#![allow(unused_variables)]` " "applies to the whole crate (if placed in `main.rs`):" msgstr "" "`#![inner_attribute]`는 자신을 감싸고 있는 [아이템](https://doc.rust-" "lang.org/stable/reference/items.html) (주로 모듈이나 크레이트)에 적용됩니다. " "다시 말해, 이 속성은 자신이 위치한 전체 스코프에 적용되는 것으로 해석됩니다. " "다음은 `#![allow(unused_variables)]`가 (`main.rs`에 위치할 경우) 전체 크레이" "트에 적용되는 예시입니다:" #: src/attribute.md:44 msgid "// This would normally warn about an unused variable.\n" msgstr "// 이것은 보통 사용되지 않는 변수에 대해 경고합니다.\n" #: src/attribute.md:48 msgid "Attributes can take arguments with different syntaxes:" msgstr "속성은 다양한 문법으로 인자를 받을 수 있습니다:" #: src/attribute.md:50 msgid "`#[attribute = \"value\"]`" msgstr "`#[attribute = \"value\"]`" #: src/attribute.md:51 msgid "`#[attribute(key = \"value\")]`" msgstr "`#[attribute(key = \"value\")]`" #: src/attribute.md:52 msgid "`#[attribute(value)]`" msgstr "`#[attribute(value)]`" #: src/attribute.md:54 msgid "" "Attributes can have multiple values and can be separated over multiple " "lines, too:" msgstr "속성은 여러 값을 가질 수 있으며 여러 줄에 걸쳐 분리될 수도 있습니다:" #: src/attribute/unused.md:3 msgid "" "The compiler provides a `dead_code` [_lint_](https://en.wikipedia.org/wiki/" "Lint_%28software%29) that will warn about unused functions. An _attribute_ " "can be used to disable the lint." msgstr "" "컴파일러는 사용되지 않는 함수에 대해 경고하는 `dead_code` [_린트(lint)_]" "(https://en.wikipedia.org/wiki/Lint_%28software%29)를 제공합니다. _속성_을 사" "용하여 이 린트를 비활성화할 수 있습니다." #: src/attribute/unused.md:9 msgid "" "// `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint\n" msgstr "" "// `#[allow(dead_code)]`는 `dead_code` 린트를 비활성화하는 속성입니다\n" #: src/attribute/unused.md:14 msgid "// FIXME ^ Add an attribute to suppress the warning\n" msgstr "// FIXME ^ 경고를 억제하기 위해 속성을 추가하세요\n" #: src/attribute/unused.md:22 msgid "" "Note that in real programs, you should eliminate dead code. In these " "examples we'll allow dead code in some places because of the interactive " "nature of the examples." msgstr "" "실제 프로그램에서는 죽은 코드를 제거해야 합니다. 이 예제들에서는 예제의 대화" "형 특성 때문에 일부 장소에서 죽은 코드를 허용할 것입니다." #: src/attribute/crate.md:3 msgid "" "The `crate_type` attribute can be used to tell the compiler whether a crate " "is a binary or a library (and even which type of library), and the " "`crate_name` attribute can be used to set the name of the crate." msgstr "" "`crate_type` 속성은 크레이트가 바이너리인지 라이브러리인지(심지어 어떤 종류" "의 라이브러리인지) 컴파일러에게 알려주는 데 사용될 수 있으며, `crate_name` 속" "성은 크레이트의 이름을 설정하는 데 사용될 수 있습니다." #: src/attribute/crate.md:7 msgid "" "However, it is important to note that both the `crate_type` and `crate_name` " "attributes have **no** effect whatsoever when using Cargo, the Rust package " "manager. Since Cargo is used for the majority of Rust projects, this means " "real-world uses of `crate_type` and `crate_name` are relatively limited." msgstr "" "하지만 Rust 패키지 관리자인 Cargo를 사용할 때는 `crate_type`과 `crate_name` " "속성 모두 **아무런** 효과가 없다는 점에 유의해야 합니다. 대다수의 Rust 프로젝" "트가 Cargo를 사용하므로, `crate_type`과 `crate_name`의 실제 사용은 상대적으" "로 제한적입니다." #: src/attribute/crate.md:13 msgid "// This crate is a library\n" msgstr "// 이 크레이트는 라이브러리입니다\n" #: src/attribute/crate.md:14 msgid "\"lib\"" msgstr "\"lib\"" #: src/attribute/crate.md:14 msgid "// The library is named \"rary\"\n" msgstr "// 라이브러리 이름은 \"rary\"입니다\n" #: src/attribute/crate.md:16 msgid "\"rary\"" msgstr "\"rary\"" #: src/attribute/crate.md:33 msgid "" "When the `crate_type` attribute is used, we no longer need to pass the `--" "crate-type` flag to `rustc`." msgstr "" "`crate_type` 속성이 사용되면, 더 이상 `rustc`에 `--crate-type` 플래그를 전달" "할 필요가 없습니다." #: src/attribute/cfg.md:3 msgid "" "Configuration conditional checks are possible through two different " "operators:" msgstr "설정 조건 검사는 두 가지 다른 연산자를 통해 가능합니다:" #: src/attribute/cfg.md:5 msgid "the `cfg` attribute: `#[cfg(...)]` in attribute position" msgstr "`cfg` 속성: 속성 위치에서의 `#[cfg(...)]`" #: src/attribute/cfg.md:6 msgid "the `cfg!` macro: `cfg!(...)` in boolean expressions" msgstr "`cfg!` 매크로: 불리언 표현식에서의 `cfg!(...)`" #: src/attribute/cfg.md:8 msgid "" "While the former enables conditional compilation, the latter conditionally " "evaluates to `true` or `false` literals allowing for checks at run-time. " "Both utilize identical argument syntax." msgstr "" "전자는 조건부 컴파일을 가능하게 하는 반면, 후자는 조건부로 `true` 또는 " "`false` 리터럴로 평가되어 런타임에 검사를 가능하게 합니다. 둘 다 동일한 인자 " "문법을 사용합니다." #: src/attribute/cfg.md:12 msgid "" "`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true " "or false. For example, all blocks in an if/else expression need to be valid " "when `cfg!` is used for the condition, regardless of what `cfg!` is " "evaluating." msgstr "" "`cfg!`는 `#[cfg]`와 달리 코드를 제거하지 않으며 오직 참 또는 거짓으로만 평가" "됩니다. 예를 들어 `cfg!`가 조건으로 사용될 때, `cfg!`가 무엇으로 평가되든 상" "관없이 if/else 표현식의 모든 블록은 유효해야 합니다." #: src/attribute/cfg.md:15 msgid "// This function only gets compiled if the target OS is linux\n" msgstr "// 이 함수는 대상 OS가 리눅스인 경우에만 컴파일됩니다\n" #: src/attribute/cfg.md:16 src/attribute/cfg.md:22 src/attribute/cfg.md:31 msgid "\"linux\"" msgstr "\"linux\"" #: src/attribute/cfg.md:18 msgid "\"You are running linux!\"" msgstr "\"당신은 리눅스를 사용하고 있습니다!\"" #: src/attribute/cfg.md:20 msgid "" "// And this function only gets compiled if the target OS is *not* linux\n" msgstr "// 그리고 이 함수는 타겟 OS가 리눅스가 *아닌* 경우에만 컴파일됩니다.\n" #: src/attribute/cfg.md:24 msgid "\"You are *not* running linux!\"" msgstr "\"당신은 리눅스를 사용하고 있지 *않습니다*!\"" #: src/attribute/cfg.md:30 msgid "\"Are you sure?\"" msgstr "\"확실한가요?\"" #: src/attribute/cfg.md:32 msgid "\"Yes. It's definitely linux!\"" msgstr "\"네. 확실히 리눅스입니다!\"" #: src/attribute/cfg.md:34 msgid "\"Yes. It's definitely *not* linux!\"" msgstr "\"네. 확실히 리눅스가 *아닙니다*!\"" #: src/attribute/cfg.md:41 msgid "" "[the reference](https://doc.rust-lang.org/reference/" "attributes.html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/" "std/macro.cfg!.html), and [macros](../macros.md)." msgstr "" "[참조](https://doc.rust-lang.org/reference/" "attributes.html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/" "std/macro.cfg!.html), 그리고 [매크로](../macros.md)." #: src/attribute/cfg/custom.md:3 msgid "" "Some conditionals like `target_os` are implicitly provided by `rustc`, but " "custom conditionals must be passed to `rustc` using the `--cfg` flag." msgstr "" "`target_os`와 같은 일부 조건은 `rustc`에 의해 암시적으로 제공되지만, 사용자 " "정의 조건은 `--cfg` 플래그를 사용하여 `rustc`에 전달되어야 합니다." #: src/attribute/cfg/custom.md:9 msgid "\"condition met!\"" msgstr "\"조건 충족!\"" #: src/attribute/cfg/custom.md:17 msgid "Try to run this to see what happens without the custom `cfg` flag." msgstr "사용자 정의 `cfg` 플래그 없이 실행하면 어떻게 되는지 확인해 보세요." #: src/attribute/cfg/custom.md:19 msgid "With the custom `cfg` flag:" msgstr "사용자 정의 `cfg` 플래그 사용 시:" #: src/generics.md:3 msgid "" "_Generics_ is the topic of generalizing types and functionalities to broader " "cases. This is extremely useful for reducing code duplication in many ways, " "but can call for rather involved syntax. Namely, being generic requires " "taking great care to specify over which types a generic type is actually " "considered valid. The simplest and most common use of generics is for type " "parameters." msgstr "" "_제네릭(Generics)_은 타입과 기능을 더 넓은 케이스로 일반화하는 주제입니다. 이" "는 여러 면에서 코드 중복을 줄이는 데 매우 유용하지만, 다소 복잡한 문법을 요" "구할 수 있습니다. 즉, 제네릭이 되려면 제네릭 타입이 실제로 유효한 것으로 간주" "되는 타입을 지정하는 데 세심한 주의가 필요합니다. 제네릭의 가장 간단하고 흔" "한 용도는 타입 파라미터입니다." #: src/generics.md:10 msgid "" "A type parameter is specified as generic by the use of angle brackets and " "upper [camel case](https://en.wikipedia.org/wiki/CamelCase): ``. \"Generic type parameters\" are typically represented as ``. " "In Rust, \"generic\" also describes anything that accepts one or more " "generic type parameters ``. Any type specified as a generic type " "parameter is generic, and everything else is concrete (non-generic)." msgstr "" "타입 파라미터는 꺾쇠 괄호와 대문자 [카멜 케이스](https://en.wikipedia.org/" "wiki/CamelCase)를 사용하여 제네릭으로 지정됩니다: ``. \"제네" "릭 타입 파라미터\"는 일반적으로 ``로 표현됩니다. Rust에서 \"제네릭\"은 하" "나 이상의 제네릭 타입 파라미터 ``를 허용하는 모든 것을 설명하기도 합니다. " "제네릭 타입 파라미터로 지정된 모든 타입은 제네릭이며, 그 외의 모든 것은 구체" "적(비-제네릭)입니다." #: src/generics.md:16 msgid "" "For example, defining a _generic function_ named `foo` that takes an " "argument `T` of any type:" msgstr "" "예를 들어, 모든 타입의 인자 `T`를 취하는 `foo`라는 이름의 _제네릭 함수_를 정" "의하면 다음과 같습니다:" #: src/generics.md:23 msgid "" "Because `T` has been specified as a generic type parameter using ``, it " "is considered generic when used here as `(arg: T)`. This is the case even if " "`T` has previously been defined as a `struct`." msgstr "" "`T`가 ``를 사용하여 제네릭 타입 파라미터로 지정되었으므로, 여기서 `(arg: " "T)`와 같이 사용될 때 제네릭으로 간주됩니다. 이는 `T`가 이전에 `struct`로 정의" "되었더라도 마찬가지입니다." #: src/generics.md:27 msgid "This example shows some of the syntax in action:" msgstr "이 예제는 실제 작동하는 문법의 일부를 보여줍니다:" #: src/generics.md:30 msgid "// A concrete type `A`.\n" msgstr "// 구체적인 타입 `A`.\n" #: src/generics.md:32 msgid "" "// In defining the type `Single`, the first use of `A` is not preceded by " "``.\n" "// Therefore, `Single` is a concrete type, and `A` is defined as above.\n" msgstr "" "// `Single` 타입을 정의할 때, `A`의 첫 사용 앞에 ``가 붙지 않습니다.\n" "// 따라서 `Single`은 구체적인 타입이며, `A`는 위에서 정의된 대로입니다.\n" #: src/generics.md:35 msgid "// ^ Here is `Single`s first use of the type `A`.\n" msgstr "// ^ 여기서 `Single`이 처음으로 `A` 타입을 사용합니다.\n" #: src/generics.md:37 msgid "" "// Here, `` precedes the first use of `T`, so `SingleGen` is a generic " "type.\n" "// Because the type parameter `T` is generic, it could be anything, " "including\n" "// the concrete type `A` defined at the top.\n" msgstr "" "// 여기서 ``가 `T`의 첫 사용 앞에 오므로, `SingleGen`은 제네릭 타입입니" "다.\n" "// 타입 파라미터 `T`는 제네릭이므로, 상단에서 정의된 구체적인 타입 `A`를 포함" "하여\n" "// 무엇이든 될 수 있습니다.\n" #: src/generics.md:44 msgid "// `Single` is concrete and explicitly takes `A`.\n" msgstr "// `Single`은 구체적이며 명시적으로 `A`를 취합니다.\n" #: src/generics.md:47 msgid "" "// Create a variable `_char` of type `SingleGen`\n" " // and give it the value `SingleGen('a')`.\n" " // Here, `SingleGen` has a type parameter explicitly specified.\n" msgstr "" "// `SingleGen` 타입의 변수 `_char`를 생성하고\n" " // `SingleGen('a')` 값을 줍니다.\n" " // 여기서 `SingleGen`은 타입 파라미터가 명시적으로 지정되었습니다.\n" #: src/generics.md:52 msgid "// `SingleGen` can also have a type parameter implicitly specified:\n" msgstr "// `SingleGen`은 타입 파라미터를 암시적으로 지정할 수도 있습니다:\n" #: src/generics.md:53 msgid "// Uses `A` defined at the top.\n" msgstr "// 상단에서 정의된 `A`를 사용합니다.\n" #: src/generics.md:54 msgid "// Uses `i32`.\n" msgstr "// `i32`를 사용합니다.\n" #: src/generics.md:55 msgid "// Uses `char`.\n" msgstr "// `char`를 사용합니다.\n" #: src/generics.md:61 msgid "[`structs`](custom_types/structs.md)" msgstr "[`구조체`](custom_types/structs.md)" #: src/generics/gen_fn.md:3 msgid "" "The same set of rules can be applied to functions: a type `T` becomes " "generic when preceded by ``." msgstr "" "함수에도 동일한 규칙이 적용될 수 있습니다: 타입 `T` 앞에 ``가 붙으면 제네" "릭이 됩니다." #: src/generics/gen_fn.md:6 msgid "" "Using generic functions sometimes requires explicitly specifying type " "parameters. This may be the case if the function is called where the return " "type is generic, or if the compiler doesn't have enough information to infer " "the necessary type parameters." msgstr "" "제네릭 함수를 사용할 때 때로는 타입 파라미터를 명시적으로 지정해야 할 필요가 " "있습니다. 반환 타입이 제네릭인 곳에서 함수가 호출되거나, 컴파일러가 필요한 타" "입 파라미터를 추론하기에 충분한 정보를 가지고 있지 않은 경우가 이에 해당할 " "수 있습니다." #: src/generics/gen_fn.md:11 msgid "" "A function call with explicitly specified type parameters looks like: `fun::" "()`." msgstr "" "명시적으로 지정된 타입 파라미터를 사용한 함수 호출은 다음과 같습니다: `fun::" "()`." #: src/generics/gen_fn.md:15 msgid "// Concrete type `A`.\n" msgstr "// 구체적인 타입 `A`.\n" #: src/generics/gen_fn.md:16 msgid "// Concrete type `S`.\n" msgstr "// 구체적인 타입 `S`.\n" #: src/generics/gen_fn.md:17 msgid "// Generic type `SGen`.\n" msgstr "// 제네릭 타입 `SGen`.\n" #: src/generics/gen_fn.md:18 msgid "" "// The following functions all take ownership of the variable passed into\n" "// them and immediately go out of scope, freeing the variable.\n" msgstr "" "// 다음 함수들은 모두 전달된 변수의 소유권을 가져가며,\n" "// 즉시 스코프를 벗어나 변수를 해제합니다.\n" #: src/generics/gen_fn.md:21 msgid "" "// Define a function `reg_fn` that takes an argument `_s` of type `S`.\n" "// This has no `` so this is not a generic function.\n" msgstr "" "// `S` 타입의 인자 `_s`를 받는 `reg_fn` 함수를 정의합니다.\n" "// ``가 없으므로 이것은 제네릭 함수가 아닙니다.\n" #: src/generics/gen_fn.md:25 msgid "" "// Define a function `gen_spec_t` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `A`, but because `A` has " "not\n" "// been specified as a generic type parameter for `gen_spec_t`, it is not " "generic.\n" msgstr "" "// `SGen` 타입의 인자 `_s`를 받는 `gen_spec_t` 함수를 정의합니다.\n" "// 타입 파라미터 `A`가 명시적으로 주어졌지만, `A`가 `gen_spec_t`의\n" "// 제네릭 타입 파라미터로 지정되지 않았으므로, 이것은 제네릭이 아닙니다.\n" #: src/generics/gen_fn.md:30 msgid "" "// Define a function `gen_spec_i32` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `i32`, which is a " "specific type.\n" "// Because `i32` is not a generic type, this function is also not generic.\n" msgstr "" "// `SGen` 타입의 인자 `_s`를 받는 `gen_spec_i32` 함수를 정의합니다.\n" "// 구체적인 타입인 `i32`가 타입 파라미터로 명시적으로 주어졌습니다.\n" "// `i32`는 제네릭 타입이 아니므로, 이 함수 또한 제네릭이 아닙니다.\n" #: src/generics/gen_fn.md:35 msgid "" "// Define a function `generic` that takes an argument `_s` of type " "`SGen`.\n" "// Because `SGen` is preceded by ``, this function is generic over " "`T`.\n" msgstr "" "// `SGen` 타입의 인자 `_s`를 받는 `generic` 함수를 정의합니다.\n" "// `SGen` 앞에 ``가 오기 때문에, 이 함수는 `T`에 대해 제네릭입니다.\n" #: src/generics/gen_fn.md:41 msgid "// Using the non-generic functions\n" msgstr "// 제네릭이 아닌 함수들 사용\n" #: src/generics/gen_fn.md:42 msgid "// Concrete type.\n" msgstr "// 구체적인 타입.\n" #: src/generics/gen_fn.md:43 msgid "// Implicitly specified type parameter `A`.\n" msgstr "// 암시적으로 지정된 타입 파라미터 `A`.\n" #: src/generics/gen_fn.md:44 msgid "// Implicitly specified type parameter `i32`.\n" msgstr "// 암시적으로 지정된 타입 파라미터 `i32`.\n" #: src/generics/gen_fn.md:46 msgid "// Explicitly specified type parameter `char` to `generic()`.\n" msgstr "// `generic()`에 명시적으로 지정된 타입 파라미터 `char`.\n" #: src/generics/gen_fn.md:49 msgid "// Implicitly specified type parameter `char` to `generic()`.\n" msgstr "// `generic()`에 암시적으로 지정된 타입 파라미터 `char`.\n" #: src/generics/gen_fn.md:50 msgid "'c'" msgstr "'c'" #: src/generics/gen_fn.md:56 msgid "[functions](../fn.md) and [`struct`s](../custom_types/structs.md)" msgstr "[함수](../fn.md)와 [`struct`](../custom_types/structs.md)" #: src/generics/impl.md:3 msgid "Similar to functions, implementations require care to remain generic." msgstr "" "함수와 마찬가지로, 구현(implementation)도 제네릭을 유지하기 위해 주의가 필요" "합니다." #: src/generics/impl.md:6 msgid "// Concrete type `S`\n" msgstr "// 구체적인 타입 `S`\n" #: src/generics/impl.md:7 msgid "// Generic type `GenericVal`\n" msgstr "// 제네릭 타입 `GenericVal`\n" #: src/generics/impl.md:8 msgid "// impl of GenericVal where we explicitly specify type parameters:\n" msgstr "// 타입 파라미터를 명시적으로 지정한 GenericVal의 구현:\n" #: src/generics/impl.md:10 msgid "// Specify `f32`\n" msgstr "// `f32` 지정\n" #: src/generics/impl.md:11 msgid "// Specify `S` as defined above\n" msgstr "// 위에서 정의한 `S` 지정\n" #: src/generics/impl.md:12 msgid "// `` Must precede the type to remain generic\n" msgstr "// 제네릭을 유지하려면 ``가 타입 앞에 와야 합니다\n" #: src/generics/impl.md:25 msgid "// impl of Val\n" msgstr "// Val 구현\n" #: src/generics/impl.md:32 msgid "// impl of GenVal for a generic type `T`\n" msgstr "// 제네릭 타입 `T`에 대한 GenVal 구현\n" #: src/generics/impl.md:50 msgid "" "[functions returning references](../scope/lifetime/fn.md), [`impl`](../fn/" "methods.md), and [`struct`](../custom_types/structs.md)" msgstr "" "[참조를 반환하는 함수](../scope/lifetime/fn.md), [`impl`](../fn/methods.md), " "그리고 [`struct`](../custom_types/structs.md)" #: src/generics/gen_trait.md:3 msgid "" "Of course `trait`s can also be generic. Here we define one which " "reimplements the `Drop` `trait` as a generic method to `drop` itself and an " "input." msgstr "" "물론 `trait`도 제네릭일 수 있습니다. 여기서는 `Drop` `트레이트`를 자신과 입력" "을 `drop`하는 제네릭 메서드로 재구현한 것을 정의합니다." #: src/generics/gen_trait.md:7 msgid "// Non-copyable types.\n" msgstr "// 복사 불가능한 타입.\n" #: src/generics/gen_trait.md:10 msgid "// A trait generic over `T`.\n" msgstr "// `T`에 대해 제네릭인 트레이트.\n" #: src/generics/gen_trait.md:13 msgid "" "// Define a method on the caller type which takes an\n" " // additional single parameter `T` and does nothing with it.\n" msgstr "" "// 호출자 타입에 대해 추가적인 단일 파라미터 `T`를 취하고\n" "// 아무것도 하지 않는 메서드를 정의합니다.\n" #: src/generics/gen_trait.md:17 msgid "" "// Implement `DoubleDrop` for any generic parameter `T` and\n" "// caller `U`.\n" msgstr "" "// 임의의 제네릭 파라미터 `T`와 호출자 `U`에 대해\n" "// `DoubleDrop`를 구현합니다.\n" #: src/generics/gen_trait.md:21 msgid "" "// This method takes ownership of both passed arguments,\n" " // deallocating both.\n" msgstr "" "// 이 메서드는 전달된 두 인자의 소유권을 가져와\n" "// 둘 다 해제합니다.\n" #: src/generics/gen_trait.md:30 msgid "// Deallocate `empty` and `null`.\n" msgstr "// `empty`와 `null`을 해제합니다.\n" #: src/generics/gen_trait.md:33 msgid "" "//empty;\n" " //null;\n" " // ^ TODO: Try uncommenting these lines.\n" msgstr "" "//empty;\n" " //null;\n" " // ^ TODO: 이 줄들의 주석을 해제해 보세요.\n" #: src/generics/gen_trait.md:41 msgid "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`struct`](../" "custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`구조체`](../" "custom_types/structs.md), 그리고 [`트레이트`](../trait.md)" #: src/generics/bounds.md:3 msgid "" "When working with generics, the type parameters often must use traits as " "_bounds_ to stipulate what functionality a type implements. For example, the " "following example uses the trait `Display` to print and so it requires `T` " "to be bound by `Display`; that is, `T` _must_ implement `Display`." msgstr "" "제네릭을 사용할 때, 타입 파라미터는 종종 타입이 구현해야 하는 기능을 규정하" "기 위해 트레이트를 _바운드(bounds)_로 사용해야 합니다. 예를 들어, 다음 예제" "는 `Display` 트레이트를 사용하여 출력하므로 `T`가 `Display`에 바운드되어야 합" "니다. 즉, `T`는 반드시 `Display`를 구현해야 합니다." #: src/generics/bounds.md:9 msgid "" "// Define a function `printer` that takes a generic type `T` which\n" "// must implement trait `Display`.\n" msgstr "" "// 제네릭 타입 `T`를 받는 함수 `printer`를 정의합니다.\n" "// `T`는 반드시 `Display` 트레이트를 구현해야 합니다.\n" #: src/generics/bounds.md:16 msgid "" "Bounding restricts the generic to types that conform to the bounds. That is:" msgstr "바운딩은 제네릭을 해당 바운드를 준수하는 타입들로 제한합니다. 즉:" #: src/generics/bounds.md:20 msgid "" "// Error! `Vec` does not implement `Display`. This\n" "// specialization will fail.\n" msgstr "" "// 에러! `Vec`는 `Display`를 구현하지 않습니다.\n" "// 이 특수화는 실패할 것입니다.\n" #: src/generics/bounds.md:26 msgid "" "Another effect of bounding is that generic instances are allowed to access " "the [methods](../fn/methods.md) of traits specified in the bounds. For " "example:" msgstr "" "바운딩의 또 다른 효과는 제네릭 인스턴스가 바운드에 지정된 트레이트의 [메서드]" "(../fn/methods.md)에 접근할 수 있게 된다는 것입니다. 예를 들어:" #: src/generics/bounds.md:30 msgid "// A trait which implements the print marker: `{:?}`.\n" msgstr "// 출력 마커 `{:?}`를 구현하는 트레이트입니다.\n" #: src/generics/bounds.md:45 msgid "" "// The generic `T` must implement `Debug`. Regardless\n" "// of the type, this will work properly.\n" msgstr "" "// 제네릭 `T`는 반드시 `Debug`를 구현해야 합니다.\n" "// 타입에 상관없이 이는 제대로 작동할 것입니다.\n" #: src/generics/bounds.md:51 msgid "" "// `T` must implement `HasArea`. Any type which meets\n" "// the bound can access `HasArea`'s function `area`.\n" msgstr "" "// `T`는 반드시 `HasArea`를 구현해야 합니다. 바운드를 충족하는\n" "// 모든 타입은 `HasArea`의 `area` 함수에 접근할 수 있습니다.\n" #: src/generics/bounds.md:61 msgid "\"Area: {}\"" msgstr "\"면적: {}\"" #: src/generics/bounds.md:63 msgid "" "//print_debug(&_triangle);\n" " //println!(\"Area: {}\", area(&_triangle));\n" " // ^ TODO: Try uncommenting these.\n" " // | Error: Does not implement either `Debug` or `HasArea`.\n" msgstr "" "//print_debug(&_triangle);\n" "//println!(\"면적: {}\", area(&_triangle));\n" "// ^ TODO: 이 줄들의 주석을 해제해 보세요.\n" "// | 에러: `Debug`나 `HasArea` 중 어느 것도 구현하지 않았습니다.\n" #: src/generics/bounds.md:70 msgid "" "As an additional note, [`where`](../generics/where.md) clauses can also be " "used to apply bounds in some cases to be more expressive." msgstr "" "추가적으로, 어떤 경우에는 [`where`](../generics/where.md) 절을 사용하여 바운" "드를 더 표현력 있게 적용할 수도 있습니다." #: src/generics/bounds.md:75 msgid "" "[`std::fmt`](../hello/print.md), [`struct`s](../custom_types/structs.md), " "and [`trait`s](../trait.md)" msgstr "" "[`std::fmt`](../hello/print.md), [`struct`](../custom_types/structs.md), 그리" "고 [`trait`](../trait.md)" #: src/generics/bounds/testcase_empty.md:3 msgid "" "A consequence of how bounds work is that even if a `trait` doesn't include " "any functionality, you can still use it as a bound. `Eq` and `Copy` are " "examples of such `trait`s from the `std` library." msgstr "" "바운드가 작동하는 방식의 결과로, `trait`가 아무런 기능을 포함하지 않더라도 여" "전히 바운드로 사용할 수 있습니다. `std` 라이브러리의 `Eq`와 `Copy`가 그러한 " "`trait`의 예입니다." #: src/generics/bounds/testcase_empty.md:17 msgid "" "// These functions are only valid for types which implement these\n" "// traits. The fact that the traits are empty is irrelevant.\n" msgstr "" "// 이 함수들은 이 트레이트들을 구현하는 타입에 대해서만 유효합니다.\n" "// 트레이트가 비어 있다는 사실은 무관합니다.\n" #: src/generics/bounds/testcase_empty.md:20 msgid "\"red\"" msgstr "\"빨강\"" #: src/generics/bounds/testcase_empty.md:21 msgid "\"blue\"" msgstr "\"파랑\"" #: src/generics/bounds/testcase_empty.md:28 msgid "" "// `red()` won't work on a blue jay nor vice versa\n" " // because of the bounds.\n" msgstr "" "// 바운드 때문에 `red()`는 blue jay(파랑 어치)에 대해 작동하지 않으며\n" "// 그 반대도 마찬가지입니다.\n" #: src/generics/bounds/testcase_empty.md:30 msgid "\"A cardinal is {}\"" msgstr "\"홍관조(cardinal)는 {}입니다\"" #: src/generics/bounds/testcase_empty.md:31 msgid "\"A blue jay is {}\"" msgstr "\"파랑 어치(blue jay)는 {}입니다\"" #: src/generics/bounds/testcase_empty.md:32 msgid "" "//println!(\"A turkey is {}\", red(&_turkey));\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" "//println!(\"칠면조는 {}\", red(&_turkey));\n" "// ^ TODO: 이 줄의 주석을 해제해 보세요.\n" #: src/generics/bounds/testcase_empty.md:39 msgid "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`std::marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), " "and [`trait`s](../../trait.md)" msgstr "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`std::marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), " "그리고 [`trait`](../../trait.md)" #: src/generics/multi_bounds.md:3 msgid "" "Multiple bounds for a single type can be applied with a `+`. Like normal, " "different types are separated with `,`." msgstr "" "단일 타입에 대해 `+`를 사용하여 다중 바운드를 적용할 수 있습니다. 평소와 마찬" "가지로, 서로 다른 타입은 `,`로 구분됩니다." #: src/generics/multi_bounds.md:10 msgid "\"Debug: `{:?}`\"" msgstr "\"디버그: `{:?}`\"" #: src/generics/multi_bounds.md:11 msgid "\"Display: `{}`\"" msgstr "\"디스플레이: `{}`\"" #: src/generics/multi_bounds.md:15 msgid "\"t: `{:?}`\"" msgstr "\"t: `{:?}`\"" #: src/generics/multi_bounds.md:16 msgid "\"u: `{:?}`\"" msgstr "\"u: `{:?}`\"" #: src/generics/multi_bounds.md:20 msgid "\"words\"" msgstr "\"단어들\"" #: src/generics/multi_bounds.md:25 msgid "" "//compare_prints(&array);\n" " // TODO ^ Try uncommenting this.\n" msgstr "" "//compare_prints(&array);\n" "// TODO ^ 주석을 해제해 보세요.\n" #: src/generics/multi_bounds.md:34 msgid "[`std::fmt`](../hello/print.md) and [`trait`s](../trait.md)" msgstr "[`std::fmt`](../hello/print.md)와 [`trait`](../trait.md)" #: src/generics/where.md:3 msgid "" "A bound can also be expressed using a `where` clause immediately before the " "opening `{`, rather than at the type's first mention. Additionally, `where` " "clauses can apply bounds to arbitrary types, rather than just to type " "parameters." msgstr "" "바운드는 타입이 처음 언급되는 곳이 아닌, 여는 중괄호 `{` 직전에 `where` 절을 " "사용하여 표현할 수도 있습니다. 또한, `where` 절은 타입 파라미터뿐만 아니라 임" "의의 타입에도 바운드를 적용할 수 있습니다." #: src/generics/where.md:8 msgid "Some cases that a `where` clause is useful:" msgstr "`where` 절이 유용한 몇 가지 경우:" #: src/generics/where.md:10 msgid "When specifying generic types and bounds separately is clearer:" msgstr "제네릭 타입과 바운드를 따로 명시하는 것이 더 명확할 때:" #: src/generics/where.md:14 msgid "// Expressing bounds with a `where` clause\n" msgstr "// `where` 절로 바운드 표현하기\n" #: src/generics/where.md:21 msgid "" "When using a `where` clause is more expressive than using normal syntax. The " "`impl` in this example cannot be directly expressed without a `where` clause:" msgstr "" "`where` 절을 사용하는 것이 일반 구문을 사용하는 것보다 더 표현력이 좋을 때. " "이 예제의 `impl`은 `where` 절 없이는 직접 표현할 수 없습니다:" #: src/generics/where.md:30 msgid "" "// Because we would otherwise have to express this as `T: Debug` or\n" "// use another method of indirect approach, this requires a `where` clause:\n" msgstr "" "// 그렇지 않으면 `T: Debug`로 표현하거나\n" "// 다른 간접적인 방법을 사용해야 하므로, 여기에는 `where` 절이 필요합니다:\n" #: src/generics/where.md:35 msgid "" "// We want `Option: Debug` as our bound because that is what's\n" " // being printed. Doing otherwise would be using the wrong bound.\n" msgstr "" "// 출력되는 것이 `Option`이므로, 바운드로 `Option: Debug`를 원합니다.\n" " // 다르게 하면 잘못된 바운드를 사용하는 셈이 됩니다.\n" #: src/generics/where.md:51 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), " "[`struct`](../custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), " "[`struct`](../custom_types/structs.md), 그리고 [`trait`](../trait.md)" #: src/generics/new_types.md:3 msgid "" "The `newtype` idiom gives compile time guarantees that the right type of " "value is supplied to a program." msgstr "" "`newtype` 관용구는 프로그램에 올바른 타입의 값이 제공됨을 컴파일 타임에 보장" "해 줍니다." #: src/generics/new_types.md:6 msgid "" "For example, an age verification function that checks age in years, _must_ " "be given a value of type `Years`." msgstr "" "예를 들어, 나이를 연 단위로 확인하는 나이 검증 함수는 반드시 `Years` 타입의 " "값을 받아야 합니다." #: src/generics/new_types.md:21 msgid "/// truncates partial years\n" msgstr "/// 부분적인 연도는 버립니다\n" #: src/generics/new_types.md:34 src/generics/new_types.md:35 msgid "\"Is an adult? {}\"" msgstr "\"성인입니까? {}\"" #: src/generics/new_types.md:36 msgid "// println!(\"Is an adult? {}\", is_adult(&age_days));\n" msgstr "// println!(\"성인입니까? {}\", is_adult(&age_days));\n" #: src/generics/new_types.md:40 msgid "" "Uncomment the last print statement to observe that the type supplied must be " "`Years`." msgstr "" "마지막 출력문의 주석을 해제하여 제공되는 타입이 반드시 `Years`여야 함을 관찰" "해 보세요." #: src/generics/new_types.md:42 msgid "" "To obtain the `newtype`'s value as the base type, you may use the tuple or " "destructuring syntax like so:" msgstr "" "`newtype`의 값을 기본 타입으로 얻으려면, 다음과 같이 튜플 또는 구조 분해 문법" "을 사용할 수 있습니다:" #: src/generics/new_types.md:49 msgid "// Tuple\n" msgstr "// 튜플\n" #: src/generics/new_types.md:50 msgid "// Destructuring\n" msgstr "// 구조 분해\n" #: src/generics/new_types.md:56 msgid "[`structs`](../custom_types/structs.md)" msgstr "[`structs`](../custom_types/structs.md)" #: src/generics/assoc_items.md:3 msgid "" "\"Associated Items\" refers to a set of rules pertaining to [`item`](https://" "doc.rust-lang.org/reference/items.html)s of various types. It is an " "extension to `trait` generics, and allows `trait`s to internally define new " "items." msgstr "" "\"연관 아이템(Associated Items)\"은 다양한 타입의 [`아이템`](https://" "doc.rust-lang.org/reference/items.html)에 관련된 규칙 집합을 말합니다. 이는 " "`trait` 제네릭의 확장이며, `trait`가 내부적으로 새로운 아이템을 정의할 수 있" "게 해줍니다." #: src/generics/assoc_items.md:7 msgid "" "One such item is called an _associated type_, providing simpler usage " "patterns when the `trait` is generic over its container type." msgstr "" "그러한 아이템 중 하나가 _연관 타입(associated type)_이며, `trait`가 컨테이너 " "타입에 대해 제네릭일 때 더 간단한 사용 패턴을 제공합니다." #: src/generics/assoc_items.md:12 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" msgstr "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" #: src/generics/assoc_items/the_problem.md:3 msgid "" "A `trait` that is generic over its container type has type specification " "requirements - users of the `trait` _must_ specify all of its generic types." msgstr "" "컨테이너 타입에 대해 제네릭인 `trait`는 타입 명시 요구사항을 가집니다 - " "`trait` 사용자는 모든 제네릭 타입을 _반드시_ 명시해야 합니다." #: src/generics/assoc_items/the_problem.md:6 msgid "" "In the example below, the `Contains` `trait` allows the use of the generic " "types `A` and `B`. The trait is then implemented for the `Container` type, " "specifying `i32` for `A` and `B` so that it can be used with `fn " "difference()`." msgstr "" "아래 예제에서 `Contains` `trait`는 제네릭 타입 `A`와 `B`의 사용을 허용합니" "다. 그 후 이 트레이트는 `Container` 타입에 대해 구현되는데, `fn difference()`" "와 함께 사용될 수 있도록 `A`와 `B`에 대해 `i32`를 지정합니다." #: src/generics/assoc_items/the_problem.md:10 msgid "" "Because `Contains` is generic, we are forced to explicitly state _all_ of " "the generic types for `fn difference()`. In practice, we want a way to " "express that `A` and `B` are determined by the _input_ `C`. As you will see " "in the next section, associated types provide exactly that capability." msgstr "" "`Contains`가 제네릭이기 때문에, 우리는 `fn difference()`에 대해 _모든_ 제네" "릭 타입을 명시적으로 나열해야만 합니다. 실제로는 `A`와 `B`가 _입력_ `C`에 의" "해 결정된다는 것을 표현하고 싶습니다. 다음 섹션에서 보게 되겠지만, 연관 타입" "은 정확히 그런 기능을 제공합니다." #: src/generics/assoc_items/the_problem.md:17 #: src/generics/assoc_items/types.md:36 msgid "" "// A trait which checks if 2 items are stored inside of container.\n" "// Also retrieves first or last value.\n" msgstr "" "// 컨테이너 안에 2개의 아이템이 저장되어 있는지 확인하는 트레이트입니다.\n" "// 또한 첫 번째 또는 마지막 값을 가져옵니다.\n" #: src/generics/assoc_items/the_problem.md:21 msgid "// Explicitly requires `A` and `B`.\n" msgstr "// 명시적으로 `A`와 `B`를 요구합니다.\n" #: src/generics/assoc_items/the_problem.md:22 #: src/generics/assoc_items/the_problem.md:23 msgid "// Doesn't explicitly require `A` or `B`.\n" msgstr "// 명시적으로 `A`나 `B`를 요구하지 않습니다.\n" #: src/generics/assoc_items/the_problem.md:27 msgid "// True if the numbers stored are equal.\n" msgstr "// 저장된 숫자들이 같으면 참입니다.\n" #: src/generics/assoc_items/the_problem.md:32 #: src/generics/assoc_items/types.md:60 msgid "// Grab the first number.\n" msgstr "// 첫 번째 숫자를 가져옵니다.\n" #: src/generics/assoc_items/the_problem.md:35 #: src/generics/assoc_items/types.md:63 msgid "// Grab the last number.\n" msgstr "// 마지막 숫자를 가져옵니다.\n" #: src/generics/assoc_items/the_problem.md:38 msgid "" "// `C` contains `A` and `B`. In light of that, having to express `A` and\n" "// `B` again is a nuisance.\n" msgstr "" "// `C`는 `A`와 `B`를 포함합니다. 이를 고려할 때, `A`와 `B`를\n" "// 다시 표현해야 하는 것은 성가신 일입니다.\n" #: src/generics/assoc_items/the_problem.md:52 #: src/generics/assoc_items/types.md:77 msgid "\"Does container contain {} and {}: {}\"" msgstr "\"컨테이너가 {}와 {}를 포함합니까: {}\"" #: src/generics/assoc_items/the_problem.md:55 #: src/generics/assoc_items/types.md:80 msgid "\"First number: {}\"" msgstr "\"첫 번째 숫자: {}\"" #: src/generics/assoc_items/the_problem.md:56 #: src/generics/assoc_items/types.md:81 msgid "\"Last number: {}\"" msgstr "\"마지막 숫자: {}\"" #: src/generics/assoc_items/the_problem.md:58 #: src/generics/assoc_items/types.md:83 msgid "\"The difference is: {}\"" msgstr "\"차이는: {}\"" #: src/generics/assoc_items/the_problem.md:64 msgid "" "[`struct`s](../../custom_types/structs.md), and [`trait`s](../../trait.md)" msgstr "" "[`struct`](../../custom_types/structs.md), 그리고 [`trait`](../../trait.md)" #: src/generics/assoc_items/types.md:3 msgid "" "The use of \"Associated types\" improves the overall readability of code by " "moving inner types locally into a trait as _output_ types. Syntax for the " "`trait` definition is as follows:" msgstr "" "\"연관 타입\"을 사용하면 내부 타입을 트레이트 내의 _출력_ 타입으로 지역적으" "로 이동시켜 코드의 전반적인 가독성을 향상시킬 수 있습니다. `trait` 정의를 위" "한 구문은 다음과 같습니다:" #: src/generics/assoc_items/types.md:8 msgid "" "// `A` and `B` are defined in the trait via the `type` keyword.\n" "// (Note: `type` in this context is different from `type` when used for\n" "// aliases).\n" msgstr "" "// `A`와 `B`는 `type` 키워드를 통해 트레이트 내에 정의됩니다.\n" "// (참고: 이 문맥에서의 `type`은 별칭(aliases)에 사용되는 `type`과는 다릅니" "다).\n" #: src/generics/assoc_items/types.md:15 msgid "// Updated syntax to refer to these new types generically.\n" msgstr "" "// 이 새로운 타입들을 제네릭하게 참조하기 위해 업데이트된 구문입니다.\n" #: src/generics/assoc_items/types.md:20 msgid "" "Note that functions that use the `trait` `Contains` are no longer required " "to express `A` or `B` at all:" msgstr "" "`Contains` `trait`를 사용하는 함수들은 더 이상 `A`나 `B`를 표현할 필요가 없다" "는 점에 유의하세요:" #: src/generics/assoc_items/types.md:24 msgid "// Without using associated types\n" msgstr "// 연관 타입을 사용하지 않는 경우\n" #: src/generics/assoc_items/types.md:27 msgid "// Using associated types\n" msgstr "// 연관 타입 사용\n" #: src/generics/assoc_items/types.md:32 msgid "" "Let's rewrite the example from the previous section using associated types:" msgstr "이전 섹션의 예제를 연관 타입을 사용하여 다시 작성해 봅시다:" #: src/generics/assoc_items/types.md:40 msgid "// Define generic types here which methods will be able to utilize.\n" msgstr "// 여기서 제네릭 타입을 정의하여 메서드들이 활용할 수 있게 합니다.\n" #: src/generics/assoc_items/types.md:50 msgid "" "// Specify what types `A` and `B` are. If the `input` type\n" " // is `Container(i32, i32)`, the `output` types are determined\n" " // as `i32` and `i32`.\n" msgstr "" "// `A`와 `B`가 어떤 타입인지 명시합니다. 만약 `input` 타입이\n" " // `Container(i32, i32)`라면, `output` 타입은 `i32`와 `i32`로\n" " // 결정됩니다.\n" #: src/generics/assoc_items/types.md:56 msgid "// `&Self::A` and `&Self::B` are also valid here.\n" msgstr "// `&Self::A`와 `&Self::B` 또한 여기서 유효합니다.\n" #: src/generics/phantom.md:3 msgid "" "A phantom type parameter is one that doesn't show up at runtime, but is " "checked statically (and only) at compile time." msgstr "" "팬텀 타입 파라미터(phantom type parameter)는 런타임에는 나타나지 않지만, 컴파" "일 타임에만 정적으로 검사되는 파라미터입니다." #: src/generics/phantom.md:6 msgid "" "Data types can use extra generic type parameters to act as markers or to " "perform type checking at compile time. These extra parameters hold no " "storage values, and have no runtime behavior." msgstr "" "데이터 타입은 추가적인 제네릭 타입 파라미터를 사용하여 마커 역할을 하거나 컴" "파일 타임에 타입 검사를 수행할 수 있습니다. 이러한 추가 파라미터는 저장 값을 " "가지지 않으며, 런타임 동작도 없습니다." #: src/generics/phantom.md:10 msgid "" "In the following example, we combine [std::marker::PhantomData](https://" "doc.rust-lang.org/std/marker/struct.PhantomData.html) with the phantom type " "parameter concept to create tuples containing different data types." msgstr "" "다음 예제에서는 [std::marker::PhantomData](https://doc.rust-lang.org/std/" "marker/struct.PhantomData.html)와 팬텀 타입 파라미터 개념을 결합하여 서로 다" "른 데이터 타입을 포함하는 튜플을 생성합니다." #: src/generics/phantom.md:16 msgid "" "// A phantom tuple struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "" "// 숨겨진 파라미터 `B`를 가지며 `A`에 대해 제네릭인 팬텀 튜플 구조체.\n" #: src/generics/phantom.md:18 src/generics/phantom.md:22 msgid "// Allow equality test for this type.\n" msgstr "// 이 타입에 대한 동등성 테스트를 허용합니다.\n" #: src/generics/phantom.md:20 msgid "" "// A phantom type struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "" "// 숨겨진 파라미터 `B`를 가지며 `A`에 대해 제네릭인 팬텀 타입 구조체.\n" #: src/generics/phantom.md:24 msgid "" "// Note: Storage is allocated for generic type `A`, but not for `B`.\n" "// Therefore, `B` cannot be used in computations.\n" msgstr "" "// 주의: 제네릭 타입 `A`에는 저장 공간이 할당되지만, `B`에는 할당되지 않습니" "다.\n" "// 따라서 `B`는 연산에 사용될 수 없습니다.\n" #: src/generics/phantom.md:29 msgid "" "// Here, `f32` and `f64` are the hidden parameters.\n" " // PhantomTuple type specified as ``.\n" msgstr "" "// 여기서 `f32`와 `f64`는 숨겨진 파라미터입니다.\n" " // PhantomTuple 타입이 ``로 지정되었습니다.\n" #: src/generics/phantom.md:31 src/generics/phantom.md:33 #: src/generics/phantom.md:37 src/generics/phantom.md:42 #: src/scope/borrow/ref.md:12 msgid "'Q'" msgstr "'Q'" #: src/generics/phantom.md:32 msgid "// PhantomTuple type specified as ``.\n" msgstr "// PhantomTuple 타입이 ``로 지정되었습니다.\n" #: src/generics/phantom.md:35 msgid "// Type specified as ``.\n" msgstr "// 타입이 ``로 지정되었습니다.\n" #: src/generics/phantom.md:40 msgid "// Type specified as ``.\n" msgstr "// 타입이 ``로 지정되었습니다.\n" #: src/generics/phantom.md:46 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_tuple1 == _tuple2 yields: {}\",\n" " // _tuple1 == _tuple2);\n" msgstr "" "// 컴파일 타임 에러! 타입 불일치로 인해 비교할 수 없습니다:\n" " // println!(\"_tuple1 == _tuple2 yields: {}\",\n" " // _tuple1 == _tuple2);\n" #: src/generics/phantom.md:50 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_struct1 == _struct2 yields: {}\",\n" " // _struct1 == _struct2);\n" msgstr "" "// 컴파일 타임 에러! 타입 불일치로 인해 비교할 수 없습니다:\n" "// println!(\"_struct1 == _struct2 yields: {}\",\n" "// _struct1 == _struct2);\n" #: src/generics/phantom.md:58 msgid "" "[Derive](../trait/derive.md), [struct](../custom_types/structs.md), and " "[tuple](../primitives/tuples.html)." msgstr "" "[Derive](../trait/derive.md), [구조체](../custom_types/structs.md), 그리고 " "[튜플](../primitives/tuples.html)." #: src/generics/phantom/testcase_units.md:3 msgid "" "A useful method of unit conversions can be examined by implementing `Add` " "with a phantom type parameter. The `Add` `trait` is examined below:" msgstr "" "팬텀 타입 파라미터로 `Add`를 구현하여 유용한 단위 변환 방법을 살펴볼 수 있습" "니다. `Add` `트레이트`는 아래에서 살펴봅니다:" #: src/generics/phantom/testcase_units.md:7 msgid "" "// This construction would impose: `Self + RHS = Output`\n" "// where RHS defaults to Self if not specified in the implementation.\n" msgstr "" "// 이 구조는 다음을 부과합니다: `Self + RHS = Output`\n" "// 구현에서 지정되지 않은 경우 RHS는 기본적으로 Self입니다.\n" #: src/generics/phantom/testcase_units.md:14 msgid "// `Output` must be `T` so that `T + T = T`.\n" msgstr "" "// `Output`은 `T + T = T`가 되도록 반드시 `T`여야 합니다.\n" #: src/generics/phantom/testcase_units.md:22 msgid "The whole implementation:" msgstr "전체 구현:" #: src/generics/phantom/testcase_units.md:27 msgid "/// Create void enumerations to define unit types.\n" msgstr "/// 단위 타입을 정의하기 위해 빈 열거형을 생성합니다.\n" #: src/generics/phantom/testcase_units.md:33 msgid "" "/// `Length` is a type with phantom type parameter `Unit`,\n" "/// and is not generic over the length type (that is `f64`).\n" "///\n" "/// `f64` already implements the `Clone` and `Copy` traits.\n" msgstr "" "/// `Length`는 팬텀 타입 파라미터 `Unit`을 가지는 타입이며,\n" "/// 길이 타입(`f64`)에 대해서는 제네릭이 아닙니다.\n" "///\n" "/// `f64`는 이미 `Clone`과 `Copy` 트레이트를 구현하고 있습니다.\n" #: src/generics/phantom/testcase_units.md:40 msgid "/// The `Add` trait defines the behavior of the `+` operator.\n" msgstr "/// `Add` 트레이트는 `+` 연산자의 동작을 정의합니다.\n" #: src/generics/phantom/testcase_units.md:45 msgid "// add() returns a new `Length` struct containing the sum.\n" msgstr "// add()는 합계를 포함하는 새로운 `Length` 구조체를 반환합니다.\n" #: src/generics/phantom/testcase_units.md:47 msgid "// `+` calls the `Add` implementation for `f64`.\n" msgstr "// `+`는 `f64`에 대한 `Add` 구현을 호출합니다.\n" #: src/generics/phantom/testcase_units.md:53 msgid "// Specifies `one_foot` to have phantom type parameter `Inch`.\n" msgstr "// `one_foot`가 팬텀 타입 파라미터 `Inch`를 가지도록 지정합니다.\n" #: src/generics/phantom/testcase_units.md:55 msgid "// `one_meter` has phantom type parameter `Mm`.\n" msgstr "// `one_meter`는 팬텀 타입 파라미터 `Mm`을 가집니다.\n" #: src/generics/phantom/testcase_units.md:58 msgid "" "// `+` calls the `add()` method we implemented for `Length`.\n" " //\n" " // Since `Length` implements `Copy`, `add()` does not consume\n" " // `one_foot` and `one_meter` but copies them into `self` and `rhs`.\n" msgstr "" "// `+`는 우리가 `Length`에 대해 구현한 `add()` 메서드를 호출합니다.\n" "//\n" "// `Length`가 `Copy`를 구현하므로, `add()`는 `one_foot`과 `one_meter`를\n" "// 소비(consume)하지 않고 `self`와 `rhs`로 복사합니다.\n" #: src/generics/phantom/testcase_units.md:65 msgid "// Addition works.\n" msgstr "// 덧셈이 작동합니다.\n" #: src/generics/phantom/testcase_units.md:66 msgid "\"one foot + one_foot = {:?} in\"" msgstr "\"1피트 + 1피트 = {:?} 인치\"" #: src/generics/phantom/testcase_units.md:67 msgid "\"one meter + one_meter = {:?} mm\"" msgstr "\"1미터 + 1미터 = {:?} mm\"" #: src/generics/phantom/testcase_units.md:69 msgid "" "// Nonsensical operations fail as they should:\n" " // Compile-time Error: type mismatch.\n" " //let one_feter = one_foot + one_meter;\n" msgstr "" "// 말도 안 되는 연산은 실패합니다:\n" "// 컴파일 타임 에러: 타입 불일치.\n" "// let one_feter = one_foot + one_meter;\n" #: src/generics/phantom/testcase_units.md:77 msgid "" "[Borrowing (`&`)](../../scope/borrow.md), [Bounds (`X: Y`)](../../generics/" "bounds.md), [enum](../../custom_types/enum.md), [impl & self](../../fn/" "methods.md), [Overloading](../../trait/ops.md), [ref](../../scope/borrow/" "ref.md), [Traits (`X for Y`)](../../trait.md), and [TupleStructs](../../" "custom_types/structs.md)." msgstr "" "[빌림(Borrowing) (`&`)](../../scope/borrow.md), [바운드(Bounds) (`X: Y`)]" "(../../generics/bounds.md), [열거형(enum)](../../custom_types/enum.md), " "[impl & self](../../fn/methods.md), [오버로딩(Overloading)](../../trait/" "ops.md), [ref](../../scope/borrow/ref.md), [트레이트(Traits) (`X for Y`)]" "(../../trait.md), 그리고 [튜플 구조체(TupleStructs)](../../custom_types/" "structs.md)." #: src/scope.md:3 msgid "" "Scopes play an important part in ownership, borrowing, and lifetimes. That " "is, they indicate to the compiler when borrows are valid, when resources can " "be freed, and when variables are created or destroyed." msgstr "" "스코프(범위)는 소유권(ownership), 빌림(borrowing), 라이프타임(lifetimes)에서 " "중요한 역할을 합니다. 즉, 스코프는 컴파일러에게 언제 빌림이 유효한지, 언제 자" "원이 해제될 수 있는지, 언제 변수가 생성되고 파괴되는지를 알려줍니다." #: src/scope/raii.md:3 msgid "" "Variables in Rust do more than just hold data in the stack: they also _own_ " "resources, e.g. `Box` owns memory in the heap. Rust enforces [RAII]" "(https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) " "(Resource Acquisition Is Initialization), so whenever an object goes out of " "scope, its destructor is called and its owned resources are freed." msgstr "" "Rust의 변수는 스택에 데이터를 저장하는 것 이상의 일을 합니다. 예를 들어 " "`Box`는 힙 메모리를 소유하는 것처럼 리소스를 _소유(own)_하기도 합니다. " "Rust는 [RAII](https://en.wikipedia.org/wiki/" "Resource_Acquisition_Is_Initialization) (자원의 획득은 초기화이다)를 강제하므" "로, 객체가 스코프를 벗어날 때마다 소멸자가 호출되어 소유한 리소스가 해제됩니" "다." #: src/scope/raii.md:8 msgid "" "This behavior shields against _resource leak_ bugs, so you'll never have to " "manually free memory or worry about memory leaks again! Here's a quick " "showcase:" msgstr "" "이러한 동작은 _리소스 누수_ 버그를 방지하므로, 수동으로 메모리를 해제하거나 " "메모리 누수에 대해 걱정할 필요가 없습니다! 간단한 예시를 보여드리겠습니다:" #: src/scope/raii.md:12 msgid "// raii.rs\n" msgstr "// raii.rs\n" #: src/scope/raii.md:14 src/scope/raii.md:21 src/scope/raii.md:26 msgid "// Allocate an integer on the heap\n" msgstr "// 힙에 정수를 할당합니다\n" #: src/scope/raii.md:17 msgid "// `_box1` is destroyed here, and memory gets freed\n" msgstr "// `_box1`은 여기서 파괴되고, 메모리가 해제됩니다\n" #: src/scope/raii.md:24 msgid "// A nested scope:\n" msgstr "// 중첩된 스코프:\n" #: src/scope/raii.md:29 msgid "// `_box3` is destroyed here, and memory gets freed\n" msgstr "// `_box3`은 여기서 파괴되고, 메모리가 해제됩니다\n" #: src/scope/raii.md:32 msgid "" "// Creating lots of boxes just for fun\n" " // There's no need to manually free memory!\n" msgstr "" "// 재미 삼아 많은 상자를 만듭니다\n" " // 수동으로 메모리를 해제할 필요가 없습니다!\n" #: src/scope/raii.md:38 msgid "// `_box2` is destroyed here, and memory gets freed\n" msgstr "// `_box2`는 여기서 파괴되고, 메모리가 해제됩니다\n" #: src/scope/raii.md:42 msgid "" "Of course, we can double check for memory errors using [`valgrind`](http://" "valgrind.org/info/):" msgstr "" "물론 [`valgrind`](http://valgrind.org/info/)를 사용하여 메모리 에러를 다시 확" "인할 수 있습니다:" #: src/scope/raii.md:65 msgid "No leaks here!" msgstr "누수가 없습니다!" #: src/scope/raii.md:67 msgid "Destructor" msgstr "소멸자" #: src/scope/raii.md:69 msgid "" "The notion of a destructor in Rust is provided through the [`Drop`](https://" "doc.rust-lang.org/std/ops/trait.Drop.html) trait. The destructor is called " "when the resource goes out of scope. This trait is not required to be " "implemented for every type, only implement it for your type if you require " "its own destructor logic." msgstr "" "Rust에서 소멸자의 개념은 [`Drop`](https://doc.rust-lang.org/std/ops/" "trait.Drop.html) 트레이트를 통해 제공됩니다. 소멸자는 리소스가 스코프를 벗어" "날 때 호출됩니다. 모든 타입에 대해 이 트레이트를 구현할 필요는 없으며, 자체적" "인 소멸자 로직이 필요한 경우에만 구현하면 됩니다." #: src/scope/raii.md:74 msgid "" "Run the below example to see how the [`Drop`](https://doc.rust-lang.org/std/" "ops/trait.Drop.html) trait works. When the variable in the `main` function " "goes out of scope the custom destructor will be invoked." msgstr "" "아래 예제를 실행하여 [`Drop`](https://doc.rust-lang.org/std/ops/" "trait.Drop.html) 트레이트가 어떻게 작동하는지 확인해 보세요. `main` 함수의 변" "수가 스코프를 벗어나면 사용자 정의 소멸자가 호출될 것입니다." #: src/scope/raii.md:82 msgid "\"ToDrop is being dropped\"" msgstr "\"ToDrop이 드롭되고 있습니다\"" #: src/scope/raii.md:88 msgid "\"Made a ToDrop!\"" msgstr "\"ToDrop을 만들었습니다!\"" #: src/scope/raii.md:94 msgid "[Box](../std/box.md)" msgstr "[Box](../std/box.md)" #: src/scope/move.md:3 msgid "" "Because variables are in charge of freeing their own resources, **resources " "can only have one owner**. This prevents resources from being freed more " "than once. Note that not all variables own resources (e.g. [references](../" "flow_control/match/destructuring/destructure_pointers.md))." msgstr "" "변수는 자신의 리소스를 해제할 책임이 있으므로, **리소스는 오직 하나의 소유자" "만 가질 수 있습니다**. 이는 리소스가 한 번 이상 해제되는 것을 방지합니다. 모" "든 변수가 리소스를 소유하는 것은 아닙니다(예: [참조](../flow_control/match/" "destructuring/destructure_pointers.md))." #: src/scope/move.md:8 msgid "" "When doing assignments (`let x = y`) or passing function arguments by value " "(`foo(x)`), the _ownership_ of the resources is transferred. In Rust-speak, " "this is known as a _move_." msgstr "" "할당(`let x = y`)을 하거나 함수 인자를 값으로 전달(`foo(x)`)할 때, 리소스의 _" "소유권_이 이전됩니다. Rust 용어로는 이를 _이동(move)_이라고 합니다." #: src/scope/move.md:12 msgid "" "After moving resources, the previous owner can no longer be used. This " "avoids creating dangling pointers." msgstr "" "리소스를 이동한 후에는 이전 소유자를 더 이상 사용할 수 없습니다. 이는 댕글링 " "포인터(dangling pointers) 생성을 방지합니다." #: src/scope/move.md:16 msgid "// This function takes ownership of the heap allocated memory\n" msgstr "// 이 함수는 힙에 할당된 메모리의 소유권을 가져갑니다\n" #: src/scope/move.md:18 msgid "\"Destroying a box that contains {}\"" msgstr "\"{}를 포함하는 상자를 파괴 중\"" #: src/scope/move.md:20 msgid "// `c` is destroyed and the memory freed\n" msgstr "// `c`가 파괴되고 메모리가 해제됩니다\n" #: src/scope/move.md:24 msgid "// _Stack_ allocated integer\n" msgstr "// _스택_에 할당된 정수\n" #: src/scope/move.md:27 msgid "// *Copy* `x` into `y` - no resources are moved\n" msgstr "// `x`를 `y`로 *복사* - 리소스가 이동되지 않음\n" #: src/scope/move.md:30 msgid "// Both values can be independently used\n" msgstr "// 두 값 모두 독립적으로 사용될 수 있음\n" #: src/scope/move.md:31 msgid "\"x is {}, and y is {}\"" msgstr "\"x는 {}이고, y는 {}입니다\"" #: src/scope/move.md:33 msgid "// `a` is a pointer to a _heap_ allocated integer\n" msgstr "// `a`는 _힙_에 할당된 정수에 대한 포인터입니다\n" #: src/scope/move.md:36 msgid "\"a contains: {}\"" msgstr "\"a가 포함하는 것: {}\"" #: src/scope/move.md:38 msgid "// *Move* `a` into `b`\n" msgstr "// `a`를 `b`로 *이동*\n" #: src/scope/move.md:40 msgid "" "// The pointer address of `a` is copied (not the data) into `b`.\n" " // Both are now pointers to the same heap allocated data, but\n" " // `b` now owns it.\n" msgstr "" "// `a`의 포인터 주소가 (데이터가 아니라) `b`로 복사됩니다.\n" "// 둘 다 이제 동일한 힙 할당 데이터를 가리키지만,\n" "// 이제 `b`가 소유권을 가집니다.\n" #: src/scope/move.md:44 msgid "" "// Error! `a` can no longer access the data, because it no longer owns the\n" " // heap memory\n" " //println!(\"a contains: {}\", a);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `a`는 더 이상 데이터를 소유하고 있지 않으므로 접근할 수 없습니다.\n" "//println!(\"a가 포함하는 것: {}\", a);\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/scope/move.md:49 msgid "" "// This function takes ownership of the heap allocated memory from `b`\n" msgstr "// 이 함수는 `b`로부터 힙에 할당된 메모리의 소유권을 가져갑니다\n" #: src/scope/move.md:52 msgid "" "// Since the heap memory has been freed at this point, this action would\n" " // result in dereferencing freed memory, but it's forbidden by the " "compiler\n" " // Error! Same reason as the previous Error\n" " //println!(\"b contains: {}\", b);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 이 시점에서 힙 메모리가 해제되었으므로, 이 동작은\n" " // 해제된 메모리를 역참조하는 결과를 낳겠지만, 컴파일러에 의해 금지됩니" "다.\n" " // 에러! 이전 에러와 같은 이유입니다.\n" " //println!(\"b가 포함하는 것: {}\", b);\n" " // TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/scope/move/mut.md:3 msgid "Mutability of data can be changed when ownership is transferred." msgstr "소유권이 이전될 때 데이터의 가변성이 변경될 수 있습니다." #: src/scope/move/mut.md:9 msgid "\"immutable_box contains {}\"" msgstr "\"불변 상자가 포함하는 것: {}\"" #: src/scope/move/mut.md:11 msgid "" "// Mutability error\n" " //*immutable_box = 4;\n" msgstr "" "// 가변성 에러\n" " //*immutable_box = 4;\n" #: src/scope/move/mut.md:14 msgid "// *Move* the box, changing the ownership (and mutability)\n" msgstr "// 상자를 *이동*하여 소유권(및 가변성)을 변경합니다\n" #: src/scope/move/mut.md:17 msgid "\"mutable_box contains {}\"" msgstr "\"가변 상자가 포함하는 것: {}\"" #: src/scope/move/mut.md:19 msgid "// Modify the contents of the box\n" msgstr "// 상자의 내용물을 수정합니다\n" #: src/scope/move/mut.md:22 msgid "\"mutable_box now contains {}\"" msgstr "\"가변 상자가 이제 포함하는 것: {}\"" #: src/scope/move/partial_move.md:3 msgid "" "Within the [destructuring](../../flow_control/match/destructuring.md) of a " "single variable, both `by-move` and `by-reference` pattern bindings can be " "used at the same time. Doing this will result in a _partial move_ of the " "variable, which means that parts of the variable will be moved while other " "parts stay. In such a case, the parent variable cannot be used afterwards as " "a whole, however the parts that are only referenced (and not moved) can " "still be used. Note that types that implement the [`Drop` trait](../../trait/" "drop.md) cannot be partially moved from, because its `drop` method would use " "it afterwards as a whole." msgstr "" "단일 변수의 [구조 분해](../../flow_control/match/destructuring.md) 내에서 `이" "동에 의한(by-move)` 패턴 바인딩과 `참조에 의한(by-reference)` 패턴 바인딩을 " "동시에 사용할 수 있습니다. 이렇게 하면 변수의 _부분 이동(partial move)_이 발" "생하는데, 이는 변수의 일부는 이동하고 다른 부분은 남아있음을 의미합니다. 이" "런 경우 부모 변수는 전체로서 나중에 사용될 수 없지만, 참조만 되고 이동되지 않" "은 부분은 여전히 사용될 수 있습니다. [`Drop` 트레이트](../../trait/drop.md)" "를 구현한 타입은 부분적으로 이동될 수 없다는 점에 유의하세요. 왜냐하면 해당 " "타입의 `drop` 메서드가 나중에 전체로서 사용될 것이기 때문입니다." #: src/scope/move/partial_move.md:22 msgid "" "// Error! cannot move out of a type which implements the `Drop` trait\n" " //impl Drop for Person {\n" " // fn drop(&mut self) {\n" " // println!(\"Dropping the person struct {:?}\", self)\n" " // }\n" " //}\n" " // TODO ^ Try uncommenting these lines\n" msgstr "" "// 에러! `Drop` 트레이트를 구현한 타입에서는 이동해 나올 수 없습니다\n" " //impl Drop for Person {\n" " // fn drop(&mut self) {\n" " // println!(\"Person 구조체를 드롭합니다 {:?}\", self)\n" " // }\n" " //}\n" " // TODO ^ 이 줄들의 주석을 해제해 보세요\n" #: src/scope/move/partial_move.md:35 msgid "// `name` is moved out of person, but `age` is referenced\n" msgstr "// `name`은 person에서 밖으로 이동되지만, `age`는 참조됩니다\n" #: src/scope/move/partial_move.md:38 msgid "\"The person's age is {}\"" msgstr "\"이 사람의 나이는 {}입니다\"" #: src/scope/move/partial_move.md:40 msgid "\"The person's name is {}\"" msgstr "\"이 사람의 이름은 {}입니다\"" #: src/scope/move/partial_move.md:42 msgid "" "// Error! borrow of partially moved value: `person` partial move occurs\n" " //println!(\"The person struct is {:?}\", person);\n" msgstr "" "// 에러! 부분적으로 이동된 값의 빌림: `person`의 부분 이동이 발생했습니다\n" " //println!(\"Person 구조체는 {:?}입니다\", person);\n" #: src/scope/move/partial_move.md:45 msgid "" "// `person` cannot be used but `person.age` can be used as it is not moved\n" msgstr "" "// `person`은 사용할 수 없지만 `person.age`는 이동되지 않았으므로 사용할 수 " "있습니다\n" #: src/scope/move/partial_move.md:46 msgid "\"The person's age from person struct is {}\"" msgstr "\"person 구조체에서 가져온 이 사람의 나이는 {}입니다\"" #: src/scope/move/partial_move.md:50 msgid "" "(In this example, we store the `age` variable on the heap to illustrate the " "partial move: deleting `ref` in the above code would give an error as the " "ownership of `person.age` would be moved to the variable `age`. If " "`Person.age` were stored on the stack, `ref` would not be required as the " "definition of `age` would copy the data from `person.age` without moving it.)" msgstr "" "(이 예제에서는 부분 이동을 설명하기 위해 `age` 변수를 힙에 저장합니다. 위 코" "드에서 `ref`를 삭제하면 `person.age`의 소유권이 `age` 변수로 이동하기 때문에 " "에러가 발생합니다. `Person.age`가 스택에 저장되어 있었다면, `age`의 정의가 " "`person.age`에서 데이터를 이동 없이 복사하므로 `ref`가 필요하지 않았을 것입니" "다.)" #: src/scope/move/partial_move.md:59 msgid "[destructuring](../../flow_control/match/destructuring.md)" msgstr "[구조 분해](../../flow_control/match/destructuring.md)" #: src/scope/borrow.md:3 msgid "" "Most of the time, we'd like to access data without taking ownership over it. " "To accomplish this, Rust uses a _borrowing_ mechanism. Instead of passing " "objects by value (`T`), objects can be passed by reference (`&T`)." msgstr "" "대부분의 경우, 우리는 데이터의 소유권을 가져오지 않고 데이터에 접근하고 싶어 " "합니다. 이를 달성하기 위해 Rust는 _빌림(borrowing)_ 메커니즘을 사용합니다. 객" "체를 값(`T`)으로 전달하는 대신, 참조(`&T`)로 전달할 수 있습니다." #: src/scope/borrow.md:7 msgid "" "The compiler statically guarantees (via its borrow checker) that references " "_always_ point to valid objects. That is, while references to an object " "exist, the object cannot be destroyed." msgstr "" "컴파일러는 (빌림 검사기를 통해) 참조가 _항상_ 유효한 객체를 가리킨다는 것을 " "정적으로 보장합니다. 즉, 객체에 대한 참조가 존재하는 동안에는 해당 객체를 파" "괴할 수 없습니다." #: src/scope/borrow.md:12 msgid "// This function takes ownership of a box and destroys it\n" msgstr "// 이 함수는 상자의 소유권을 가져와 파괴합니다\n" #: src/scope/borrow.md:14 msgid "\"Destroying box that contains {}\"" msgstr "\"{}를 포함하는 상자를 파괴 중\"" #: src/scope/borrow.md:16 msgid "// This function borrows an i32\n" msgstr "// 이 함수는 i32를 빌립니다\n" #: src/scope/borrow.md:19 msgid "\"This int is: {}\"" msgstr "\"이 정수는: {}\"" #: src/scope/borrow.md:23 msgid "" "// Create a boxed i32 in the heap, and an i32 on the stack\n" " // Remember: numbers can have arbitrary underscores added for " "readability\n" " // 5_i32 is the same as 5i32\n" msgstr "" "// 힙에 boxed i32를 생성하고, 스택에 i32를 생성합니다\n" "// 기억하세요: 숫자는 가독성을 위해 임의의 밑줄을 추가할 수 있습니다\n" "// 5_i32는 5i32와 동일합니다\n" #: src/scope/borrow.md:29 msgid "" "// Borrow the contents of the box. Ownership is not taken,\n" " // so the contents can be borrowed again.\n" msgstr "" "// 상자의 내용물을 빌립니다. 소유권을 가져가지 않으므로,\n" "// 내용물을 다시 빌릴 수 있습니다.\n" #: src/scope/borrow.md:35 msgid "// Take a reference to the data contained inside the box\n" msgstr "// 상자 안에 포함된 데이터에 대한 참조를 가져옵니다\n" #: src/scope/borrow.md:38 msgid "" "// Error!\n" " // Can't destroy `boxed_i32` while the inner value is borrowed later " "in scope.\n" msgstr "" "// 에러!\n" "// 내부 값이 스코프의 나중 부분에서 빌려지고 있는 동안에는 `boxed_i32`를 파괴" "할 수 없습니다.\n" #: src/scope/borrow.md:43 msgid "// Attempt to borrow `_ref_to_i32` after inner value is destroyed\n" msgstr "// 내부 값이 파괴된 후에 `_ref_to_i32`를 빌리려고 시도합니다\n" #: src/scope/borrow.md:45 msgid "// `_ref_to_i32` goes out of scope and is no longer borrowed.\n" msgstr "// `_ref_to_i32`가 스코프를 벗어나며 더 이상 빌려지지 않습니다.\n" #: src/scope/borrow.md:48 msgid "" "// `boxed_i32` can now give up ownership to `eat_box_i32` and be destroyed\n" msgstr "" "// `boxed_i32`는 이제 `eat_box_i32`에게 소유권을 넘기고 파괴될 수 있습니다\n" #: src/scope/borrow/mut.md:3 msgid "" "Mutable data can be mutably borrowed using `&mut T`. This is called a " "_mutable reference_ and gives read/write access to the borrower. In " "contrast, `&T` borrows the data via an immutable reference, and the borrower " "can read the data but not modify it:" msgstr "" "가변 데이터는 `&mut T`를 사용하여 가변적으로 빌려올 수 있습니다. 이를 _가변 " "참조(mutable reference)_라고 하며 빌리는 사람에게 읽기/쓰기 권한을 부여합니" "다. 반면 `&T`는 불변 참조를 통해 데이터를 빌려오며, 빌리는 사람은 데이터를 읽" "을 수는 있지만 수정할 수는 없습니다:" #: src/scope/borrow/mut.md:12 msgid "" "// `&'static str` is a reference to a string allocated in read only memory\n" msgstr "" "// `&'static str`은 읽기 전용 메모리에 할당된 문자열에 대한 참조입니다\n" #: src/scope/borrow/mut.md:17 msgid "// This function takes a reference to a book\n" msgstr "// 이 함수는 책에 대한 참조를 받습니다\n" #: src/scope/borrow/mut.md:20 msgid "\"I immutably borrowed {} - {} edition\"" msgstr "\"{} - {} 판을 불변으로 빌렸습니다\"" #: src/scope/borrow/mut.md:22 msgid "" "// This function takes a reference to a mutable book and changes `year` to " "2014\n" msgstr "" "// 이 함수는 가변적인 책에 대한 참조를 받아 `year`를 2014로 변경합니다\n" #: src/scope/borrow/mut.md:26 msgid "\"I mutably borrowed {} - {} edition\"" msgstr "\"{} - {} 판을 가변으로 빌렸습니다\"" #: src/scope/borrow/mut.md:30 msgid "// Create an immutable Book named `immutabook`\n" msgstr "// `immutabook`이라는 이름의 불변 책을 생성합니다\n" #: src/scope/borrow/mut.md:32 msgid "// string literals have type `&'static str`\n" msgstr "// 문자열 리터럴은 `&'static str` 타입을 가집니다\n" #: src/scope/borrow/mut.md:33 msgid "\"Douglas Hofstadter\"" msgstr "\"더글라스 호프스태터\"" #: src/scope/borrow/mut.md:34 msgid "\"Gödel, Escher, Bach\"" msgstr "\"괴델, 에셔, 바흐\"" #: src/scope/borrow/mut.md:38 msgid "// Create a mutable copy of `immutabook` and call it `mutabook`\n" msgstr "// `immutabook`의 가변 복사본을 생성하고 `mutabook`이라고 부릅니다\n" #: src/scope/borrow/mut.md:41 msgid "// Immutably borrow an immutable object\n" msgstr "// 불변 객체를 불변으로 빌립니다\n" #: src/scope/borrow/mut.md:44 msgid "// Immutably borrow a mutable object\n" msgstr "// 가변 객체를 불변으로 빌립니다\n" #: src/scope/borrow/mut.md:47 msgid "// Borrow a mutable object as mutable\n" msgstr "// 가변 객체를 가변으로 빌립니다\n" #: src/scope/borrow/mut.md:50 msgid "// Error! Cannot borrow an immutable object as mutable\n" msgstr "// 에러! 불변 객체는 가변으로 빌릴 수 없습니다\n" #: src/scope/borrow/mut.md:58 msgid "[`static`](../lifetime/static_lifetime.md)" msgstr "[`static`](../lifetime/static_lifetime.md)" #: src/scope/borrow/alias.md:3 msgid "" "Data can be immutably borrowed any number of times, but while immutably " "borrowed, the original data can't be mutably borrowed. On the other hand, " "only _one_ mutable borrow is allowed at a time. The original data can be " "borrowed again only _after_ the mutable reference has been used for the last " "time." msgstr "" "데이터는 횟수에 제한 없이 불변으로 빌려질 수 있지만, 불변으로 빌려진 동안에" "는 원본 데이터를 가변으로 빌릴 수 없습니다. 반면에, 가변 빌림은 한 번에 _하나" "_만 허용됩니다. 원본 데이터는 가변 참조가 마지막으로 사용된 _후_에만 다시 빌" "려질 수 있습니다." #: src/scope/borrow/alias.md:17 msgid "// Data can be accessed via the references and the original owner\n" msgstr "// 데이터는 참조와 원본 소유자를 통해 접근할 수 있습니다\n" #: src/scope/borrow/alias.md:18 src/scope/borrow/alias.md:27 #: src/scope/borrow/alias.md:49 msgid "\"Point has coordinates: ({}, {}, {})\"" msgstr "\"점의 좌표: ({}, {}, {})\"" #: src/scope/borrow/alias.md:21 msgid "" "// Error! Can't borrow `point` as mutable because it's currently\n" " // borrowed as immutable.\n" " // let mutable_borrow = &mut point;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! 현재 불변으로 빌려진 상태이기 때문에 `point`를 가변으로 빌릴 수 없습" "니다.\n" "// let mutable_borrow = &mut point;\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/scope/borrow/alias.md:26 msgid "// The borrowed values are used again here\n" msgstr "// 빌려온 값들이 여기서 다시 사용됩니다\n" #: src/scope/borrow/alias.md:30 msgid "" "// The immutable references are no longer used for the rest of the code so\n" " // it is possible to reborrow with a mutable reference.\n" msgstr "" "// 불변 참조들이 코드의 나머지 부분에서 더 이상 사용되지 않으므로\n" "// 가변 참조로 다시 빌리는 것이 가능합니다.\n" #: src/scope/borrow/alias.md:34 msgid "// Change data via mutable reference\n" msgstr "// 가변 참조를 통해 데이터를 변경합니다\n" #: src/scope/borrow/alias.md:39 msgid "" "// Error! Can't borrow `point` as immutable because it's currently\n" " // borrowed as mutable.\n" " // let y = &point.y;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! 현재 가변으로 빌려진 상태이기 때문에 `point`를 불변으로 빌릴 수 없습" "니다.\n" "// let y = &point.y;\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/scope/borrow/alias.md:44 msgid "" "// Error! Can't print because `println!` takes an immutable reference.\n" " // println!(\"Point Z coordinate is {}\", point.z);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `println!`은 불변 참조를 받기 때문에 출력할 수 없습니다.\n" "// println!(\"점의 Z 좌표는 {}입니다\", point.z);\n" "// TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/scope/borrow/alias.md:48 msgid "// Ok! Mutable references can be passed as immutable to `println!`\n" msgstr "// 좋습니다! 가변 참조는 불변 참조로 `println!`에 전달될 수 있습니다\n" #: src/scope/borrow/alias.md:52 msgid "" "// The mutable reference is no longer used for the rest of the code so it\n" " // is possible to reborrow\n" msgstr "" "// 가변 참조가 코드의 나머지 부분에서 더 이상 사용되지 않으므로\n" "// 다시 빌리는 것이 가능합니다\n" #: src/scope/borrow/alias.md:55 msgid "\"Point now has coordinates: ({}, {}, {})\"" msgstr "\"점은 이제 다음 좌표를 가집니다: ({}, {}, {})\"" #: src/scope/borrow/ref.md:3 msgid "" "When doing pattern matching or destructuring via the `let` binding, the " "`ref` keyword can be used to take references to the fields of a struct/" "tuple. The example below shows a few instances where this can be useful:" msgstr "" "`let` 바인딩을 통해 패턴 매칭이나 구조 분해를 수행할 때, `ref` 키워드를 사용" "하여 구조체/튜플 필드에 대한 참조를 가져올 수 있습니다. 아래 예제는 이것이 유" "용할 수 있는 몇 가지 사례를 보여줍니다:" #: src/scope/borrow/ref.md:14 msgid "" "// A `ref` borrow on the left side of an assignment is equivalent to\n" " // an `&` borrow on the right side.\n" msgstr "" "// 할당의 왼쪽 편에 있는 `ref` 빌림은\n" "// 오른쪽 편에 있는 `&` 빌림과 동일합니다.\n" #: src/scope/borrow/ref.md:19 msgid "\"ref_c1 equals ref_c2: {}\"" msgstr "\"ref_c1은 ref_c2와 같습니다: {}\"" #: src/scope/borrow/ref.md:23 msgid "// `ref` is also valid when destructuring a struct.\n" msgstr "// `ref`는 구조체를 구조 분해할 때도 유효합니다.\n" #: src/scope/borrow/ref.md:25 msgid "// `ref_to_x` is a reference to the `x` field of `point`.\n" msgstr "// `ref_to_x`는 `point`의 `x` 필드에 대한 참조입니다.\n" #: src/scope/borrow/ref.md:28 msgid "// Return a copy of the `x` field of `point`.\n" msgstr "// `point`의 `x` 필드 복사본을 반환합니다.\n" #: src/scope/borrow/ref.md:32 msgid "// A mutable copy of `point`\n" msgstr "// `point`의 가변 복사본\n" #: src/scope/borrow/ref.md:36 msgid "// `ref` can be paired with `mut` to take mutable references.\n" msgstr "// `ref`는 `mut`와 짝을 이루어 가변 참조를 가져올 수 있습니다.\n" #: src/scope/borrow/ref.md:39 msgid "// Mutate the `y` field of `mutable_point` via a mutable reference.\n" msgstr "// 가변 참조를 통해 `mutable_point`의 `y` 필드를 변경합니다.\n" #: src/scope/borrow/ref.md:43 msgid "\"point is ({}, {})\"" msgstr "\"point는 ({}, {})입니다\"" #: src/scope/borrow/ref.md:44 msgid "\"mutable_point is ({}, {})\"" msgstr "\"mutable_point는 ({}, {})입니다\"" #: src/scope/borrow/ref.md:46 msgid "// A mutable tuple that includes a pointer\n" msgstr "// 포인터를 포함하는 가변 튜플\n" #: src/scope/borrow/ref.md:50 msgid "// Destructure `mutable_tuple` to change the value of `last`.\n" msgstr "// `mutable_tuple`을 구조 분해하여 `last` 값을 변경합니다.\n" #: src/scope/borrow/ref.md:55 msgid "\"tuple is {:?}\"" msgstr "\"튜플은 {:?}입니다\"" #: src/scope/lifetime.md:3 msgid "" "A _lifetime_ is a construct the compiler (or more specifically, its _borrow " "checker_) uses to ensure all borrows are valid. Specifically, a variable's " "lifetime begins when it is created and ends when it is destroyed. While " "lifetimes and scopes are often referred to together, they are not the same." msgstr "" "_라이프타임(lifetime)_은 컴파일러(더 구체적으로는 _빌림 검사기_)가 모든 빌림" "이 유효한지 확인하기 위해 사용하는 구성 요소입니다. 구체적으로, 변수의 라이프" "타임은 생성될 때 시작하고 파괴될 때 끝납니다. 라이프타임과 스코프는 종종 함" "께 언급되지만, 같은 것은 아닙니다." #: src/scope/lifetime.md:8 msgid "" "Take, for example, the case where we borrow a variable via `&`. The borrow " "has a lifetime that is determined by where it is declared. As a result, the " "borrow is valid as long as it ends before the lender is destroyed. However, " "the scope of the borrow is determined by where the reference is used." msgstr "" "예를 들어, `&`를 통해 변수를 빌리는 경우를 생각해 봅시다. 빌림은 선언된 위치" "에 따라 결정되는 라이프타임을 가집니다. 결과적으로 빌림은 빌려준 대상이 파괴" "되기 전에 끝나는 한 유효합니다. 하지만 빌림의 스코프는 참조가 사용되는 위치" "에 따라 결정됩니다." #: src/scope/lifetime.md:13 msgid "" "In the following example and in the rest of this section, we will see how " "lifetimes relate to scopes, as well as how the two differ." msgstr "" "다음 예제와 이 섹션의 나머지 부분에서 라이프타임이 스코프와 어떻게 관련되어 " "있는지, 그리고 두 가지가 어떻게 다른지 살펴보겠습니다." #: src/scope/lifetime.md:17 msgid "" "// Lifetimes are annotated below with lines denoting the creation\n" "// and destruction of each variable.\n" "// `i` has the longest lifetime because its scope entirely encloses\n" "// both `borrow1` and `borrow2`. The duration of `borrow1` compared\n" "// to `borrow2` is irrelevant since they are disjoint.\n" msgstr "" "// 아래에는 각 변수의 생성과 파괴를 나타내는 선으로 라이프타임이 주석 처리되" "어 있습니다.\n" "// `i`의 스코프가 `borrow1`과 `borrow2`를 완전히 감싸고 있기 때문에\n" "// `i`는 가장 긴 라이프타임을 가집니다. `borrow1`과 `borrow2`는 서로 겹치지 " "않으므로\n" "// 둘의 기간 비교는 무의미합니다.\n" #: src/scope/lifetime.md:23 msgid "" "// Lifetime for `i` starts. ────────────────┐\n" " // │\n" msgstr "" "// `i`의 라이프타임 시작. ──────────────────┐\n" " // │\n" #: src/scope/lifetime.md:25 src/scope/lifetime.md:32 msgid "// │\n" msgstr "// │\n" #: src/scope/lifetime.md:26 msgid "" "// `borrow1` lifetime starts. ──┐│\n" " // ││\n" msgstr "" "// `borrow1` 라이프타임 시작. ──┐│\n" " // ││\n" #: src/scope/lifetime.md:28 msgid "\"borrow1: {}\"" msgstr "\"borrow1: {}\"" #: src/scope/lifetime.md:28 src/scope/lifetime.md:35 msgid "// ││\n" msgstr "// ││\n" #: src/scope/lifetime.md:29 msgid "" "// `borrow1` ends. ─────────────────────────────────┘│\n" " // │\n" " // │\n" msgstr "" "// `borrow1` 끝. ───────────────────────────────────┘│\n" " // │\n" " // │\n" #: src/scope/lifetime.md:33 msgid "" "// `borrow2` lifetime starts. ──┐│\n" " // ││\n" msgstr "" "// `borrow2` 라이프타임 시작. ──┐│\n" " // ││\n" #: src/scope/lifetime.md:35 msgid "\"borrow2: {}\"" msgstr "\"borrow2: {}\"" #: src/scope/lifetime.md:36 msgid "" "// `borrow2` ends. ─────────────────────────────────┘│\n" " // │\n" msgstr "" "// `borrow2` 끝. ───────────────────────────────────┘│\n" " // │\n" #: src/scope/lifetime.md:38 msgid "// Lifetime ends. ─────────────────────────────────────┘\n" msgstr "// 라이프타임 끝. ─────────────────────────────────────┘\n" #: src/scope/lifetime.md:41 msgid "" "Note that no names or types are assigned to label lifetimes. This restricts " "how lifetimes will be able to be used as we will see." msgstr "" "레이블 라이프타임에는 이름이나 타입이 할당되지 않는다는 점에 유의하세요. 이" "는 앞으로 보게 될 것처럼 라이프타임을 사용하는 방식에 제한을 줍니다." #: src/scope/lifetime/explicit.md:3 msgid "" "The borrow checker uses explicit lifetime annotations to determine how long " "references should be valid. In cases where lifetimes are not elided[^1], " "Rust requires explicit annotations to determine what the lifetime of a " "reference should be. The syntax for explicitly annotating a lifetime uses an " "apostrophe character as follows:" msgstr "" "빌림 검사기는 참조가 얼마나 오래 유효해야 하는지 결정하기 위해 명시적 라이프" "타임 어노테이션을 사용합니다. 라이프타임이 생략(elided)[^1]되지 않는 경우, " "Rust는 참조의 라이프타임이 어떻게 되어야 하는지 결정하기 위해 명시적인 어노테" "이션을 요구합니다. 라이프타임을 명시적으로 어노테이션하는 구문은 다음과 같이 " "아포스트로피 문자를 사용합니다:" #: src/scope/lifetime/explicit.md:10 msgid "// `foo` has a lifetime parameter `'a`\n" msgstr "// `foo`는 라이프타임 파라미터 `'a`를 가집니다\n" #: src/scope/lifetime/explicit.md:14 msgid "" "Similar to [closures](../../fn/closures/anonymity.md), using lifetimes " "requires generics. Additionally, this lifetime syntax indicates that the " "lifetime of `foo` may not exceed that of `'a`. Explicit annotation of a type " "has the form `&'a T` where `'a` has already been introduced." msgstr "" "[클로저](../../fn/closures/anonymity.md)와 유사하게, 라이프타임을 사용하려면 " "제네릭이 필요합니다. 또한, 이 라이프타임 구문은 `foo`의 라이프타임이 `'a`의 " "라이프타임을 초과할 수 없음을 나타냅니다. 타입의 명시적 어노테이션은 `&'a T` " "형식을 가지며, 여기서 `'a`는 이미 도입된 라이프타임입니다." #: src/scope/lifetime/explicit.md:19 msgid "In cases with multiple lifetimes, the syntax is similar:" msgstr "여러 라이프타임이 있는 경우에도 구문은 유사합니다:" #: src/scope/lifetime/explicit.md:22 msgid "// `foo` has lifetime parameters `'a` and `'b`\n" msgstr "// `foo`는 라이프타임 파라미터 `'a`와 `'b`를 가집니다\n" #: src/scope/lifetime/explicit.md:26 msgid "" "In this case, the lifetime of `foo` cannot exceed that of either `'a` _or_ " "`'b`." msgstr "" "이 경우, `foo`의 라이프타임은 `'a` _또는_ `'b` 중 어느 하나의 라이프타임도 초" "과할 수 없습니다." #: src/scope/lifetime/explicit.md:28 msgid "See the following example for explicit lifetime annotation in use:" msgstr "명시적 라이프타임 어노테이션이 사용된 다음 예제를 참조하세요:" #: src/scope/lifetime/explicit.md:31 msgid "" "// `print_refs` takes two references to `i32` which have different\n" "// lifetimes `'a` and `'b`. These two lifetimes must both be at\n" "// least as long as the function `print_refs`.\n" msgstr "" "// `print_refs`는 서로 다른 라이프타임 `'a`와 `'b`를 가진\n" "// 두 개의 `i32` 참조를 받습니다. 이 두 라이프타임은 모두\n" "// 적어도 `print_refs` 함수만큼 길어야 합니다.\n" #: src/scope/lifetime/explicit.md:35 msgid "\"x is {} and y is {}\"" msgstr "\"x는 {}이고 y는 {}입니다\"" #: src/scope/lifetime/explicit.md:37 msgid "" "// A function which takes no arguments, but has a lifetime parameter `'a`.\n" msgstr "// 인자를 받지 않지만 라이프타임 파라미터 `'a`를 가진 함수입니다.\n" #: src/scope/lifetime/explicit.md:42 msgid "// ERROR: `_x` does not live long enough\n" msgstr "// 에러: `_x`의 수명이 충분히 길지 않습니다\n" #: src/scope/lifetime/explicit.md:44 msgid "" "// Attempting to use the lifetime `'a` as an explicit type annotation\n" " // inside the function will fail because the lifetime of `&_x` is " "shorter\n" " // than that of `_y`. A short lifetime cannot be coerced into a longer " "one.\n" msgstr "" "// 함수 내부에서 라이프타임 `'a`를 명시적 타입 어노테이션으로 사용하려고 하" "면\n" " // 실패합니다. `&_x`의 라이프타임이 `_y`의 라이프타임보다 짧기 때문입니" "다.\n" " // 짧은 라이프타임은 더 긴 라이프타임으로 강제 변환될 수 없습니다.\n" #: src/scope/lifetime/explicit.md:50 msgid "// Create variables to be borrowed below.\n" msgstr "// 아래에서 빌려올 변수들을 생성합니다.\n" #: src/scope/lifetime/explicit.md:53 msgid "// Borrows (`&`) of both variables are passed into the function.\n" msgstr "// 두 변수의 빌림(`&`)이 함수로 전달됩니다.\n" #: src/scope/lifetime/explicit.md:55 msgid "" "// Any input which is borrowed must outlive the borrower.\n" " // In other words, the lifetime of `four` and `nine` must\n" " // be longer than that of `print_refs`.\n" msgstr "" "// 빌려온 모든 입력은 빌리는 주체보다 오래 살아야 합니다.\n" " // 다시 말해, `four`와 `nine`의 라이프타임은\n" " // `print_refs`의 라이프타임보다 길어야 합니다.\n" #: src/scope/lifetime/explicit.md:60 msgid "" "// `failed_borrow` contains no references to force `'a` to be\n" " // longer than the lifetime of the function, but `'a` is longer.\n" " // Because the lifetime is never constrained, it defaults to `'static`.\n" msgstr "" "// `failed_borrow`는 `'a`가 함수의 라이프타임보다 길어야 함을 강제하는\n" "// 참조를 포함하지 않지만, `'a`는 더 깁니다.\n" "// 라이프타임이 결코 제약되지 않으므로, 이는 `'static`으로 기본 설정됩니다.\n" #: src/scope/lifetime/explicit.md:66 msgid "" "[elision](elision.md) implicitly annotates lifetimes and so is different." msgstr "" "[생략(elision)](elision.md)은 암시적으로 라이프타임을 어노테이션하므로 다릅니" "다." #: src/scope/lifetime/explicit.md:70 msgid "[generics](../../generics.md) and [closures](../../fn/closures.md)" msgstr "[제네릭](../../generics.md) 및 [클로저](../../fn/closures.md)" #: src/scope/lifetime/fn.md:3 msgid "" "Ignoring [elision](elision.md), function signatures with lifetimes have a " "few constraints:" msgstr "" "[생략](elision.md)을 무시하고, 라이프타임을 가진 함수 시그니처에는 몇 가지 제" "약 사항이 있습니다:" #: src/scope/lifetime/fn.md:5 msgid "any reference _must_ have an annotated lifetime." msgstr "모든 참조는 _반드시_ 어노테이션된 라이프타임을 가져야 합니다." #: src/scope/lifetime/fn.md:6 msgid "" "any reference being returned _must_ have the same lifetime as an input or be " "`static`." msgstr "" "반환되는 모든 참조는 입력과 동일한 라이프타임을 가지거나 `static`이어야 _합니" "다_." #: src/scope/lifetime/fn.md:9 msgid "" "Additionally, note that returning references without input is banned if it " "would result in returning references to invalid data. The following example " "shows off some valid forms of functions with lifetimes:" msgstr "" "또한, 입력 없이 참조를 반환하는 것이 유효하지 않은 데이터에 대한 참조를 반환" "하는 결과를 낳는다면 금지된다는 점에 유의하세요. 다음 예제는 라이프타임이 있" "는 유효한 함수 형태를 보여줍니다:" #: src/scope/lifetime/fn.md:14 msgid "" "// One input reference with lifetime `'a` which must live\n" "// at least as long as the function.\n" msgstr "" "// 라이프타임 `'a`를 가진 하나의 입력 참조입니다.\n" "// 이 참조는 적어도 함수만큼 오래 살아야 합니다.\n" #: src/scope/lifetime/fn.md:17 msgid "\"`print_one`: x is {}\"" msgstr "\"`print_one`: x는 {}입니다\"" #: src/scope/lifetime/fn.md:19 msgid "// Mutable references are possible with lifetimes as well.\n" msgstr "// 가변 참조도 라이프타임과 함께 사용할 수 있습니다.\n" #: src/scope/lifetime/fn.md:24 msgid "" "// Multiple elements with different lifetimes. In this case, it\n" "// would be fine for both to have the same lifetime `'a`, but\n" "// in more complex cases, different lifetimes may be required.\n" msgstr "" "// 서로 다른 라이프타임을 가진 여러 요소들입니다. 이 경우,\n" "// 둘 다 동일한 라이프타임 `'a`를 가져도 괜찮지만,\n" "// 더 복잡한 경우에는 서로 다른 라이프타임이 필요할 수 있습니다.\n" #: src/scope/lifetime/fn.md:29 msgid "\"`print_multi`: x is {}, y is {}\"" msgstr "\"`print_multi`: x는 {}, y는 {}입니다\"" #: src/scope/lifetime/fn.md:31 msgid "" "// Returning references that have been passed in is acceptable.\n" "// However, the correct lifetime must be returned.\n" msgstr "" "// 전달된 참조를 반환하는 것은 허용됩니다.\n" "// 하지만, 올바른 라이프타임이 반환되어야 합니다.\n" #: src/scope/lifetime/fn.md:35 msgid "" "//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n" "// The above is invalid: `'a` must live longer than the function.\n" "// Here, `&String::from(\"foo\")` would create a `String`, followed by a\n" "// reference. Then the data is dropped upon exiting the scope, leaving\n" "// a reference to invalid data to be returned.\n" msgstr "" "//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n" "// 위 코드는 유효하지 않습니다: `'a`는 함수보다 오래 살아야 합니다.\n" "// 여기서 `&String::from(\"foo\")`는 `String`을 생성한 후 참조를 생성합니" "다.\n" "// 그런 다음 스코프를 벗어날 때 데이터가 드롭되어,\n" "// 유효하지 않은 데이터에 대한 참조가 반환됩니다.\n" #: src/scope/lifetime/fn.md:60 msgid "[Functions](../../fn.md)" msgstr "[함수](../../fn.md)" #: src/scope/lifetime/methods.md:3 msgid "Methods are annotated similarly to functions:" msgstr "메서드는 함수와 유사하게 어노테이션됩니다:" #: src/scope/lifetime/methods.md:9 msgid "// Annotate lifetimes as in a standalone function.\n" msgstr "// 독립형 함수처럼 라이프타임을 어노테이션합니다.\n" #: src/scope/lifetime/methods.md:12 msgid "\"`print`: {}\"" msgstr "\"`print`: {}\"" #: src/scope/lifetime/methods.md:26 msgid "[methods](../../fn/methods.md)" msgstr "[메서드](../../fn/methods.md)" #: src/scope/lifetime/struct.md:3 msgid "Annotation of lifetimes in structures are also similar to functions:" msgstr "구조체에서의 라이프타임 어노테이션도 함수와 비슷합니다:" #: src/scope/lifetime/struct.md:6 msgid "" "// A type `Borrowed` which houses a reference to an\n" "// `i32`. The reference to `i32` must outlive `Borrowed`.\n" msgstr "" "// `i32`에 대한 참조를 보관하는 `Borrowed` 타입입니다.\n" "// `i32`에 대한 참조는 `Borrowed`보다 오래 살아야 합니다.\n" #: src/scope/lifetime/struct.md:10 msgid "// Similarly, both references here must outlive this structure.\n" msgstr "// 마찬가지로, 여기의 두 참조는 이 구조체보다 오래 살아야 합니다.\n" #: src/scope/lifetime/struct.md:17 msgid "// An enum which is either an `i32` or a reference to one.\n" msgstr "// `i32`이거나 이에 대한 참조인 열거형입니다.\n" #: src/scope/lifetime/struct.md:34 src/scope/lifetime/struct.md:36 msgid "\"x is borrowed in {:?}\"" msgstr "\"x는 {:?}에서 빌려졌습니다\"" #: src/scope/lifetime/struct.md:35 msgid "\"x and y are borrowed in {:?}\"" msgstr "\"x와 y는 {:?}에서 빌려졌습니다\"" #: src/scope/lifetime/struct.md:37 msgid "\"y is *not* borrowed in {:?}\"" msgstr "\"y는 {:?}에서 빌려지지 *않았습니다*\"" #: src/scope/lifetime/struct.md:43 msgid "[`struct`s](../../custom_types/structs.md)" msgstr "[`struct`](../../custom_types/structs.md)" #: src/scope/lifetime/trait.md:3 msgid "" "Annotation of lifetimes in trait methods basically are similar to functions. " "Note that `impl` may have annotation of lifetimes too." msgstr "" "트레이트 메서드의 라이프타임 어노테이션은 기본적으로 함수와 유사합니다. " "`impl`도 라이프타임 어노테이션을 가질 수 있음에 유의하세요." #: src/scope/lifetime/trait.md:7 msgid "// A struct with annotation of lifetimes.\n" msgstr "// 라이프타임 어노테이션이 있는 구조체.\n" #: src/scope/lifetime/trait.md:12 msgid "// Annotate lifetimes to impl.\n" msgstr "// impl에 라이프타임을 어노테이션합니다.\n" #: src/scope/lifetime/trait.md:24 msgid "\"b is {:?}\"" msgstr "\"b는 {:?}입니다\"" #: src/scope/lifetime/trait.md:30 msgid "[`trait`s](../../trait.md)" msgstr "[`trait`](../../trait.md)" #: src/scope/lifetime/lifetime_bounds.md:3 msgid "" "Just like generic types can be bounded, lifetimes (themselves generic) use " "bounds as well. The `:` character has a slightly different meaning here, but " "`+` is the same. Note how the following read:" msgstr "" "제네릭 타입이 바운드될 수 있는 것처럼, (그 자체로 제네릭인) 라이프타임도 바운" "드를 사용합니다. 여기서 `:` 문자는 약간 다른 의미를 갖지만, `+`는 동일합니" "다. 다음이 어떻게 읽히는지 주목하세요:" #: src/scope/lifetime/lifetime_bounds.md:7 msgid "`T: 'a`: _All_ references in `T` must outlive lifetime `'a`." msgstr "" "`T: 'a`: `T` 내의 _모든_ 참조는 라이프타임 `'a`보다 오래 살아야 합니다." #: src/scope/lifetime/lifetime_bounds.md:8 msgid "" "`T: Trait + 'a`: Type `T` must implement trait `Trait` and _all_ references " "in `T` must outlive `'a`." msgstr "" "`T: Trait + 'a`: 타입 `T`는 트레이트 `Trait`를 구현해야 하며, `T` 내의 _모든" "_ 참조는 `'a`보다 오래 살아야 합니다." #: src/scope/lifetime/lifetime_bounds.md:11 msgid "" "The example below shows the above syntax in action used after keyword " "`where`:" msgstr "" "아래 예제는 `where` 키워드 뒤에 사용된 위 구문의 실제 사용 예를 보여줍니다:" #: src/scope/lifetime/lifetime_bounds.md:14 msgid "// Trait to bound with.\n" msgstr "// 바운드할 트레이트.\n" #: src/scope/lifetime/lifetime_bounds.md:17 msgid "" "// `Ref` contains a reference to a generic type `T` that has\n" "// some lifetime `'a` unknown by `Ref`. `T` is bounded such that any\n" "// *references* in `T` must outlive `'a`. Additionally, the lifetime\n" "// of `Ref` may not exceed `'a`.\n" msgstr "" "// `Ref`는 `Ref`가 알 수 없는 어떤 라이프타임 `'a`를 가진 제네릭 타입 `T`에 " "대한\n" "// 참조를 포함합니다. `T`는 `T` 내부의 모든 *참조*가 `'a`보다 오래 살아야 한" "다는\n" "// 바운드를 가집니다. 추가적으로, `Ref`의 라이프타임은 `'a`를 초과할 수 없습" "니다.\n" #: src/scope/lifetime/lifetime_bounds.md:22 msgid "// A generic function which prints using the `Debug` trait.\n" msgstr "// `Debug` 트레이트를 사용하여 출력하는 제네릭 함수.\n" #: src/scope/lifetime/lifetime_bounds.md:26 msgid "\"`print`: t is {:?}\"" msgstr "\"`print`: t는 {:?}입니다\"" #: src/scope/lifetime/lifetime_bounds.md:28 msgid "" "// Here a reference to `T` is taken where `T` implements\n" "// `Debug` and all *references* in `T` outlive `'a`. In\n" "// addition, `'a` must outlive the function.\n" msgstr "" "// 여기서 `T`는 `Debug`를 구현하고 `T`의 모든 *참조*가 `'a`보다 오래 사는\n" "// `T`에 대한 참조를 받습니다. 또한, `'a`는 함수보다 오래 살아야 합니다.\n" #: src/scope/lifetime/lifetime_bounds.md:34 msgid "\"`print_ref`: t is {:?}\"" msgstr "\"`print_ref`: t는 {:?}입니다\"" #: src/scope/lifetime/lifetime_bounds.md:48 msgid "" "[generics](../../generics.md), [bounds in generics](../../generics/" "bounds.md), and [multiple bounds in generics](../../generics/multi_bounds.md)" msgstr "" "[제네릭](../../generics.md), [제네릭의 바운드](../../generics/bounds.md), 그" "리고 [제네릭의 다중 바운드](../../generics/multi_bounds.md)" #: src/scope/lifetime/lifetime_coercion.md:3 msgid "" "A longer lifetime can be coerced into a shorter one so that it works inside " "a scope it normally wouldn't work in. This comes in the form of inferred " "coercion by the Rust compiler, and also in the form of declaring a lifetime " "difference:" msgstr "" "더 긴 라이프타임은 평소에는 작동하지 않을 스코프 내에서도 작동하도록 더 짧은 " "라이프타임으로 강제 변환(coerced)될 수 있습니다. 이는 Rust 컴파일러에 의한 추" "론된 강제 변환 형태와 라이프타임 차이를 선언하는 형태로 나타납니다:" #: src/scope/lifetime/lifetime_coercion.md:9 msgid "" "// Here, Rust infers a lifetime that is as short as possible.\n" "// The two references are then coerced to that lifetime.\n" msgstr "" "// 여기서 Rust는 가능한 한 짧은 라이프타임을 추론합니다.\n" "// 그 후 두 참조는 해당 라이프타임으로 강제 변환됩니다.\n" #: src/scope/lifetime/lifetime_coercion.md:14 msgid "" "// `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`.\n" "// Here, we take in an `&'a i32` and return a `&'b i32` as a result of " "coercion.\n" msgstr "" "// `<'a: 'b, 'b>`는 라이프타임 `'a`가 적어도 `'b`만큼 길다는 뜻으로 읽힙니" "다.\n" "// 여기서 우리는 `&'a i32`를 받아 강제 변환의 결과로 `&'b i32`를 반환합니" "다.\n" #: src/scope/lifetime/lifetime_coercion.md:22 msgid "// Longer lifetime\n" msgstr "// 더 긴 라이프타임\n" #: src/scope/lifetime/lifetime_coercion.md:25 msgid "// Shorter lifetime\n" msgstr "// 더 짧은 라이프타임\n" #: src/scope/lifetime/lifetime_coercion.md:27 msgid "\"The product is {}\"" msgstr "\"곱은 {}입니다\"" #: src/scope/lifetime/lifetime_coercion.md:28 msgid "\"{} is the first\"" msgstr "\"{}은(는) 첫 번째입니다\"" #: src/scope/lifetime/static_lifetime.md:3 msgid "" "Rust has a few reserved lifetime names. One of those is `'static`. You might " "encounter it in two situations:" msgstr "" "Rust에는 몇 가지 예약된 라이프타임 이름이 있습니다. 그중 하나가 `'static`입니" "다. 두 가지 상황에서 이를 마주칠 수 있습니다:" #: src/scope/lifetime/static_lifetime.md:7 msgid "// A reference with 'static lifetime:\n" msgstr "// 'static 라이프타임을 가진 참조:\n" #: src/scope/lifetime/static_lifetime.md:8 msgid "\"hello world\"" msgstr "\"안녕 세상\"" #: src/scope/lifetime/static_lifetime.md:9 msgid "// 'static as part of a trait bound:\n" msgstr "// 트레이트 바운드의 일부로서의 'static:\n" #: src/scope/lifetime/static_lifetime.md:14 msgid "" "Both are related but subtly different and this is a common source for " "confusion when learning Rust. Here are some examples for each situation:" msgstr "" "두 가지는 관련이 있지만 미묘하게 다르며, 이는 Rust를 배울 때 흔한 혼란의 원인" "이 됩니다. 각 상황에 대한 몇 가지 예시를 소개합니다:" #: src/scope/lifetime/static_lifetime.md:17 msgid "Reference lifetime" msgstr "참조 라이프타임" #: src/scope/lifetime/static_lifetime.md:19 msgid "" "As a reference lifetime `'static` indicates that the data pointed to by the " "reference lives for the remaining lifetime of the running program. It can " "still be coerced to a shorter lifetime." msgstr "" "참조 라이프타임으로서 `'static`은 참조가 가리키는 데이터가 실행 중인 프로그램" "의 남은 수명 동안 살아있음을 나타냅니다. 여전히 더 짧은 라이프타임으로 강제 " "변환될 수 있습니다." #: src/scope/lifetime/static_lifetime.md:23 msgid "" "There are two common ways to make a variable with `'static` lifetime, and " "both are stored in the read-only memory of the binary:" msgstr "" "`'static` 라이프타임을 가진 변수를 만드는 두 가지 일반적인 방법이 있으며, 둘 " "다 바이너리의 읽기 전용 메모리에 저장됩니다:" #: src/scope/lifetime/static_lifetime.md:26 msgid "Make a constant with the `static` declaration." msgstr "`static` 선언으로 상수를 만듭니다." #: src/scope/lifetime/static_lifetime.md:27 msgid "Make a `string` literal which has type: `&'static str`." msgstr "`&'static str` 타입을 갖는 `문자열` 리터럴을 만듭니다." #: src/scope/lifetime/static_lifetime.md:29 msgid "See the following example for a display of each method:" msgstr "각 방법에 대한 예제는 다음을 참조하세요:" #: src/scope/lifetime/static_lifetime.md:32 msgid "// Make a constant with `'static` lifetime.\n" msgstr "// `'static` 라이프타임을 가진 상수를 만듭니다.\n" #: src/scope/lifetime/static_lifetime.md:34 msgid "" "// Returns a reference to `NUM` where its `'static`\n" "// lifetime is coerced to that of the input argument.\n" msgstr "" "// `NUM`에 대한 참조를 반환합니다. 여기서 `NUM`의 `'static`\n" "// 라이프타임은 입력 인자의 라이프타임으로 강제 변환됩니다.\n" #: src/scope/lifetime/static_lifetime.md:43 msgid "// Make a `string` literal and print it:\n" msgstr "// `문자열` 리터럴을 만들고 출력합니다:\n" #: src/scope/lifetime/static_lifetime.md:44 msgid "\"I'm in read-only memory\"" msgstr "\"저는 읽기 전용 메모리에 있습니다\"" #: src/scope/lifetime/static_lifetime.md:45 msgid "\"static_string: {}\"" msgstr "\"static_string: {}\"" #: src/scope/lifetime/static_lifetime.md:47 msgid "" "// When `static_string` goes out of scope, the reference\n" " // can no longer be used, but the data remains in the binary.\n" msgstr "" "// `static_string`이 스코프를 벗어나면, 참조는\n" "// 더 이상 사용할 수 없지만, 데이터는 바이너리에 남아 있습니다.\n" #: src/scope/lifetime/static_lifetime.md:52 msgid "// Make an integer to use for `coerce_static`:\n" msgstr "// `coerce_static`에 사용할 정수를 만듭니다:\n" #: src/scope/lifetime/static_lifetime.md:55 msgid "// Coerce `NUM` to lifetime of `lifetime_num`:\n" msgstr "// `NUM`을 `lifetime_num`의 라이프타임으로 강제 변환합니다:\n" #: src/scope/lifetime/static_lifetime.md:58 msgid "\"coerced_static: {}\"" msgstr "\"강제 변환된 static: {}\"" #: src/scope/lifetime/static_lifetime.md:61 msgid "\"NUM: {} stays accessible!\"" msgstr "\"NUM: {} 여전히 접근 가능합니다!\"" #: src/scope/lifetime/static_lifetime.md:65 msgid "" "Since `'static` references only need to be valid for the _remainder_ of a " "program's life, they can be created while the program is executed. Just to " "demonstrate, the below example uses [`Box::leak`](https://doc.rust-lang.org/" "std/boxed/struct.Box.html#method.leak) to dynamically create `'static` " "references. In that case it definitely doesn't live for the entire duration, " "but only from the leaking point onward." msgstr "" "`'static` 참조는 프로그램 수명의 _나머지_ 기간 동안만 유효하면 되므로, 프로그" "램이 실행되는 동안 생성될 수 있습니다. 아래 예제는 [`Box::leak`](https://" "doc.rust-lang.org/std/boxed/struct.Box.html#method.leak)를 사용하여 " "`'static` 참조를 동적으로 생성하는 방법을 보여줍니다. 이 경우 전체 기간 동안 " "살아있는 것은 아니지만, 누수 지점부터는 계속 살아있습니다." #: src/scope/lifetime/static_lifetime.md:90 msgid "Trait bound" msgstr "트레이트 바운드" #: src/scope/lifetime/static_lifetime.md:92 msgid "" "As a trait bound, it means the type does not contain any non-static " "references. Eg. the receiver can hold on to the type for as long as they " "want and it will never become invalid until they drop it." msgstr "" "트레이트 바운드로서, 이는 해당 타입이 정적이지 않은(non-static) 참조를 포함하" "지 않음을 의미합니다. 예를 들어, 수신자는 원하는 만큼 해당 타입을 보유할 수 " "있으며, 드롭할 때까지 절대 유효하지 않게 되지 않습니다." #: src/scope/lifetime/static_lifetime.md:96 msgid "" "It's important to understand this means that any owned data always passes a " "`'static` lifetime bound, but a reference to that owned data generally does " "not:" msgstr "" "이것이 의미하는 바를 이해하는 것이 중요합니다. 모든 소유된 데이터는 항상 " "`'static` 라이프타임 바운드를 통과하지만, 소유된 데이터에 대한 참조는 일반적" "으로 그렇지 않습니다:" #: src/scope/lifetime/static_lifetime.md:104 msgid "\"'static value passed in is: {:?}\"" msgstr "\"'static 값이 전달되었습니다: {:?}\"" #: src/scope/lifetime/static_lifetime.md:108 msgid "// i is owned and contains no references, thus it's 'static:\n" msgstr "// i는 소유된 데이터이며 참조를 포함하지 않으므로 'static입니다:\n" #: src/scope/lifetime/static_lifetime.md:112 msgid "" "// oops, &i only has the lifetime defined by the scope of\n" " // main(), so it's not 'static:\n" msgstr "" "// 이런, &i는 main()의 스코프에 의해 정의된 라이프타임만\n" "// 가지므로 'static이 아닙니다:\n" #: src/scope/lifetime/static_lifetime.md:118 msgid "The compiler will tell you:" msgstr "컴파일러는 다음과 같이 알려줄 것입니다:" #: src/scope/lifetime/static_lifetime.md:135 msgid "[`'static` constants](../../custom_types/constants.md)" msgstr "[`'static` 상수](../../custom_types/constants.md)" #: src/scope/lifetime/elision.md:3 msgid "" "Some lifetime patterns are overwhelmingly common and so the borrow checker " "will allow you to omit them to save typing and to improve readability. This " "is known as elision. Elision exists in Rust solely because these patterns " "are common." msgstr "" "일부 라이프타임 패턴은 압도적으로 흔해서, 빌림 검사기는 타이핑을 줄이고 가독" "성을 높이기 위해 이를 생략할 수 있게 해줍니다. 이를 생략(elision)이라고 합니" "다. 생략은 오직 이러한 패턴이 흔하다는 이유만으로 Rust에 존재합니다." #: src/scope/lifetime/elision.md:8 msgid "" "The following code shows a few examples of elision. For a more comprehensive " "description of elision, see [lifetime elision](https://doc.rust-lang.org/" "book/ch10-03-lifetime-syntax.html#lifetime-elision) in the book." msgstr "" "다음 코드는 생략의 몇 가지 예시를 보여줍니다. 생략에 대한 더 포괄적인 설명은 " "책의 [라이프타임 생략](https://doc.rust-lang.org/book/ch10-03-lifetime-" "syntax.html#lifetime-elision)을 참조하세요." #: src/scope/lifetime/elision.md:12 msgid "" "// `elided_input` and `annotated_input` essentially have identical " "signatures\n" "// because the lifetime of `elided_input` is inferred by the compiler:\n" msgstr "" "// `elided_input`과 `annotated_input`은 본질적으로 동일한 시그니처를 가집니" "다.\n" "// `elided_input`의 라이프타임이 컴파일러에 의해 추론되기 때문입니다:\n" #: src/scope/lifetime/elision.md:15 msgid "\"`elided_input`: {}\"" msgstr "\"`elided_input`: {}\"" #: src/scope/lifetime/elision.md:19 msgid "\"`annotated_input`: {}\"" msgstr "\"`annotated_input`: {}\"" #: src/scope/lifetime/elision.md:21 msgid "" "// Similarly, `elided_pass` and `annotated_pass` have identical signatures\n" "// because the lifetime is added implicitly to `elided_pass`:\n" msgstr "" "// 마찬가지로, `elided_pass`와 `annotated_pass`는 동일한 시그니처를 가집니" "다.\n" "// 라이프타임이 `elided_pass`에 암시적으로 추가되기 때문입니다:\n" #: src/scope/lifetime/elision.md:34 msgid "\"`elided_pass`: {}\"" msgstr "\"`elided_pass`: {}\"" #: src/scope/lifetime/elision.md:35 msgid "\"`annotated_pass`: {}\"" msgstr "\"`annotated_pass`: {}\"" #: src/scope/lifetime/elision.md:41 msgid "" "[elision](https://doc.rust-lang.org/book/ch10-03-lifetime-" "syntax.html#lifetime-elision)" msgstr "" "[생략](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-" "elision)" #: src/trait.md:3 msgid "" "A `trait` is a collection of methods defined for an unknown type: `Self`. " "They can access other methods declared in the same trait." msgstr "" "`trait`는 알 수 없는 타입 `Self`에 대해 정의된 메서드들의 모음입니다. 이들은 " "동일한 트레이트 내에 선언된 다른 메서드에 접근할 수 있습니다." #: src/trait.md:6 msgid "" "Traits can be implemented for any data type. In the example below, we define " "`Animal`, a group of methods. The `Animal` `trait` is then implemented for " "the `Sheep` data type, allowing the use of methods from `Animal` with a " "`Sheep`." msgstr "" "트레이트는 모든 데이터 타입에 대해 구현될 수 있습니다. 아래 예제에서는 메서" "드 그룹인 `Animal`을 정의합니다. 그런 다음 `Animal` `trait`를 `Sheep` 데이터 " "타입에 대해 구현하여 `Sheep`으로 `Animal`의 메서드를 사용할 수 있게 합니다." #: src/trait.md:15 msgid "" "// Associated function signature; `Self` refers to the implementor type.\n" msgstr "// 연관 함수 시그니처; `Self`는 구현하는 타입을 가리킵니다.\n" #: src/trait.md:18 msgid "// Method signatures; these will return a string.\n" msgstr "// 메서드 시그니처; 이들은 문자열을 반환할 것입니다.\n" #: src/trait.md:22 msgid "// Traits can provide default method definitions.\n" msgstr "// 트레이트는 기본 메서드 정의를 제공할 수 있습니다.\n" #: src/trait.md:24 msgid "\"{} says {}\"" msgstr "\"{}가 말하길 {}\"" #: src/trait.md:35 msgid "// Implementor methods can use the implementor's trait methods.\n" msgstr "// 구현자의 메서드는 구현자의 트레이트 메서드를 사용할 수 있습니다.\n" #: src/trait.md:36 msgid "\"{} is already naked...\"" msgstr "\"{}는 이미 벌거벗었습니다...\"" #: src/trait.md:38 msgid "\"{} gets a haircut!\"" msgstr "\"{}가 털을 깎습니다!\"" #: src/trait.md:44 src/trait/dyn.md:25 msgid "// Implement the `Animal` trait for `Sheep`.\n" msgstr "// `Sheep`에 대해 `Animal` 트레이트를 구현합니다.\n" #: src/trait.md:47 msgid "// `Self` is the implementor type: `Sheep`.\n" msgstr "// `Self`는 구현하는 타입인 `Sheep`입니다.\n" #: src/trait.md:58 msgid "\"baaaaah?\"" msgstr "\"메에에에?\"" #: src/trait.md:60 src/trait/dyn.md:29 msgid "\"baaaaah!\"" msgstr "\"메에에에!\"" #: src/trait.md:64 msgid "// Default trait methods can be overridden.\n" msgstr "// 기본 트레이트 메서드는 재정의(오버라이드)될 수 있습니다.\n" #: src/trait.md:66 msgid "// For example, we can add some quiet contemplation.\n" msgstr "// 예를 들어, 조용한 사색을 추가할 수 있습니다.\n" #: src/trait.md:67 msgid "\"{} pauses briefly... {}\"" msgstr "\"{}가 잠시 멈춥니다... {}\"" #: src/trait.md:72 msgid "// Type annotation is necessary in this case.\n" msgstr "// 이 경우에는 타입 어노테이션이 필요합니다.\n" #: src/trait.md:73 msgid "\"Dolly\"" msgstr "\"돌리\"" #: src/trait.md:74 msgid "// TODO ^ Try removing the type annotations.\n" msgstr "// TODO ^ 타입 어노테이션을 제거해 보세요.\n" #: src/trait/derive.md:3 msgid "" "The compiler is capable of providing basic implementations for some traits " "via the `#[derive]` [attribute](../attribute.md). These traits can still be " "manually implemented if a more complex behavior is required." msgstr "" "컴파일러는 `#[derive]` [속성](../attribute.md)을 통해 일부 트레이트에 대한 기" "본적인 구현을 제공할 수 있습니다. 더 복잡한 동작이 필요한 경우에는 이러한 트" "레이트들을 수동으로 구현할 수도 있습니다." #: src/trait/derive.md:7 msgid "The following is a list of derivable traits:" msgstr "다음은 derive 가능한 트레이트 목록입니다:" #: src/trait/derive.md:9 msgid "" "Comparison traits: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), " "[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]" "(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)." msgstr "" "비교 트레이트: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), " "[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]" "(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)." #: src/trait/derive.md:11 msgid "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), to create " "`T` from `&T` via a copy." msgstr "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), 복사를 통해 " "`&T`로부터 `T`를 생성합니다." #: src/trait/derive.md:12 msgid "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), to give a " "type 'copy semantics' instead of 'move semantics'." msgstr "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), 타입에 '이" "동 의미론(move semantics)' 대신 '복사 의미론(copy semantics)'을 부여합니다." #: src/trait/derive.md:13 msgid "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), to compute a " "hash from `&T`." msgstr "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), `&T`로부터 해시" "를 계산합니다." #: src/trait/derive.md:14 msgid "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), to " "create an empty instance of a data type." msgstr "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), 데이" "터 타입의 빈 인스턴스를 생성합니다." #: src/trait/derive.md:15 msgid "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), to format a " "value using the `{:?}` formatter." msgstr "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), `{:?}` 포맷터" "를 사용하여 값을 형식화합니다." #: src/trait/derive.md:18 msgid "// `Centimeters`, a tuple struct that can be compared\n" msgstr "// `Centimeters`, 비교 가능한 튜플 구조체\n" #: src/trait/derive.md:21 msgid "// `Inches`, a tuple struct that can be printed\n" msgstr "// `Inches`, 출력 가능한 튜플 구조체\n" #: src/trait/derive.md:33 msgid "// `Seconds`, a tuple struct with no additional attributes\n" msgstr "// `Seconds`, 추가 속성이 없는 튜플 구조체\n" #: src/trait/derive.md:40 msgid "" "// Error: `Seconds` can't be printed; it doesn't implement the `Debug` " "trait\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러: `Seconds`는 출력될 수 없습니다. `Debug` 트레이트를 구현하지 않았기 " "때문입니다.\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ 이 줄의 주석을 해제해 보세요.\n" #: src/trait/derive.md:44 msgid "" "// Error: `Seconds` can't be compared; it doesn't implement the `PartialEq` " "trait\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러: `Seconds`는 비교될 수 없습니다. `PartialEq` 트레이트를 구현하지 않았" "기 때문입니다.\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ 이 줄의 주석을 해제해 보세요.\n" #: src/trait/derive.md:50 msgid "\"One foot equals {:?}\"" msgstr "\"1피트는 {:?}와 같습니다.\"" #: src/trait/derive.md:56 msgid "\"smaller\"" msgstr "\"더 작습니다\"" #: src/trait/derive.md:58 msgid "\"bigger\"" msgstr "\"더 큽니다\"" #: src/trait/derive.md:61 msgid "\"One foot is {} than one meter.\"" msgstr "\"1피트는 1미터보다 {}.\"" #: src/trait/derive.md:67 msgid "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)" msgstr "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)" #: src/trait/dyn.md:3 msgid "" "The Rust compiler needs to know how much space every function's return type " "requires. This means all your functions have to return a concrete type. " "Unlike other languages, if you have a trait like `Animal`, you can't write a " "function that returns `Animal`, because its different implementations will " "need different amounts of memory." msgstr "" "Rust 컴파일러는 모든 함수의 반환 타입이 얼마나 많은 공간을 필요로 하는지 알아" "야 합니다. 이는 여러분의 모든 함수가 구체적인 타입을 반환해야 함을 의미합니" "다. 다른 언어와 달리, `Animal`과 같은 트레이트가 있을 때 `Animal`을 반환하는 " "함수를 작성할 수 없는데, 그 이유는 서로 다른 구현체들이 서로 다른 양의 메모리" "를 필요로 하기 때문입니다." #: src/trait/dyn.md:8 msgid "" "However, there's an easy workaround. Instead of returning a trait object " "directly, our functions return a `Box` which _contains_ some `Animal`. A " "`box` is just a reference to some memory in the heap. Because a reference " "has a statically-known size, and the compiler can guarantee it points to a " "heap-allocated `Animal`, we can return a trait from our function!" msgstr "" "하지만 쉬운 해결 방법이 있습니다. 트레이트 객체를 직접 반환하는 대신, 우리 함" "수는 어떤 `Animal`을 *포함하는* `Box`를 반환합니다. `Box`는 단지 힙 메모리에 " "대한 참조일 뿐입니다. 참조는 정적으로 알려진 크기를 가지며, 컴파일러는 그것" "이 힙에 할당된 `Animal`을 가리키고 있음을 보장할 수 있으므로, 우리 함수에서 " "트레이트를 반환할 수 있게 됩니다!" #: src/trait/dyn.md:13 msgid "" "Rust tries to be as explicit as possible whenever it allocates memory on the " "heap. So if your function returns a pointer-to-trait-on-heap in this way, " "you need to write the return type with the `dyn` keyword, e.g. `Box`." msgstr "" "Rust는 힙에 메모리를 할당할 때마다 가능한 한 명시적이려고 노력합니다. 따라서 " "여러분의 함수가 이런 방식으로 힙상의 트레이트에 대한 포인터를 반환한다면, 반" "환 타입에 `dyn` 키워드를 사용해야 합니다. 예: `Box`." #: src/trait/dyn.md:22 msgid "// Instance method signature\n" msgstr "// 인스턴스 메서드 시그니처\n" #: src/trait/dyn.md:32 msgid "// Implement the `Animal` trait for `Cow`.\n" msgstr "// `Cow`에 대해 `Animal` 트레이트를 구현합니다.\n" #: src/trait/dyn.md:36 msgid "\"moooooo!\"" msgstr "\"음메~!\"" #: src/trait/dyn.md:39 msgid "" "// Returns some struct that implements Animal, but we don't know which one " "at compile time.\n" msgstr "" "// `Animal`을 구현하는 어떤 구조체를 반환하지만, 컴파일 타임에는 그것이 무엇" "인지 알 수 없습니다.\n" #: src/trait/dyn.md:52 msgid "\"You've randomly chosen an animal, and it says {}\"" msgstr "\"동물을 무작위로 선택했고, 그 동물은 {}라고 말합니다.\"" #: src/trait/ops.md:3 msgid "" "In Rust, many of the operators can be overloaded via traits. That is, some " "operators can be used to accomplish different tasks based on their input " "arguments. This is possible because operators are syntactic sugar for method " "calls. For example, the `+` operator in `a + b` calls the `add` method (as " "in `a.add(b)`). This `add` method is part of the `Add` trait. Hence, the `+` " "operator can be used by any implementor of the `Add` trait." msgstr "" "Rust에서 많은 연산자들은 트레이트를 통해 오버로딩될 수 있습니다. 즉, 일부 연" "산자들은 입력 인자에 따라 서로 다른 작업을 수행하는 데 사용될 수 있습니다. 이" "는 연산자가 메서드 호출의 구문 설탕(syntactic sugar)이기 때문에 가능합니다. " "예를 들어, `a + b`에서의 `+` 연산자는 (`a.add(b)`와 같이) `add` 메서드를 호출" "합니다. 이 `add` 메서드는 `Add` 트레이트의 일부입니다. 따라서 `+` 연산자는 " "`Add` 트레이트의 모든 구현체에서 사용될 수 있습니다." #: src/trait/ops.md:9 msgid "" "A list of the traits, such as `Add`, that overload operators can be found in " "[`core::ops`](https://doc.rust-lang.org/core/ops/)." msgstr "" "연산자를 오버로딩하는 `Add`와 같은 트레이트들의 목록은 [`core::ops`](https://" "doc.rust-lang.org/core/ops/)에서 찾을 수 있습니다." #: src/trait/ops.md:22 msgid "" "// The `std::ops::Add` trait is used to specify the functionality of `+`.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Bar`.\n" "// The following block implements the operation: Foo + Bar = FooBar\n" msgstr "" "// `std::ops::Add` 트레이트는 `+`의 기능을 지정하는 데 사용됩니다.\n" "// 여기서 우리는 `Add`를 만듭니다 - 이는 RHS(우항) 타입이 `Bar`인 덧셈" "을 위한 트레이트입니다.\n" "// 다음 블록은 Foo + Bar = FooBar 연산을 구현합니다.\n" #: src/trait/ops.md:30 msgid "\"> Foo.add(Bar) was called\"" msgstr "\"> Foo.add(Bar)가 호출되었습니다\"" #: src/trait/ops.md:35 msgid "" "// By reversing the types, we end up implementing non-commutative addition.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Foo`.\n" "// This block implements the operation: Bar + Foo = BarFoo\n" msgstr "" "// 타입을 반대로 함으로써, 우리는 비가환(non-commutative) 덧셈을 구현하게 됩" "니다.\n" "// 여기서 우리는 `Add`를 만듭니다 - 이는 RHS 타입이 `Foo`인 덧셈을 위한 " "트레이트입니다.\n" "// 이 블록은 Bar + Foo = BarFoo 연산을 구현합니다.\n" #: src/trait/ops.md:43 msgid "\"> Bar.add(Foo) was called\"" msgstr "\"> Bar.add(Foo)가 호출되었습니다\"" #: src/trait/ops.md:50 msgid "\"Foo + Bar = {:?}\"" msgstr "\"Foo + Bar = {:?}\"" #: src/trait/ops.md:51 msgid "\"Bar + Foo = {:?}\"" msgstr "\"Bar + Foo = {:?}\"" #: src/trait/ops.md:55 src/testing.md:16 src/testing/doc_testing.md:105 #: src/testing/dev_dependencies.md:36 msgid "See Also" msgstr "참고" #: src/trait/ops.md:57 msgid "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [Syntax Index]" "(https://doc.rust-lang.org/book/appendix-02-operators.html)" msgstr "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [구문 색인]" "(https://doc.rust-lang.org/book/appendix-02-operators.html)" #: src/trait/drop.md:3 msgid "" "The [`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) trait only " "has one method: `drop`, which is called automatically when an object goes " "out of scope. The main use of the `Drop` trait is to free the resources that " "the implementor instance owns." msgstr "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) 트레이트는 `drop`" "이라는 하나의 메서드만을 가집니다. 이 메서드는 객체가 스코프를 벗어날 때 자동" "으로 호출됩니다. `Drop` 트레이트의 주요 용도는 구현체 인스턴스가 소유한 리소" "스를 해제하는 것입니다." #: src/trait/drop.md:7 msgid "" "`Box`, `Vec`, `String`, `File`, and `Process` are some examples of types " "that implement the `Drop` trait to free resources. The `Drop` trait can also " "be manually implemented for any custom data type." msgstr "" "`Box`, `Vec`, `String`, `File`, 그리고 `Process`는 리소스를 해제하기 위해 " "`Drop` 트레이트를 구현하는 몇 가지 타입의 예입니다. `Drop` 트레이트는 임의의 " "사용자 정의 데이터 타입에 대해 수동으로 구현될 수도 있습니다." #: src/trait/drop.md:11 msgid "" "The following example adds a print to console to the `drop` function to " "announce when it is called." msgstr "" "다음 예제는 `drop` 함수가 호출될 때 알림을 주기 위해 콘솔 출력을 추가합니다." #: src/trait/drop.md:18 msgid "// This trivial implementation of `drop` adds a print to console.\n" msgstr "// 이 간단한 `drop` 구현은 콘솔에 출력을 추가합니다.\n" #: src/trait/drop.md:22 msgid "\"> Dropping {}\"" msgstr "\"> {}를 해제합니다\"" #: src/trait/drop.md:27 src/std_misc/path.md:33 src/std_misc/fs.md:44 #: src/std_misc/fs.md:87 msgid "\"a\"" msgstr "\"a\"" #: src/trait/drop.md:29 msgid "// block A\n" msgstr "// 블록 A\n" #: src/trait/drop.md:31 src/std_misc/path.md:33 msgid "\"b\"" msgstr "\"b\"" #: src/trait/drop.md:33 msgid "// block B\n" msgstr "// 블록 B\n" #: src/trait/drop.md:35 src/std_misc/path.md:36 msgid "\"c\"" msgstr "\"c\"" #: src/trait/drop.md:36 msgid "\"d\"" msgstr "\"d\"" #: src/trait/drop.md:38 msgid "\"Exiting block B\"" msgstr "\"블록 B를 나가는 중\"" #: src/trait/drop.md:40 msgid "\"Just exited block B\"" msgstr "\"방금 블록 B를 나갔습니다\"" #: src/trait/drop.md:42 msgid "\"Exiting block A\"" msgstr "\"블록 A를 나가는 중\"" #: src/trait/drop.md:44 msgid "\"Just exited block A\"" msgstr "\"방금 블록 A를 나갔습니다\"" #: src/trait/drop.md:46 msgid "// Variable can be manually dropped using the `drop` function\n" msgstr "// 변수는 `drop` 함수를 사용하여 수동으로 해제할 수 있습니다.\n" #: src/trait/drop.md:48 msgid "// TODO ^ Try commenting this line\n" msgstr "// TODO ^ 이 줄을 주석 처리해 보세요.\n" #: src/trait/drop.md:50 msgid "\"end of the main function\"" msgstr "\"메인 함수 끝\"" #: src/trait/drop.md:52 msgid "" "// `_a` *won't* be `drop`ed again here, because it already has been\n" " // (manually) `drop`ed\n" msgstr "" "// `_a`는 여기서 다시 `drop`되지 않습니다. 이미 (수동으로) `drop`되었기 때문" "입니다.\n" #: src/trait/drop.md:57 msgid "" "For a more practical example, here's how the `Drop` trait can be used to " "automatically clean up temporary files when they're no longer needed:" msgstr "" "더 실용적인 예로, `Drop` 트레이트를 사용하여 더 이상 필요하지 않은 임시 파일" "을 자동으로 정리하는 방법은 다음과 같습니다:" #: src/trait/drop.md:71 msgid "// Note: File::create() will overwrite existing files\n" msgstr "// 참고: `File::create()`는 기존 파일을 덮어씁니다.\n" #: src/trait/drop.md:77 msgid "" "// When TempFile is dropped:\n" "// 1. First, our drop implementation will remove the file's name from the " "filesystem.\n" "// 2. Then, File's drop will close the file, removing its underlying content " "from the disk.\n" msgstr "" "// `TempFile`이 drop될 때:\n" "// 1. 먼저, 우리가 작성한 drop 구현이 파일 시스템에서 파일 이름을 제거합니" "다.\n" "// 2. 그런 다음, `File`의 drop이 파일을 닫고 디스크에서 기본 콘텐츠를 제거합" "니다.\n" #: src/trait/drop.md:84 msgid "\"Failed to remove temporary file: {}\"" msgstr "\"임시 파일을 제거하는 데 실패했습니다: {}\"" #: src/trait/drop.md:86 msgid "\"> Dropped temporary file: {:?}\"" msgstr "\"> 임시 파일을 해제했습니다: {:?}\"" #: src/trait/drop.md:87 msgid "" "// File's drop is implicitly called here because it is a field of this " "struct.\n" msgstr "" "// `File`의 drop은 이 구조체의 필드이므로 여기서 암시적으로 호출됩니다.\n" #: src/trait/drop.md:92 msgid "// Create a new scope to demonstrate drop behavior\n" msgstr "// drop 동작을 시연하기 위해 새 스코프를 생성합니다.\n" #: src/trait/drop.md:94 msgid "\"test.txt\"" msgstr "\"test.txt\"" #: src/trait/drop.md:95 msgid "\"Temporary file created\"" msgstr "\"임시 파일이 생성되었습니다\"" #: src/trait/drop.md:96 msgid "// File will be automatically cleaned up when temp goes out of scope\n" msgstr "// `temp`가 스코프를 벗어날 때 파일이 자동으로 정리됩니다.\n" #: src/trait/drop.md:98 msgid "\"End of scope - file should be cleaned up\"" msgstr "\"스코프 종료 - 파일이 정리되어야 합니다\"" #: src/trait/drop.md:100 msgid "// We can also manually drop if needed\n" msgstr "// 필요하다면 수동으로 drop할 수도 있습니다.\n" #: src/trait/drop.md:101 msgid "\"another_test.txt\"" msgstr "\"another_test.txt\"" #: src/trait/drop.md:102 msgid "// Explicitly drop the file\n" msgstr "// 파일을 명시적으로 drop합니다.\n" #: src/trait/drop.md:103 msgid "\"Manually dropped file\"" msgstr "\"수동으로 파일을 drop했습니다\"" #: src/trait/iter.md:3 msgid "" "The [`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "trait is used to implement iterators over collections such as arrays." msgstr "" "[`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) 트레이" "트는 배열과 같은 컬렉션에 대한 이터레이터를 구현하는 데 사용됩니다." #: src/trait/iter.md:6 msgid "" "The trait requires only a method to be defined for the `next` element, which " "may be manually defined in an `impl` block or automatically defined (as in " "arrays and ranges)." msgstr "" "이 트레이트는 `next` 요소에 대해 정의될 메서드 하나만을 필요로 하며, 이는 " "`impl` 블록에서 수동으로 정의하거나 (배열 및 범위와 같이) 자동으로 정의될 수 " "있습니다." #: src/trait/iter.md:10 msgid "" "As a point of convenience for common situations, the `for` construct turns " "some collections into iterators using the [`.into_iter()`](https://doc.rust-" "lang.org/std/iter/trait.IntoIterator.html) method." msgstr "" "일반적인 상황에서의 편의를 위해, `for` 구문은 [`.into_iter()`](https://" "doc.rust-lang.org/std/iter/trait.IntoIterator.html) 메서드를 사용하여 일부 컬" "렉션을 이터레이터로 변환합니다." #: src/trait/iter.md:18 msgid "" "// Implement `Iterator` for `Fibonacci`.\n" "// The `Iterator` trait only requires a method to be defined for the `next` " "element,\n" "// and an `associated type` to declare the return type of the iterator.\n" msgstr "" "// `Fibonacci`에 대해 `Iterator`를 구현합니다.\n" "// `Iterator` 트레이트는 `next` 요소에 대해 정의될 메서드 하나와,\n" "// 이터레이터의 반환 타입을 선언하기 위한 `연관 타입(associated type)`만을 필" "요로 합니다.\n" #: src/trait/iter.md:23 msgid "// We can refer to this type using Self::Item\n" msgstr "// `Self::Item`을 사용하여 이 타입을 참조할 수 있습니다.\n" #: src/trait/iter.md:26 msgid "" "// Here, we define the sequence using `.curr` and `.next`.\n" " // The return type is `Option`:\n" " // * When the `Iterator` is finished, `None` is returned.\n" " // * Otherwise, the next value is wrapped in `Some` and returned.\n" " // We use Self::Item in the return type, so we can change\n" " // the type without having to update the function signatures.\n" msgstr "" "// 여기서리는 `.curr`와 `.next`를 사용하여 수열을 정의합니다.\n" " // 반환 타입은 `Option`입니다:\n" " // * 이터레이터가 끝나면 `None`이 반환됩니다.\n" " // * 그렇지 않으면 다음 값이 `Some`으로 감싸져서 반환됩니다.\n" " // 반환 타입에 `Self::Item`을 사용하므로, 함수 시그니처를 업데이트할 필" "요 없이\n" " // 타입을 변경할 수 있습니다.\n" #: src/trait/iter.md:38 msgid "" "// Since there's no endpoint to a Fibonacci sequence, the `Iterator`\n" " // will never return `None`, and `Some` is always returned.\n" msgstr "" "// 피보나치 수열에는 끝이 없으므로, 이 `Iterator`는\n" " // 결코 `None`을 반환하지 않으며 항상 `Some`이 반환됩니다.\n" #: src/trait/iter.md:43 msgid "// Returns a Fibonacci sequence generator\n" msgstr "// 피보나치 수열 생성기를 반환합니다.\n" #: src/trait/iter.md:50 msgid "// `0..3` is an `Iterator` that generates: 0, 1, and 2.\n" msgstr "// `0..3`은 0, 1, 2를 생성하는 `Iterator`입니다.\n" #: src/trait/iter.md:53 msgid "\"Four consecutive `next` calls on 0..3\"" msgstr "\"0..3에 대한 네 번의 연속적인 `next` 호출\"" #: src/trait/iter.md:54 src/trait/iter.md:55 src/trait/iter.md:56 #: src/trait/iter.md:57 src/std_misc/fs.md:90 msgid "\"> {:?}\"" msgstr "\"> {:?}\"" #: src/trait/iter.md:59 msgid "" "// `for` works through an `Iterator` until it returns `None`.\n" " // Each `Some` value is unwrapped and bound to a variable (here, `i`).\n" msgstr "" "// `for`는 `None`이 반환될 때까지 `Iterator`를 통해 작동합니다.\n" " // 각 `Some` 값은 래핑이 해제되어 변수(여기서는 `i`)에 바인딩됩니다.\n" #: src/trait/iter.md:61 msgid "\"Iterate through 0..3 using `for`\"" msgstr "\"`for`를 사용하여 0..3을 순회합니다\"" #: src/trait/iter.md:63 src/trait/iter.md:69 src/trait/iter.md:75 #: src/trait/iter.md:83 src/std/vec.md:50 src/std/str.md:22 #: src/std_misc/fs.md:82 msgid "\"> {}\"" msgstr "\"> {}\"" #: src/trait/iter.md:66 msgid "// The `take(n)` method reduces an `Iterator` to its first `n` terms.\n" msgstr "// `take(n)` 메서드는 `Iterator`를 처음 `n`개의 항으로 줄입니다.\n" #: src/trait/iter.md:67 msgid "\"The first four terms of the Fibonacci sequence are: \"" msgstr "\"피보나치 수열의 처음 네 항은 다음과 같습니다: \"" #: src/trait/iter.md:72 msgid "" "// The `skip(n)` method shortens an `Iterator` by dropping its first `n` " "terms.\n" msgstr "" "// `skip(n)` 메서드는 처음 `n`개의 항을 버리고 `Iterator`를 단축시킵니다.\n" #: src/trait/iter.md:73 msgid "\"The next four terms of the Fibonacci sequence are: \"" msgstr "\"피보나치 수열의 다음 네 항은 다음과 같습니다: \"" #: src/trait/iter.md:80 msgid "// The `iter` method produces an `Iterator` over an array/slice.\n" msgstr "// `iter` 메서드는 배열/슬라이스에 대한 `Iterator`를 생성합니다.\n" #: src/trait/iter.md:81 msgid "\"Iterate the following array {:?}\"" msgstr "\"다음 배열 {:?}을 순회합니다\"" #: src/trait/impl_trait.md:3 msgid "`impl Trait` can be used in two locations:" msgstr "`impl Trait`는 두 위치에서 사용될 수 있습니다:" #: src/trait/impl_trait.md:5 msgid "as an argument type" msgstr "인자 타입으로서" #: src/trait/impl_trait.md:6 msgid "as a return type" msgstr "반환 타입으로서" #: src/trait/impl_trait.md:8 msgid "As an argument type" msgstr "인자 타입으로서" #: src/trait/impl_trait.md:10 msgid "" "If your function is generic over a trait but you don't mind the specific " "type, you can simplify the function declaration using `impl Trait` as the " "type of the argument." msgstr "" "함수가 트레이트에 대해 제네릭이지만 구체적인 타입에는 관심이 없다면, 인자 타" "입으로 `impl Trait`를 사용하여 함수 선언을 단순화할 수 있습니다." #: src/trait/impl_trait.md:12 msgid "For example, consider the following code:" msgstr "예를 들어, 다음 코드를 살펴보세요:" #: src/trait/impl_trait.md:18 src/trait/impl_trait.md:37 msgid "// For each line in the source\n" msgstr "// 소스의 각 줄에 대해\n" #: src/trait/impl_trait.md:20 src/trait/impl_trait.md:39 msgid "" "// If the line was read successfully, process it, if not, return the error\n" msgstr "" "// 줄을 성공적으로 읽었다면 처리하고, 그렇지 않으면 에러를 반환합니다\n" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 src/std/str.md:41 msgid "','" msgstr "','" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 msgid "// Split the line separated by commas\n" msgstr "// 콤마로 구분된 줄을 분할합니다\n" #: src/trait/impl_trait.md:22 src/trait/impl_trait.md:41 msgid "// Remove leading and trailing whitespace\n" msgstr "// 앞뒤 공백을 제거합니다\n" #: src/trait/impl_trait.md:23 src/trait/impl_trait.md:42 msgid "// Collect all strings in a row into a Vec\n" msgstr "// 한 행의 모든 문자열을 `Vec`으로 수집합니다\n" #: src/trait/impl_trait.md:26 src/trait/impl_trait.md:45 msgid "// Collect all lines into a Vec>\n" msgstr "// 모든 줄을 `Vec>`으로 수집합니다\n" #: src/trait/impl_trait.md:30 msgid "" "`parse_csv_document` is generic, allowing it to take any type which " "implements BufRead, such as `BufReader` or `[u8]`, but it's not " "important what type `R` is, and `R` is only used to declare the type of " "`src`, so the function can also be written as:" msgstr "" "`parse_csv_document`는 제네릭이어서 `BufReader`이나 `[u8]`과 같이 " "`BufRead`를 구현하는 모든 타입을 취할 수 있지만, `R`이 어떤 타입인지는 중요하" "지 않고 `R`은 단지 `src`의 타입을 선언하는 데만 사용되므로, 다음과 같이 작성" "할 수도 있습니다:" #: src/trait/impl_trait.md:49 msgid "" "Note that using `impl Trait` as an argument type means that you cannot " "explicitly state what form of the function you use, i.e. " "`parse_csv_document::(std::io::empty())` will not work with " "the second example." msgstr "" "`impl Trait`를 인자 타입으로 사용하는 것은 여러분이 함수의 어떤 형태를 사용하" "는지 명시적으로 명시할 수 없음을 의미합니다. 즉, `parse_csv_document::" "(std::io::empty())`는 두 번째 예제에서 작동하지 않습니다." #: src/trait/impl_trait.md:51 msgid "As a return type" msgstr "반환 타입으로서" #: src/trait/impl_trait.md:53 msgid "" "If your function returns a type that implements `MyTrait`, you can write its " "return type as `-> impl MyTrait`. This can help simplify your type " "signatures quite a lot!" msgstr "" "여러분의 함수가 `MyTrait`를 구현하는 타입을 반환한다면, 반환 타입을 `-> impl " "MyTrait`로 작성할 수 있습니다. 이는 타입 시그니처를 아주 많이 단순화하는 데 " "도움이 될 수 있습니다!" #: src/trait/impl_trait.md:59 msgid "" "// This function combines two `Vec` and returns an iterator over it.\n" "// Look how complicated its return type is!\n" msgstr "" "// 이 함수는 두 개의 `Vec`를 결합하고 그에 대한 이터레이터를 반환합니" "다.\n" "// 반환 타입이 얼마나 복잡한지 보세요!\n" #: src/trait/impl_trait.md:68 msgid "" "// This is the exact same function, but its return type uses `impl Trait`.\n" "// Look how much simpler it is!\n" msgstr "" "// 이것은 정확히 동일한 함수이지만, 반환 타입에 `impl Trait`를 사용합니다.\n" "// 훨씬 더 간단해진 것을 보세요!\n" #: src/trait/impl_trait.md:87 msgid "\"all done\"" msgstr "\"모두 완료\"" #: src/trait/impl_trait.md:91 msgid "" "More importantly, some Rust types can't be written out. For example, every " "closure has its own unnamed concrete type. Before `impl Trait` syntax, you " "had to allocate on the heap in order to return a closure. But now you can do " "it all statically, like this:" msgstr "" "더 중요한 점은, 일부 Rust 타입은 명시적으로 작성할 수 없다는 것입니다. 예를 " "들어, 모든 클로저는 자신만의 이름 없는 구체적인 타입을 가집니다. `impl " "Trait` 구문이 생기기 전에는 클로저를 반환하기 위해 힙에 할당해야만 했습니다. " "하지만 이제는 다음과 같이 정적으로 처리할 수 있습니다:" #: src/trait/impl_trait.md:97 msgid "// Returns a function that adds `y` to its input\n" msgstr "// 입력에 `y`를 더하는 함수를 반환합니다.\n" #: src/trait/impl_trait.md:109 msgid "" "You can also use `impl Trait` to return an iterator that uses `map` or " "`filter` closures! This makes using `map` and `filter` easier. Because " "closure types don't have names, you can't write out an explicit return type " "if your function returns iterators with closures. But with `impl Trait` you " "can do this easily:" msgstr "" "또한 `impl Trait`를 사용하여 `map`이나 `filter` 클로저를 사용하는 이터레이터" "를 반환할 수도 있습니다! 이는 `map`과 `filter`를 더 쉽게 사용할 수 있게 해줍" "니다. 클로저 타입은 이름이 없기 때문에, 함수가 클로저를 포함하는 이터레이터" "를 반환할 경우 명시적인 반환 타입을 작성할 수 없습니다. 하지만 `impl Trait`" "를 사용하면 이를 쉽게 할 수 있습니다:" #: src/trait/clone.md:3 msgid "" "When dealing with resources, the default behavior is to transfer them during " "assignments or function calls. However, sometimes we need to make a copy of " "the resource as well." msgstr "" "리소스를 다룰 때, 기본 동작은 할당이나 함수 호출 시 리소스를 이전(transfer)하" "는 것입니다. 하지만 때로는 리소스의 복사본을 만들어야 할 때도 있습니다." #: src/trait/clone.md:7 msgid "" "The [`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) trait " "helps us do exactly this. Most commonly, we can use the `.clone()` method " "defined by the `Clone` trait." msgstr "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) 트레이트는 바" "로 이런 일을 돕습니다. 가장 일반적으로, `Clone` 트레이트에 정의된 `.clone()` " "메서드를 사용할 수 있습니다." #: src/trait/clone.md:11 msgid "// A unit struct without resources\n" msgstr "// 리소스가 없는 유닛 구조체\n" #: src/trait/clone.md:14 msgid "// A tuple struct with resources that implements the `Clone` trait\n" msgstr "// `Clone` 트레이트를 구현하는 리소스가 있는 튜플 구조체\n" #: src/trait/clone.md:20 msgid "// Instantiate `Unit`\n" msgstr "// `Unit`을 인스턴스화합니다\n" #: src/trait/clone.md:22 msgid "// Copy `Unit`, there are no resources to move\n" msgstr "// `Unit`을 복사합니다. 이동할 리소스가 없습니다.\n" #: src/trait/clone.md:25 msgid "// Both `Unit`s can be used independently\n" msgstr "// 두 `Unit` 모두 독립적으로 사용될 수 있습니다.\n" #: src/trait/clone.md:26 src/trait/clone.md:31 msgid "\"original: {:?}\"" msgstr "\"원본: {:?}\"" #: src/trait/clone.md:27 msgid "\"copy: {:?}\"" msgstr "\"복사본: {:?}\"" #: src/trait/clone.md:29 msgid "// Instantiate `Pair`\n" msgstr "// `Pair`를 인스턴스화합니다\n" #: src/trait/clone.md:33 msgid "// Move `pair` into `moved_pair`, moves resources\n" msgstr "// `pair`를 `moved_pair`로 이동합니다. 리소스가 이동됩니다.\n" #: src/trait/clone.md:35 msgid "\"moved: {:?}\"" msgstr "\"이동됨: {:?}\"" #: src/trait/clone.md:37 msgid "" "// Error! `pair` has lost its resources\n" " //println!(\"original: {:?}\", pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `pair`는 리소스를 잃었습니다\n" " //println!(\"original: {:?}\", pair);\n" " // TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/trait/clone.md:41 msgid "// Clone `moved_pair` into `cloned_pair` (resources are included)\n" msgstr "// `moved_pair`를 `cloned_pair`로 클론합니다(리소스가 포함됩니다)\n" #: src/trait/clone.md:43 msgid "// Drop the moved original pair using std::mem::drop\n" msgstr "// `std::mem::drop`을 사용하여 이동된 원본 페어를 해제합니다\n" #: src/trait/clone.md:46 msgid "" "// Error! `moved_pair` has been dropped\n" " //println!(\"moved and dropped: {:?}\", moved_pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `moved_pair`가 해제되었습니다\n" " //println!(\"moved and dropped: {:?}\", moved_pair);\n" " // TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/trait/clone.md:50 msgid "// The result from .clone() can still be used!\n" msgstr "// `.clone()`의 결과는 여전히 사용될 수 있습니다!\n" #: src/trait/clone.md:51 msgid "\"clone: {:?}\"" msgstr "\"클론: {:?}\"" #: src/trait/supertraits.md:3 msgid "" "Rust doesn't have \"inheritance\", but you can define a trait as being a " "superset of another trait. For example:" msgstr "" "Rust에는 \"상속\"이 없지만, 한 트레이트를 다른 트레이트의 슈퍼셋(superset)으" "로 정의할 수 있습니다. 예를 들어:" #: src/trait/supertraits.md:10 msgid "" "// Person is a supertrait of Student.\n" "// Implementing Student requires you to also impl Person.\n" msgstr "" "// Person은 Student의 슈퍼트레이트입니다.\n" "// Student를 구현하려면 Person도 구현해야 합니다.\n" #: src/trait/supertraits.md:20 msgid "" "// CompSciStudent (computer science student) is a subtrait of both " "Programmer\n" "// and Student. Implementing CompSciStudent requires you to impl both " "supertraits.\n" msgstr "" "// CompSciStudent(컴퓨터 공학 학생)는 Programmer와 Student 모두의 서브트레이" "트입니다.\n" "// CompSciStudent를 구현하려면 두 슈퍼트레이트를 모두 구현해야 합니다.\n" #: src/trait/supertraits.md:29 msgid "" "\"My name is {} and I attend {}. My favorite language is {}. My Git username " "is {}\"" msgstr "" "\"제 이름은 {}이고 {}에 다닙니다. 제가 가장 좋아하는 언어는 {}입니다. 제 Git " "사용자 이름은 {}입니다.\"" #: src/trait/supertraits.md:42 msgid "" "[The Rust Programming Language chapter on supertraits](https://doc.rust-" "lang.org/book/ch19-03-advanced-traits.html#using-supertraits-to-require-one-" "traits-functionality-within-another-trait)" msgstr "" "[러스트 프로그래밍 언어의 슈퍼트레이트 장](https://doc.rust-lang.org/book/" "ch19-03-advanced-traits.html#using-supertraits-to-require-one-traits-" "functionality-within-another-trait)" #: src/trait/disambiguating.md:3 msgid "" "A type can implement many different traits. What if two traits both require " "the same name for a function? For example, many traits might have a method " "named `get()`. They might even have different return types!" msgstr "" "하나의 타입은 여러 개의 서로 다른 트레이트를 구현할 수 있습니다. 만약 두 트레" "이트가 함수에 대해 동일한 이름을 요구한다면 어떨까요? 예를 들어, 많은 트레이" "트가 `get()`이라는 이름의 메서드를 가질 수 있습니다. 심지어 반환 타입이 다를 " "수도 있습니다!" #: src/trait/disambiguating.md:7 msgid "" "Good news: because each trait implementation gets its own `impl` block, it's " "clear which trait's `get` method you're implementing." msgstr "" "좋은 소식은, 각 트레이트 구현이 자신만의 `impl` 블록을 가지기 때문에, 어떤 트" "레이트의 `get` 메서드를 구현하고 있는지 명확하다는 것입니다." #: src/trait/disambiguating.md:10 msgid "" "What about when it comes time to _call_ those methods? To disambiguate " "between them, we have to use Fully Qualified Syntax." msgstr "" "그럼 그 메서드들을 *호출*해야 할 때는 어떨까요? 이들 사이의 모호함을 없애기 " "위해, 우리는 '완전한 정규화 구문(Fully Qualified Syntax)'을 사용해야 합니다." #: src/trait/disambiguating.md:15 msgid "// Get the selected username out of this widget\n" msgstr "// 이 위젯에서 선택된 사용자 이름을 가져옵니다\n" #: src/trait/disambiguating.md:20 msgid "// Get the selected age out of this widget\n" msgstr "// 이 위젯에서 선택된 나이를 가져옵니다\n" #: src/trait/disambiguating.md:23 msgid "// A form with both a UsernameWidget and an AgeWidget\n" msgstr "// UsernameWidget과 AgeWidget을 모두 포함하는 폼\n" #: src/trait/disambiguating.md:44 src/trait/disambiguating.md:54 msgid "\"rustacean\"" msgstr "\"러스타시안(rustacean)\"" #: src/trait/disambiguating.md:48 msgid "" "// If you uncomment this line, you'll get an error saying\n" " // \"multiple `get` found\". Because, after all, there are multiple " "methods\n" " // named `get`.\n" " // println!(\"{}\", form.get());\n" msgstr "" "// 이 줄의 주석을 해제하면 \"multiple `get` found\"라는 에러가 발생합니다.\n" " // 결국 `get`이라는 이름의 메서드가 여러 개 있기 때문입니다.\n" " // println!(\"{}\", form.get());\n" #: src/trait/disambiguating.md:62 msgid "" "[The Rust Programming Language chapter on Fully Qualified syntax](https://" "doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-" "for-disambiguation-calling-methods-with-the-same-name)" msgstr "" "[러스트 프로그래밍 언어의 완전한 정규화 구문 장](https://doc.rust-lang.org/" "book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-" "calling-methods-with-the-same-name)" #: src/macros.md:1 msgid "`macro_rules!`" msgstr "`macro_rules!`" #: src/macros.md:3 msgid "" "Rust provides a powerful macro system that allows metaprogramming. As you've " "seen in previous chapters, macros look like functions, except that their " "name ends with a bang `!`, but instead of generating a function call, macros " "are expanded into source code that gets compiled with the rest of the " "program. However, unlike macros in C and other languages, Rust macros are " "expanded into abstract syntax trees, rather than string preprocessing, so " "you don't get unexpected precedence bugs." msgstr "" "Rust는 메타프로그래밍을 가능하게 하는 강력한 매크로 시스템을 제공합니다. 이" "전 장들에서 보았듯이, 매크로는 이름이 느낌표 `!`로 끝난다는 점을 제외하면 함" "수와 비슷해 보입니다. 하지만 함수 호출을 생성하는 대신, 매크로는 프로그램의 " "나머지 부분과 함께 컴파일되는 소스 코드로 확장됩니다. 그러나 C나 다른 언어의 " "매크로와 달리, Rust 매크로는 문자열 전처리가 아닌 추상 구문 트리(AST)로 확장" "되므로, 예상치 못한 연산자 우선순위 버그가 발생하지 않습니다." #: src/macros.md:11 msgid "Macros are created using the `macro_rules!` macro." msgstr "매크로는 `macro_rules!` 매크로를 사용하여 생성됩니다." #: src/macros.md:14 msgid "// This is a simple macro named `say_hello`.\n" msgstr "// `say_hello`라는 이름의 간단한 매크로입니다.\n" #: src/macros.md:16 msgid "// `()` indicates that the macro takes no argument.\n" msgstr "// `()`는 매크로가 인자를 취하지 않음을 나타냅니다.\n" #: src/macros.md:18 msgid "// The macro will expand into the contents of this block.\n" msgstr "// 매크로는 이 블록의 내용으로 확장됩니다.\n" #: src/macros.md:19 msgid "\"Hello!\"" msgstr "\"안녕하세요!\"" #: src/macros.md:24 msgid "// This call will expand into `println!(\"Hello!\")`\n" msgstr "// 이 호출은 `println!(\"안녕하세요!\")`로 확장됩니다.\n" #: src/macros.md:29 msgid "So why are macros useful?" msgstr "그렇다면 왜 매크로가 유용할까요?" #: src/macros.md:31 msgid "" "Don't repeat yourself. There are many cases where you may need similar " "functionality in multiple places but with different types. Often, writing a " "macro is a useful way to avoid repeating code. (More on this later)" msgstr "" "반복하지 마세요(DRY, Don't repeat yourself). 여러 곳에서 서로 다른 타입에 대" "해 유사한 기능이 필요할 수 있는 경우가 많습니다. 종종 매크로를 작성하는 것은 " "코드 반복을 피하는 유용한 방법입니다. (이에 대해서는 나중에 자세히 다룹니다)" #: src/macros.md:35 msgid "" "Domain-specific languages. Macros allow you to define special syntax for a " "specific purpose. (More on this later)" msgstr "" "도메인 특화 언어(DSL, Domain-specific languages). 매크로를 사용하면 특정 목적" "을 위한 특정 구문을 정의할 수 있습니다. (이에 대해서는 나중에 자세히 다룹니" "다)" #: src/macros.md:38 msgid "" "Variadic interfaces. Sometimes you want to define an interface that takes a " "variable number of arguments. An example is `println!` which could take any " "number of arguments, depending on the format string. (More on this later)" msgstr "" "가변 인자 인터페이스. 때로는 가변적인 개수의 인자를 취하는 인터페이스를 정의" "하고 싶을 때가 있습니다. 예를 들어 `println!`은 형식 문자열에 따라 인자를 몇 " "개든 취할 수 있습니다! (이에 대해서는 나중에 자세히 다룹니다)" #: src/macros/syntax.md:3 msgid "" "In following subsections, we will show how to define macros in Rust. There " "are three basic ideas:" msgstr "" "이어지는 하위 섹션에서는 Rust에서 매크로를 정의하는 방법을 보여줄 것입니다. " "여기에는 세 가지 기본 아이디어가 있습니다:" #: src/macros/syntax.md:6 msgid "[Patterns and Designators](designators.md)" msgstr "[패턴과 지시자](designators.md)" #: src/macros/syntax.md:7 msgid "[Overloading](overload.md)" msgstr "[오버로딩](overload.md)" #: src/macros/syntax.md:8 msgid "[Repetition](repeat.md)" msgstr "[반복](repeat.md)" #: src/macros/designators.md:3 msgid "" "The arguments of a macro are prefixed by a dollar sign `$` and type " "annotated with a _designator_:" msgstr "" "매크로의 인자는 달러 기호 `$`가 접두사로 붙으며, 지시자(designator)로 타입이 " "어노테이션됩니다:" #: src/macros/designators.md:8 msgid "" "// This macro takes an argument of designator `ident` and\n" " // creates a function named `$func_name`.\n" " // The `ident` designator is used for variable/function names.\n" msgstr "" "// 이 매크로는 지시자 `ident` 인자를 취하여\n" " // `$func_name`이라는 이름의 함수를 생성합니다.\n" " // `ident` 지시자는 변수/함수 이름에 사용됩니다.\n" #: src/macros/designators.md:13 msgid "// The `stringify!` macro converts an `ident` into a string.\n" msgstr "// `stringify!` 매크로는 `ident`를 문자열로 변환합니다.\n" #: src/macros/designators.md:14 msgid "\"You called {:?}()\"" msgstr "\"당신은 {:?}()를 호출했습니다\"" #: src/macros/designators.md:19 msgid "// Create functions named `foo` and `bar` with the above macro.\n" msgstr "" "// 위의 매크로를 사용하여 `foo`와 `bar`라는 이름의 함수를 생성합니다.\n" #: src/macros/designators.md:25 msgid "" "// This macro takes an expression of type `expr` and prints\n" " // it as a string along with its result.\n" " // The `expr` designator is used for expressions.\n" msgstr "" "// 이 매크로는 `expr` 타입의 표현식을 취하여\n" " // 결과와 함께 문자열로 출력합니다.\n" " // `expr` 지시자는 표현식에 사용됩니다.\n" #: src/macros/designators.md:29 msgid "// `stringify!` will convert the expression *as it is* into a string.\n" msgstr "// `stringify!`는 표현식을 *있는 그대로* 문자열로 변환합니다.\n" #: src/macros/designators.md:30 msgid "\"{:?} = {:?}\"" msgstr "\"{:?} = {:?}\"" #: src/macros/designators.md:42 msgid "// Recall that blocks are expressions too!\n" msgstr "// 블록도 표현식이라는 점을 기억하세요!\n" #: src/macros/designators.md:51 msgid "These are some of the available designators:" msgstr "사용 가능한 지시자들의 일부는 다음과 같습니다:" #: src/macros/designators.md:53 msgid "`block`" msgstr "`block`" #: src/macros/designators.md:54 msgid "`expr` is used for expressions" msgstr "`expr`은 표현식에 사용됩니다" #: src/macros/designators.md:55 msgid "`ident` is used for variable/function names" msgstr "`ident`는 변수/함수 이름에 사용됩니다" #: src/macros/designators.md:56 msgid "`item`" msgstr "`item`" #: src/macros/designators.md:57 msgid "`literal` is used for literal constants" msgstr "`literal`은 리터럴 상수에 사용됩니다" #: src/macros/designators.md:58 msgid "`pat` (_pattern_)" msgstr "`pat` (패턴)" #: src/macros/designators.md:59 msgid "`path`" msgstr "`path`" #: src/macros/designators.md:60 msgid "`stmt` (_statement_)" msgstr "`stmt` (문장)" #: src/macros/designators.md:61 msgid "`tt` (_token tree_)" msgstr "`tt` (토큰 트리)" #: src/macros/designators.md:62 msgid "`ty` (_type_)" msgstr "`ty` (타입)" #: src/macros/designators.md:63 msgid "`vis` (_visibility qualifier_)" msgstr "`vis` (가시성 한정자)" #: src/macros/designators.md:65 msgid "" "For a complete list, see the [Rust Reference](https://doc.rust-lang.org/" "reference/macros-by-example.html)." msgstr "" "전체 목록은 [Rust 레퍼런스](https://doc.rust-lang.org/reference/macros-by-" "example.html)를 참조하세요." #: src/macros/overload.md:3 msgid "" "Macros can be overloaded to accept different combinations of arguments. In " "that regard, `macro_rules!` can work similarly to a match block:" msgstr "" "매크로는 서로 다른 인자 조합을 수용하도록 오버로딩될 수 있습니다. 그런 점에서" "는 `macro_rules!`는 `match` 블록과 비슷하게 작동할 수 있습니다:" #: src/macros/overload.md:7 msgid "" "// `test!` will compare `$left` and `$right`\n" "// in different ways depending on how you invoke it:\n" msgstr "" "// `test!`는 호출 방식에 따라 `$left`와 `$right`를\n" "// 서로 다른 방식으로 비교할 것입니다:\n" #: src/macros/overload.md:10 msgid "" "// Arguments don't need to be separated by a comma.\n" " // Any template can be used!\n" msgstr "" "// 인자들은 콤마로 구분될 필요가 없습니다.\n" " // 어떤 템플릿이든 사용될 수 있습니다!\n" #: src/macros/overload.md:13 msgid "\"{:?} and {:?} is {:?}\"" msgstr "\"{:?} and {:?} is {:?}\"" #: src/macros/overload.md:18 msgid "// ^ each arm must end with a semicolon.\n" msgstr "// ^ 각 팔(arm)은 세미콜론으로 끝나야 합니다.\n" #: src/macros/overload.md:20 msgid "\"{:?} or {:?} is {:?}\"" msgstr "\"{:?} or {:?} is {:?}\"" #: src/macros/repeat.md:3 msgid "" "Macros can use `+` in the argument list to indicate that an argument may " "repeat at least once, or `*`, to indicate that the argument may repeat zero " "or more times." msgstr "" "매크로는 인자 목록에서 `+`를 사용하여 인자가 한 번 이상 반복될 수 있음을 나타" "내거나, `*`를 사용하여 인자가 0번 이상 반복될 수 있음을 나타낼 수 있습니다." #: src/macros/repeat.md:7 msgid "" "In the following example, surrounding the matcher with `$(...),+` will match " "one or more expression, separated by commas. Also note that the semicolon is " "optional on the last case." msgstr "" "다음 예제에서, 매처(matcher)를 `$(...),+`로 감싸면 콤마로 구분된 하나 이상의 " "표현식과 매치됩니다. 또한 마지막 케이스에서는 세미콜론이 선택사항임에 유의하" "세요." #: src/macros/repeat.md:12 msgid "// `find_min!` will calculate the minimum of any number of arguments.\n" msgstr "// `find_min!`은 임의 개수의 인자들 중 최솟값을 계산합니다.\n" #: src/macros/repeat.md:14 msgid "// Base case:\n" msgstr "// 기본 케이스:\n" #: src/macros/repeat.md:16 msgid "// `$x` followed by at least one `$y,`\n" msgstr "// `$x` 뒤에 최소 하나의 `$y,`가 오는 경우\n" #: src/macros/repeat.md:18 msgid "// Call `find_min!` on the tail `$y`\n" msgstr "// 나머지 `$y`들에 대해 `find_min!`을 호출합니다.\n" #: src/macros/dry.md:3 msgid "" "Macros allow writing DRY code by factoring out the common parts of functions " "and/or test suites. Here is an example that implements and tests the `+=`, " "`*=` and `-=` operators on `Vec`:" msgstr "" "매크로는 함수나 테스트 스위트의 공통 부분을 추출함으로써 DRY(Don't Repeat " "Yourself) 코드를 작성할 수 있게 해줍니다. 다음은 `Vec`에 대해 `+=`, `*=` " "및 `-=` 연산자를 구현하고 테스트하는 예제입니다:" #: src/macros/dry.md:11 msgid "" "// The `tt` (token tree) designator is used for\n" " // operators and tokens.\n" msgstr "" "// `tt`(토큰 트리) 지시자는\n" " // 연산자와 토큰에 사용됩니다.\n" #: src/macros/dry.md:15 msgid "\"{:?}: dimension mismatch: {:?} {:?} {:?}\"" msgstr "\"{:?}: dimension mismatch: {:?} {:?} {:?}\"" #: src/macros/dry.md:30 msgid "// *x = x.$method(*y);\n" msgstr "// *x = x.$method(*y);\n" #: src/macros/dry.md:35 msgid "// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.\n" msgstr "// `add_assign`, `mul_assign`, `sub_assign` 함수를 구현합니다.\n" #: src/macros/dry.md:60 msgid "// Test `add_assign`, `mul_assign`, and `sub_assign`.\n" msgstr "// `add_assign`, `mul_assign`, `sub_assign`을 테스트합니다.\n" #: src/macros/dsl.md:1 msgid "Domain Specific Languages (DSLs)" msgstr "도메인 특화 언어 (DSL)" #: src/macros/dsl.md:3 msgid "" "A DSL is a mini \"language\" embedded in a Rust macro. It is completely " "valid Rust because the macro system expands into normal Rust constructs, but " "it looks like a small language. This allows you to define concise or " "intuitive syntax for some special functionality (within bounds)." msgstr "" "DSL은 Rust 매크로에 내장된 미니 \"언어\"입니다. 매크로 시스템이 일반적인 " "Rust 구문으로 확장되기 때문에 완전히 유효한 Rust 코드이지만, 작은 언어처럼 보" "입니다. 이를 통해 (일정한 범위 내에서) 특정 기능을 위한 간결하거나 직관적인 " "구문을 정의할 수 있습니다." #: src/macros/dsl.md:8 msgid "" "Suppose that I want to define a little calculator API. I would like to " "supply an expression and have the output printed to console." msgstr "" "작은 계산기 API를 정의하고 싶다고 가정해 봅시다. 표현식을 입력하면 출력이 콘" "솔에 인쇄되도록 하고 싶습니다." #: src/macros/dsl.md:15 msgid "// Force types to be unsigned integers\n" msgstr "// 타입을 부호 없는 정수로 강제합니다\n" #: src/macros/dsl.md:16 src/macros/variadics.md:15 msgid "\"{} = {}\"" msgstr "\"{} = {}\"" #: src/macros/dsl.md:23 msgid "// hehehe `eval` is _not_ a Rust keyword!\n" msgstr "// 히히히 `eval`은 Rust 키워드가 아닙니다!\n" #: src/macros/dsl.md:32 src/macros/variadics.md:35 msgid "Output:" msgstr "출력:" #: src/macros/dsl.md:39 msgid "" "This was a very simple example, but much more complex interfaces have been " "developed, such as [`lazy_static`](https://crates.io/crates/lazy_static) or " "[`clap`](https://crates.io/crates/clap)." msgstr "" "이것은 매우 간단한 예제였지만, [`lazy_static`](https://crates.io/crates/" "lazy_static)이나 [`clap`](https://crates.io/crates/clap)과 같이 훨씬 더 복잡" "한 인터페이스들이 개발되어 있습니다." #: src/macros/dsl.md:43 msgid "" "Also, note the two pairs of braces in the macro. The outer ones are part of " "the syntax of `macro_rules!`, in addition to `()` or `[]`." msgstr "" "또한, 매크로에 두 쌍의 중괄호가 있음에 유의하세요. 바깥쪽 중괄호는 `()`나 " "`[]` 외에 `macro_rules!` 문법의 일부입니다." #: src/macros/variadics.md:1 msgid "Variadic Interfaces" msgstr "가변 인자 인터페이스" #: src/macros/variadics.md:3 msgid "" "A _variadic_ interface takes an arbitrary number of arguments. For example, " "`println!` can take an arbitrary number of arguments, as determined by the " "format string." msgstr "" "가변 인자 인터페이스는 임의의 개수의 인자를 취합니다. 예를 들어, `println!`" "은 형식 문자열에 따라 결정되는 임의의 개수의 인자를 취할 수 있습니다." #: src/macros/variadics.md:7 msgid "" "We can extend our `calculate!` macro from the previous section to be " "variadic:" msgstr "" "이전 섹션의 `calculate!` 매크로를 가변 인자를 취하도록 확장할 수 있습니다:" #: src/macros/variadics.md:11 msgid "// The pattern for a single `eval`\n" msgstr "// 단일 `eval`을 위한 패턴\n" #: src/macros/variadics.md:14 msgid "// Force types to be integers\n" msgstr "// 타입을 정수로 강제합니다\n" #: src/macros/variadics.md:19 msgid "// Decompose multiple `eval`s recursively\n" msgstr "// 여러 개의 `eval`을 재귀적으로 분해합니다\n" #: src/macros/variadics.md:27 msgid "// Look ma! Variadic `calculate!`!\n" msgstr "// 보세요! 가변 인자 `calculate!`입니다!\n" #: src/error.md:3 msgid "" "Error handling is the process of handling the possibility of failure. For " "example, failing to read a file and then continuing to use that _bad_ input " "would clearly be problematic. Noticing and explicitly managing those errors " "saves the rest of the program from various pitfalls." msgstr "" "에러 핸들링은 실패 가능성을 처리하는 과정입니다. 예를 들어, 파일을 읽는 데 실" "패했는데도 그 *잘못된* 입력을 계속 사용하는 것은 분명히 문제가 될 것입니다. " "이러한 에러를 인지하고 명시적으로 관리하면 프로그램의 나머지 부분을 다양한 함" "정으로부터 보호할 수 있습니다." #: src/error.md:8 msgid "" "There are various ways to deal with errors in Rust, which are described in " "the following subchapters. They all have more or less subtle differences and " "different use cases. As a rule of thumb:" msgstr "" "Rust에는 에러를 처리하는 다양한 방법이 있으며, 이는 이어지는 하위 장에서 설명" "합니다. 이들은 모두 어느 정도 미묘한 차이가 있으며 용도가 다릅니다. 일반적인 " "원칙은 다음과 같습니다:" #: src/error.md:12 msgid "" "An explicit `panic` is mainly useful for tests and dealing with " "unrecoverable errors. For prototyping it can be useful, for example when " "dealing with functions that haven't been implemented yet, but in those cases " "the more descriptive `unimplemented` is better. In tests `panic` is a " "reasonable way to explicitly fail." msgstr "" "명시적인 `panic`은 주로 테스트와 복구 불가능한 에러를 처리하는 데 유용합니" "다. 프로토타이핑을 할 때도 유용할 수 있는데, 예를 들어 아직 구현되지 않은 함" "수를 다룰 때 유용하지만, 그런 경우에는 더 설명적인 `unimplemented`를 사용하" "는 것이 좋습니다. 테스트에서 `panic`은 명시적으로 실패를 알리는 합리적인 방법" "입니다." #: src/error.md:17 msgid "" "The `Option` type is for when a value is optional or when the lack of a " "value is not an error condition. For example the parent of a directory - `/` " "and `C:` don't have one. When dealing with `Option`s, `unwrap` is fine for " "prototyping and cases where it's absolutely certain that there is guaranteed " "to be a value. However `expect` is more useful since it lets you specify an " "error message in case something goes wrong anyway." msgstr "" "`Option` 타입은 값이 선택적이거나 값의 부재가 에러 상황이 아닐 때 사용됩니" "다. 예를 들어 디렉터리의 부모 - `/`와 `C:`는 부모가 없습니다. `Option`을 다" "룰 때, `unwrap`은 프로토타이핑이나 값이 반드시 존재한다고 절대적으로 확신할 " "수 있는 경우에 괜찮습니다. 하지만 `expect`는 무언가 잘못되었을 경우를 대비해 " "에러 메시지를 지정할 수 있게 해주므로 더 유용합니다." #: src/error.md:24 msgid "" "When there is a chance that things do go wrong and the caller has to deal " "with the problem, use `Result`. You can `unwrap` and `expect` them as well " "(please don't do that unless it's a test or quick prototype)." msgstr "" "무언가 잘못될 가능성이 있고 호출자가 그 문제를 처리해야 할 때는 `Result`를 사" "용하세요. `Result`에 대해서도 `unwrap`과 `expect`를 사용할 수 있지만 (테스트" "나 빠른 프로토타입이 아니라면 제발 그렇게 하지 마세요)." #: src/error.md:28 msgid "" "For a more rigorous discussion of error handling, refer to the error " "handling section in the [official book](https://doc.rust-lang.org/book/" "ch09-00-error-handling.html)." msgstr "" "에러 핸들링에 대한 더 엄밀한 논의는 [공식 도서](https://doc.rust-lang.org/" "book/ch09-00-error-handling.html)의 에러 핸들링 섹션을 참조하세요." #: src/error/panic.md:3 msgid "" "The simplest error handling mechanism we will see is `panic`. It prints an " "error message, starts unwinding the stack, and usually exits the program. " "Here, we explicitly call `panic` on our error condition:" msgstr "" "우리가 살펴볼 가장 단순한 에러 핸들링 메커니즘은 `panic`입니다. 이것은 에러 " "메시지를 출력하고, 스택을 되감기(unwind) 시작하며, 보통 프로그램을 종료합니" "다. 여기서는 에러 조건에 대해 명시적으로 `panic`을 호출합니다:" #: src/error/panic.md:9 msgid "// You shouldn't drink too many sugary beverages.\n" msgstr "// 설탕이 든 음료를 너무 많이 마시면 안 됩니다.\n" #: src/error/panic.md:10 src/error/panic.md:17 src/error/abort_unwind.md:10 #: src/error/abort_unwind.md:23 src/error/abort_unwind.md:41 #: src/error/abort_unwind.md:50 src/error/option_unwrap.md:32 #: src/error/option_unwrap.md:43 src/error/option_unwrap.md:50 msgid "\"lemonade\"" msgstr "\"레모네이드\"" #: src/error/panic.md:10 src/error/option_unwrap.md:43 msgid "\"AAAaaaaa!!!!\"" msgstr "\"으아아아아!!!!\"" #: src/error/panic.md:12 src/error/abort_unwind.md:17 #: src/error/abort_unwind.md:44 msgid "\"Some refreshing {} is all I need.\"" msgstr "\"상쾌한 {}만 있으면 돼요.\"" #: src/error/panic.md:16 src/error/abort_unwind.md:22 #: src/error/abort_unwind.md:49 src/error/option_unwrap.md:49 msgid "\"water\"" msgstr "\"물\"" #: src/error/panic.md:18 msgid "\"still water\"" msgstr "\"생수\"" #: src/error/panic.md:22 msgid "" "The first call to `drink` works. The second panics and thus the third is " "never called." msgstr "" "첫 번째 `drink` 호출은 작동합니다. 두 번째는 패닉을 일으키며, 따라서 세 번째" "는 결코 호출되지 않습니다." #: src/error/abort_unwind.md:1 msgid "`abort` and `unwind`" msgstr "`abort`와 `unwind`" #: src/error/abort_unwind.md:3 msgid "" "The previous section illustrates the error handling mechanism `panic`. " "Different code paths can be conditionally compiled based on the panic " "setting. The current values available are `unwind` and `abort`." msgstr "" "이전 섹션에서는 에러 핸들링 메커니즘인 `panic`을 설명했습니다. 패닉 설정에 따" "라 서로 다른 코드 경로를 조건부로 컴파일할 수 있습니다. 현재 사용 가능한 값" "은 `unwind`와 `abort`입니다." #: src/error/abort_unwind.md:5 msgid "" "Building on the prior lemonade example, we explicitly use the panic strategy " "to exercise different lines of code." msgstr "" "앞선 레모네이드 예제를 바탕으로, 서로 다른 코드 라인을 실행해 보기 위해 패닉 " "전략을 명시적으로 사용합니다." #: src/error/abort_unwind.md:9 msgid "// You shouldn't drink too much sugary beverages.\n" msgstr "// 설탕이 든 음료를 너무 많이 마시면 안 됩니다.\n" #: src/error/abort_unwind.md:11 msgid "\"abort\"" msgstr "\"abort\"" #: src/error/abort_unwind.md:12 src/error/abort_unwind.md:37 msgid "\"This is not your party. Run!!!!\"" msgstr "\"여긴 당신 파티가 아니에요. 도망쳐요!!!!\"" #: src/error/abort_unwind.md:14 src/error/abort_unwind.md:32 msgid "\"Spit it out!!!!\"" msgstr "\"뱉어내요!!!!\"" #: src/error/abort_unwind.md:27 msgid "" "Here is another example focusing on rewriting `drink()` and explicitly use " "the `unwind` keyword." msgstr "" "여기 `drink()`를 다시 작성하고 `unwind` 키워드를 명시적으로 사용하는 또 다른 " "예제가 있습니다." #: src/error/abort_unwind.md:30 src/error/abort_unwind.md:35 msgid "\"unwind\"" msgstr "\"unwind\"" #: src/error/abort_unwind.md:54 msgid "" "The panic strategy can be set from the command line by using `abort` or " "`unwind`." msgstr "" "패닉 전략은 커맨드 라인에서 `abort` 또는 `unwind`를 사용하여 설정할 수 있습니" "다." #: src/error/option_unwrap.md:3 msgid "" "In the last example, we showed that we can induce program failure at will. " "We told our program to `panic` if we drink a sugary lemonade. But what if we " "expect _some_ drink but don't receive one? That case would be just as bad, " "so it needs to be handled!" msgstr "" "지난 예제에서, 우리는 프로그램을 의도적으로 실패하게 만들 수 있음을 보여주었" "습니다. 설탕이 든 레모네이드를 마시면 `panic`하도록 프로그램에 지시했습니다. " "하지만 음료가 있을 것으로 예상했는데 아무것도 받지 못하면 어떨까요? 그 경우" "도 마찬가지로 나쁠 것이므로, 처리가 필요합니다!" #: src/error/option_unwrap.md:8 msgid "" "We _could_ test this against the null string (`\"\"`) as we do with a " "lemonade. Since we're using Rust, let's instead have the compiler point out " "cases where there's no drink." msgstr "" "레모네이드의 경우처럼 빈 문자열(`\"\"`)인지 테스트할 수도 있습니다. 하지만 우" "리는 Rust를 사용하고 있으니, 대신 컴파일러가 음료가 없는 경우를 지적하도록 해" "봅시다." #: src/error/option_unwrap.md:12 msgid "" "An `enum` called `Option` in the `std` library is used when absence is a " "possibility. It manifests itself as one of two \"options\":" msgstr "" "표준 라이브러리의 `Option`라는 열거형은 부재의 가능성이 있을 때 사용됩니" "다. 이는 두 가지 \"옵션\" 중 하나로 나타납니다:" #: src/error/option_unwrap.md:15 msgid "`Some(T)`: An element of type `T` was found" msgstr "`Some(T)`: `T` 타입의 요소가 발견됨" #: src/error/option_unwrap.md:16 msgid "`None`: No element was found" msgstr "`None`: 요소가 발견되지 않음" #: src/error/option_unwrap.md:18 msgid "" "These cases can either be explicitly handled via `match` or implicitly with " "`unwrap`. Implicit handling will either return the inner element or `panic`." msgstr "" "이러한 경우들은 `match`를 통해 명시적으로 처리하거나 `unwrap`을 통해 암시적으" "로 처리할 수 있습니다. 암시적 처리는 내부 요소를 반환하거나 `panic`을 일으킵" "니다." #: src/error/option_unwrap.md:21 msgid "" "Note that it's possible to manually customize `panic` with [expect](https://" "doc.rust-lang.org/std/option/enum.Option.html#method.expect), but `unwrap` " "otherwise leaves us with a less meaningful output than explicit handling. In " "the following example, explicit handling yields a more controlled result " "while retaining the option to `panic` if desired." msgstr "" "[expect](https://doc.rust-lang.org/std/option/enum.Option.html#method.expect)" "를 사용하여 `panic`을 수동으로 커스터마이징할 수 있지만, 그렇지 않으면 " "`unwrap`은 명시적 처리보다 덜 의미 있는 출력을 남깁니다. 다음 예제에서, 명시" "적 처리는 원하는 경우 `panic`할 수 있는 옵션을 유지하면서도 더 제어된 결과를 " "제공합니다." #: src/error/option_unwrap.md:27 msgid "" "// The adult has seen it all, and can handle any drink well.\n" "// All drinks are handled explicitly using `match`.\n" msgstr "" "// 어른은 모든 것을 보았고, 어떤 음료든 잘 다룰 수 있습니다.\n" "// 모든 음료는 `match`를 사용하여 명시적으로 처리됩니다.\n" #: src/error/option_unwrap.md:30 msgid "// Specify a course of action for each case.\n" msgstr "// 각 경우에 대한 행동 지침을 지정합니다.\n" #: src/error/option_unwrap.md:32 msgid "\"Yuck! Too sugary.\"" msgstr "\"윽! 너무 달아요.\"" #: src/error/option_unwrap.md:33 msgid "\"{}? How nice.\"" msgstr "\"{}요? 좋네요.\"" #: src/error/option_unwrap.md:34 msgid "\"No drink? Oh well.\"" msgstr "\"음료가 없나요? 뭐, 어쩔 수 없죠.\"" #: src/error/option_unwrap.md:37 msgid "" "// Others will `panic` before drinking sugary drinks.\n" "// All drinks are handled implicitly using `unwrap`.\n" msgstr "" "// 다른 사람들은 단 음료를 마시기 전에 `panic`할 것입니다.\n" "// 모든 음료는 `unwrap`을 사용하여 암시적으로 처리됩니다.\n" #: src/error/option_unwrap.md:41 msgid "// `unwrap` returns a `panic` when it receives a `None`.\n" msgstr "// `unwrap`은 `None`을 받으면 `panic`을 반환합니다.\n" #: src/error/option_unwrap.md:45 msgid "\"I love {}s!!!!!\"" msgstr "\"난 {}가 너무 좋아요!!!!!\"" #: src/error/option_unwrap.md:57 msgid "\"coffee\"" msgstr "\"커피\"" #: src/error/option_unwrap/question_mark.md:3 msgid "" "You can unpack `Option`s by using `match` statements, but it's often easier " "to use the `?` operator. If `x` is an `Option`, then evaluating `x?` will " "return the underlying value if `x` is `Some`, otherwise it will terminate " "whatever function is being executed and return `None`." msgstr "" "`match` 문을 사용하여 `Option`을 풀 수(unpack) 있지만, `?` 연산자를 사용하는 " "것이 더 쉬울 때가 많습니다. 만약 `x`가 `Option`이라면, `x?`를 평가할 때 `x`" "가 `Some`이면 그 내부 값을 반환하고, 그렇지 않으면 실행 중인 함수를 종료하고 " "`None`을 반환합니다." #: src/error/option_unwrap/question_mark.md:10 msgid "" "// If `current_age` is `None`, this returns `None`.\n" " // If `current_age` is `Some`, the inner `u8` value + 1\n" " // gets assigned to `next_age`\n" msgstr "" "// 만약 `current_age`가 `None`이면, 이는 `None`을 반환합니다.\n" " // 만약 `current_age`가 `Some`이면, 내부의 `u8` 값 + 1이\n" " // `next_age`에 할당됩니다.\n" #: src/error/option_unwrap/question_mark.md:14 msgid "\"Next year I will be {}\"" msgstr "\"내년에 저는 {}살이 됩니다\"" #: src/error/option_unwrap/question_mark.md:18 msgid "You can chain many `?`s together to make your code much more readable." msgstr "" "여러 개의 `?`를 체인으로 연결하여 코드를 훨씬 더 읽기 쉽게 만들 수 있습니다." #: src/error/option_unwrap/question_mark.md:38 msgid "" "// Gets the area code of the phone number of the person's job, if it " "exists.\n" msgstr "// 사람의 직장 전화번호의 지역 번호가 존재한다면 가져옵니다.\n" #: src/error/option_unwrap/question_mark.md:40 msgid "" "// This would need many nested `match` statements without the `?` operator.\n" " // It would take a lot more code - try writing it yourself and see " "which\n" " // is easier.\n" msgstr "" "// `?` 연산자가 없다면 많은 중첩된 `match` 문이 필요했을 것입니다.\n" " // 훨씬 더 많은 코드가 필요할 것입니다 - 직접 작성해 보고 어느 쪽이 " "더 쉬운지\n" " // 확인해 보세요.\n" #: src/error/option_unwrap/map.md:3 msgid "" "`match` is a valid method for handling `Option`s. However, you may " "eventually find heavy usage tedious, especially with operations only valid " "with an input. In these cases, [combinators](https://doc.rust-lang.org/" "reference/glossary.html#combinator) can be used to manage control flow in a " "modular fashion." msgstr "" "`match`는 `Option`을 처리하는 유효한 방법입니다. 하지만 특히 입력이 있을 때" "만 유효한 연산들의 경우, 과도한 사용은 지루할 수 있습니다. 이런 경우, [콤비네" "이터(combinators)](https://doc.rust-lang.org/reference/" "glossary.html#combinator)를 사용하여 모듈식으로 제어 흐름을 관리할 수 있습니" "다." #: src/error/option_unwrap/map.md:8 msgid "" "`Option` has a built in method called `map()`, a combinator for the simple " "mapping of `Some -> Some` and `None -> None`. Multiple `map()` calls can be " "chained together for even more flexibility." msgstr "" "`Option`에는 `Some -> Some` 및 `None -> None`의 단순 매핑을 위한 콤비네이터" "인 `map()` 메서드가 내장되어 있습니다. 여러 개의 `map()` 호출을 체인으로 연결" "하여 훨씬 더 유연하게 사용할 수 있습니다." #: src/error/option_unwrap/map.md:12 msgid "" "In the following example, `process()` replaces all functions previous to it " "while staying compact." msgstr "" "다음 예제에서 `process()`는 간결함을 유지하면서 그 이전의 모든 함수들을 대체" "합니다." #: src/error/option_unwrap/map.md:23 msgid "" "// Peeling food. If there isn't any, then return `None`.\n" "// Otherwise, return the peeled food.\n" msgstr "" "// 음식을 껍질 벗깁니다. 음식이 없다면 `None`을 반환합니다.\n" "// 그렇지 않으면 껍질을 벗긴 음식을 반환합니다.\n" #: src/error/option_unwrap/map.md:32 msgid "" "// Chopping food. If there isn't any, then return `None`.\n" "// Otherwise, return the chopped food.\n" msgstr "" "// 음식을 썹니다. 음식이 없다면 `None`을 반환합니다.\n" "// 그렇지 않으면 썬 음식을 반환합니다.\n" #: src/error/option_unwrap/map.md:41 msgid "" "// Cooking food. Here, we showcase `map()` instead of `match` for case " "handling.\n" msgstr "" "// 음식을 요리합니다. 여기서는 케이스 처리를 위해 `match` 대신 `map()`을 보여" "줍니다.\n" #: src/error/option_unwrap/map.md:46 msgid "" "// A function to peel, chop, and cook food all in sequence.\n" "// We chain multiple uses of `map()` to simplify the code.\n" msgstr "" "// 음식을 순서대로 껍질 벗기고, 썰고, 요리하는 함수입니다.\n" "// 코드를 단순화하기 위해 `map()`을 여러 번 체인으로 연결합니다.\n" #: src/error/option_unwrap/map.md:54 msgid "// Check whether there's food or not before trying to eat it!\n" msgstr "// 먹기 전에 음식이 있는지 없는지 확인합니다!\n" #: src/error/option_unwrap/map.md:58 msgid "\"Mmm. I love {:?}\"" msgstr "\"음~ 전 {:?}가 정말 좋아요\"" #: src/error/option_unwrap/map.md:59 msgid "\"Oh no! It wasn't edible.\"" msgstr "\"오 이런! 먹을 수 있는 게 아니었어요.\"" #: src/error/option_unwrap/map.md:70 msgid "// Let's try the simpler looking `process()` now.\n" msgstr "// 이제 더 간단해 보이는 `process()`를 시도해 봅시다.\n" #: src/error/option_unwrap/map.md:81 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" msgstr "" "[클로저](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" #: src/error/option_unwrap/and_then.md:3 msgid "" "`map()` was described as a chainable way to simplify `match` statements. " "However, using `map()` on a function that returns an `Option` results in " "the nested `Option>`. Chaining multiple calls together can then " "become confusing. That's where another combinator called `and_then()`, known " "in some languages as flatmap, comes in." msgstr "" "`map()`은 `match` 문을 단순화하기 위한 체인 가능한 방법으로 설명되었습니다. " "하지만 `Option`를 반환하는 함수에 `map()`을 사용하면 중첩된 " "`Option>`가 생성됩니다. 여러 호출을 함께 체인으로 연결하는 것은 혼" "란스러울 수 있습니다. 이때 다른 언어에서 `flatmap`으로 알려진 `and_then()`이" "라는 또 다른 콤비네이터가 등장합니다." #: src/error/option_unwrap/and_then.md:9 msgid "" "`and_then()` calls its function input with the wrapped value and returns the " "result. If the `Option` is `None`, then it returns `None` instead." msgstr "" "`and_then()`은 래핑된 값을 가지고 함수 입력을 호출하고 그 결과를 반환합니다. " "만약 `Option`이 `None`이라면, 대신 `None`을 반환합니다." #: src/error/option_unwrap/and_then.md:11 msgid "" "In the following example, `cookable_v3()` results in an `Option`. " "Using `map()` instead of `and_then()` would have given an " "`Option>`, which is an invalid type for `eat()`." msgstr "" "다음 예제에서, `cookable_v3()`는 `Option`를 결과로 냅니다. " "`and_then()` 대신 `map()`을 사용했다면 `Option>`를 얻었을 것이" "며, 이는 `eat()`에 대해 유효하지 않은 타입입니다." #: src/error/option_unwrap/and_then.md:20 msgid "// We don't have the ingredients to make Sushi.\n" msgstr "// 우리는 스시를 만들 재료가 없습니다.\n" #: src/error/option_unwrap/and_then.md:28 msgid "// We have the recipe for everything except Cordon Bleu.\n" msgstr "" "// 우리는 코르동 블뢰(Cordon Bleu)를 제외한 모든 것의 레시피를 가지고 있습니" "다.\n" #: src/error/option_unwrap/and_then.md:36 msgid "" "// To make a dish, we need both the recipe and the ingredients.\n" "// We can represent the logic with a chain of `match`es:\n" msgstr "" "// 요리를 하려면 레시피와 재료가 모두 필요합니다.\n" "// 우리는 이 로직을 `match`들의 체인으로 표현할 수 있습니다:\n" #: src/error/option_unwrap/and_then.md:45 msgid "" "// This can conveniently be rewritten more compactly with `and_then()`:\n" msgstr "// 이는 `and_then()`을 사용하여 더 간결하게 다시 작성될 수 있습니다:\n" #: src/error/option_unwrap/and_then.md:50 msgid "" "// Otherwise we'd need to `flatten()` an `Option>`\n" "// to get an `Option`:\n" msgstr "" "// 그렇지 않다면 `Option`를 얻기 위해 `Option>`를 " "`flatten()`해야 할 것입니다:\n" #: src/error/option_unwrap/and_then.md:59 msgid "\"Yay! On {:?} we get to eat {:?}.\"" msgstr "\"야호! {:?}에 우리는 {:?}를 먹게 되었어요.\"" #: src/error/option_unwrap/and_then.md:60 msgid "\"Oh no. We don't get to eat on {:?}?\"" msgstr "\"오 이런. {:?}에는 못 먹는 건가요?\"" #: src/error/option_unwrap/and_then.md:75 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then), and [`Option::flatten()`]" "(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" msgstr "" "[클로저](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then), 그리고 [`Option::flatten()`]" "(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" #: src/error/option_unwrap/defaults.md:1 msgid "Unpacking options and defaults" msgstr "Option 풀기와 기본값" #: src/error/option_unwrap/defaults.md:3 msgid "" "There is more than one way to unpack an `Option` and fall back on a default " "if it is `None`. To choose the one that meets our needs, we need to consider " "the following:" msgstr "" "`Option`이 `None`일 때 이를 풀고 기본값으로 돌아가는 방법은 여러 가지가 있습" "니다. 우리의 필요에 맞는 것을 선택하려면 다음을 고려해야 합니다:" #: src/error/option_unwrap/defaults.md:5 msgid "do we need eager or lazy evaluation?" msgstr "" "조급한(eager) 평가가 필요한가요, 아니면 느긋한(lazy) 평가가 필요한가요?" #: src/error/option_unwrap/defaults.md:6 msgid "" "do we need to keep the original empty value intact, or modify it in place?" msgstr "" "원래의 빈 값을 그대로 두어야 하나요, 아니면 그 자리에서 수정해야 하나요?" #: src/error/option_unwrap/defaults.md:8 msgid "`or()` is chainable, evaluates eagerly, keeps empty value intact" msgstr "`or()`은 체인 가능하며, 조급하게 평가하고, 빈 값을 그대로 유지합니다." #: src/error/option_unwrap/defaults.md:10 msgid "" "`or()`is chainable and eagerly evaluates its argument, as is shown in the " "following example. Note that because `or`'s arguments are evaluated eagerly, " "the variable passed to `or` is moved." msgstr "" "`or()`은 체인 가능하며 다음 예제에서 보듯 인자를 조급하게 평가합니다. `or`의 " "인자들은 조급하게 평가되기 때문에, `or`에 전달된 변수는 이동(move)된다는 점" "에 유의하세요." #: src/error/option_unwrap/defaults.md:22 #: src/error/option_unwrap/defaults.md:55 msgid "\"first_available_fruit: {:?}\"" msgstr "\"first_available_fruit: {:?}\"" #: src/error/option_unwrap/defaults.md:23 msgid "// first_available_fruit: Some(Orange)\n" msgstr "// first_available_fruit: Some(Orange)\n" #: src/error/option_unwrap/defaults.md:25 msgid "" "// `or` moves its argument.\n" " // In the example above, `or(orange)` returned a `Some`, so `or(apple)` " "was not invoked.\n" " // But the variable named `apple` has been moved regardless, and cannot " "be used anymore.\n" " // println!(\"Variable apple was moved, so this line won't compile: {:?}" "\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" "// `or`는 인자를 이동시킵니다.\n" " // 위 예제에서 `or(orange)`가 `Some`을 반환했으므로 `or(apple)`은 호출되" "지 않았습니다.\n" " // 하지만 `apple`이라는 이름의 변수는 상관없이 이동되었으며, 더 이상 사용" "할 수 없습니다.\n" " // println!(\"Variable apple was moved, so this line won't compile: {:?}" "\", apple);\n" " // TODO: 위 줄의 주석을 해제하여 컴파일러 에러를 확인해 보세요.\n" #: src/error/option_unwrap/defaults.md:33 msgid "`or_else()` is chainable, evaluates lazily, keeps empty value intact" msgstr "" "`or_else()`는 체인 가능하며, 느긋하게 평가하고, 빈 값을 그대로 유지합니다." #: src/error/option_unwrap/defaults.md:35 msgid "" "Another alternative is to use `or_else`, which is also chainable, and " "evaluates lazily, as is shown in the following example:" msgstr "" "또 다른 대안은 `or_else`를 사용하는 것입니다. 이 역시 체인 가능하며 다음 예제" "에서 보듯 느긋하게 평가합니다:" #: src/error/option_unwrap/defaults.md:44 msgid "\"Providing kiwi as fallback\"" msgstr "\"키위를 대체값으로 제공함\"" #: src/error/option_unwrap/defaults.md:48 #: src/error/option_unwrap/defaults.md:93 msgid "\"Providing lemon as fallback\"" msgstr "\"레몬을 대체값으로 제공함\"" #: src/error/option_unwrap/defaults.md:56 msgid "" "// Providing kiwi as fallback\n" " // first_available_fruit: Some(Kiwi)\n" msgstr "" "// 키위를 대체값으로 제공함\n" " // first_available_fruit: Some(Kiwi)\n" #: src/error/option_unwrap/defaults.md:61 msgid "`get_or_insert()` evaluates eagerly, modifies empty value in place" msgstr "`get_or_insert()`는 조급하게 평가하며, 빈 값을 그 자리에서 수정합니다." #: src/error/option_unwrap/defaults.md:63 msgid "" "To make sure that an `Option` contains a value, we can use `get_or_insert` " "to modify it in place with a fallback value, as is shown in the following " "example. Note that `get_or_insert` eagerly evaluates its parameter, so " "variable `apple` is moved:" msgstr "" "`Option`에 값이 포함되도록 보장하기 위해, 다음 예제에서 보듯 `get_or_insert`" "를 사용하여 대체값으로 그 자리에서 수정할 수 있습니다. `get_or_insert`는 파라" "미터를 조급하게 평가하므로, `apple` 변수는 이동된다는 점에 유의하세요." #: src/error/option_unwrap/defaults.md:73 #: src/error/option_unwrap/defaults.md:98 msgid "\"first_available_fruit is: {:?}\"" msgstr "\"first_available_fruit is: {:?}\"" #: src/error/option_unwrap/defaults.md:74 #: src/error/option_unwrap/defaults.md:99 msgid "\"my_fruit is: {:?}\"" msgstr "\"my_fruit is: {:?}\"" #: src/error/option_unwrap/defaults.md:75 msgid "" "// first_available_fruit is: Apple\n" " // my_fruit is: Some(Apple)\n" " //println!(\"Variable named `apple` is moved: {:?}\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" "// first_available_fruit is: Apple\n" " // my_fruit is: Some(Apple)\n" " //println!(\"apple이라는 이름의 변수는 이동되었습니다: {:?}\", apple);\n" " // TODO: 위 줄의 주석을 해제하여 컴파일러 에러를 확인해 보세요.\n" #: src/error/option_unwrap/defaults.md:82 msgid "`get_or_insert_with()` evaluates lazily, modifies empty value in place" msgstr "" "`get_or_insert_with()`는 느긋하게 평가하며, 빈 값을 그 자리에서 수정합니다." #: src/error/option_unwrap/defaults.md:84 msgid "" "Instead of explicitly providing a value to fall back on, we can pass a " "closure to `get_or_insert_with`, as follows:" msgstr "" "대체할 값을 명시적으로 제공하는 대신, 다음과 같이 `get_or_insert_with`에 클로" "저를 전달할 수 있습니다:" #: src/error/option_unwrap/defaults.md:100 msgid "" "// Providing lemon as fallback\n" " // first_available_fruit is: Lemon\n" " // my_fruit is: Some(Lemon)\n" msgstr "" "// 레몬을 대체값으로 제공함\n" " // first_available_fruit is: Lemon\n" " // my_fruit is: Some(Lemon)\n" #: src/error/option_unwrap/defaults.md:104 msgid "" "// If the Option has a value, it is left unchanged, and the closure is not " "invoked\n" msgstr "" "// Option에 값이 있으면 변경되지 않은 채로 유지되며, 클로저는 호출되지 않습니" "다.\n" #: src/error/option_unwrap/defaults.md:107 msgid "\"should_be_apple is: {:?}\"" msgstr "\"should_be_apple is: {:?}\"" #: src/error/option_unwrap/defaults.md:108 msgid "\"my_apple is unchanged: {:?}\"" msgstr "\"my_apple is unchanged: {:?}\"" #: src/error/option_unwrap/defaults.md:109 msgid "" "// The output is a follows. Note that the closure `get_lemon_as_fallback` is " "not invoked\n" " // should_be_apple is: Apple\n" " // my_apple is unchanged: Some(Apple)\n" msgstr "" "// 출력은 다음과 같습니다. `get_lemon_as_fallback` 클로저가 호출되지 않았음" "에 유의하세요.\n" " // should_be_apple is: Apple\n" " // my_apple is unchanged: Some(Apple)\n" #: src/error/option_unwrap/defaults.md:117 msgid "" "[`closures`](https://doc.rust-lang.org/book/ch13-01-closures.html), " "[`get_or_insert`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.get_or_insert), [`get_or_insert_with`](https://" "doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with), " "[`moved variables`](https://doc.rust-lang.org/book/ch04-02-references-and-" "borrowing.html), [`or`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.or), [`or_else`](https://doc.rust-lang.org/core/" "option/enum.Option.html#method.or_else)" msgstr "" "[`클로저(closures)`](https://doc.rust-lang.org/book/ch13-01-closures.html), " "[`get_or_insert`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.get_or_insert), [`get_or_insert_with`](https://" "doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with), [`" "이동된 변수(moved variables)`](https://doc.rust-lang.org/book/ch04-02-" "references-and-borrowing.html), [`or`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.or), [`or_else`](https://doc.rust-lang.org/core/" "option/enum.Option.html#method.or_else)" #: src/error/result.md:3 msgid "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) is a " "richer version of the [`Option`](https://doc.rust-lang.org/std/option/" "enum.Option.html) type that describes possible _error_ instead of possible " "_absence_." msgstr "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)은 발생 가능" "한 *에러*를 설명하는, [`Option`](https://doc.rust-lang.org/std/option/" "enum.Option.html) 타입의 더 풍부한 버전입니다." #: src/error/result.md:6 msgid "That is, `Result` could have one of two outcomes:" msgstr "즉, `Result`는 다음 두 가지 결과 중 하나를 가질 수 있습니다:" #: src/error/result.md:8 msgid "`Ok(T)`: An element `T` was found" msgstr "`Ok(T)`: 요소 `T`가 발견됨" #: src/error/result.md:9 msgid "`Err(E)`: An error was found with element `E`" msgstr "`Err(E)`: 요소 `E`와 함께 에러가 발견됨" #: src/error/result.md:11 msgid "" "By convention, the expected outcome is `Ok` while the unexpected outcome is " "`Err`." msgstr "관례적으로 기대되는 결과는 `Ok`이며, 기대하지 않은 결과는 `Err`입니다." #: src/error/result.md:13 msgid "" "Like `Option`, `Result` has many methods associated with it. `unwrap()`, for " "example, either yields the element `T` or `panic`s. For case handling, there " "are many combinators between `Result` and `Option` that overlap." msgstr "" "`Option`과 마찬가지로, `Result`도 많은 메서드들을 가지고 있습니다. 예를 들어 " "`unwrap()`은 요소 `T`를 내놓거나 `panic`을 일으킵니다. 케이스 처리를 위해 " "`Result`와 `Option` 사이에는 겹치는 많은 콤비네이터들이 있습니다." #: src/error/result.md:17 msgid "" "In working with Rust, you will likely encounter methods that return the " "`Result` type, such as the [`parse()`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) method. It might not always be possible to " "parse a string into the other type, so `parse()` returns a `Result` " "indicating possible failure." msgstr "" "Rust로 작업하다 보면 [`parse()`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) 메서드와 같이 `Result` 타입을 반환하는 메서" "드들을 자주 만나게 될 것입니다. 문자열을 다른 타입으로 파싱하는 것이 항상 가" "능한 것은 아니므로, `parse()`는 실패 가능성을 나타내는 `Result`를 반환합니다." #: src/error/result.md:22 msgid "" "Let's see what happens when we successfully and unsuccessfully `parse()` a " "string:" msgstr "" "문자열을 `parse()` 하는 데 성공했을 때와 실패했을 때 어떤 일이 일어나는지 봅" "시다:" #: src/error/result.md:26 msgid "// Let's try using `unwrap()` to get the number out. Will it bite us?\n" msgstr "// `unwrap()`을 사용하여 숫자를 꺼내봅시다. 문제가 생길까요?\n" #: src/error/result.md:33 src/error/result.md:36 #: src/error/result/result_map.md:42 src/error/result/result_map.md:46 #: src/error/result/result_map.md:75 src/error/result/result_map.md:79 #: src/error/result/result_alias.md:36 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:36 src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:67 #: src/error/result/enter_question_mark.md:68 msgid "\"2\"" msgstr "\"2\"" #: src/error/result.md:34 src/error/result.md:37 msgid "\"double is {}\"" msgstr "\"두 배는 {}\"" #: src/error/result.md:36 src/error/result/result_map.md:46 #: src/error/result/result_map.md:79 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:68 msgid "\"t\"" msgstr "\"t\"" #: src/error/result.md:41 msgid "" "In the unsuccessful case, `parse()` leaves us with an error for `unwrap()` " "to `panic` on. Additionally, the `panic` exits our program and provides an " "unpleasant error message." msgstr "" "실패한 경우, `parse()`는 `unwrap()`이 `panic`을 일으킬 수 있도록 에러를 남깁" "니다. 게다가 이 `panic`은 프로그램을 종료시키고 불쾌한 에러 메시지를 제공합니" "다." #: src/error/result.md:45 msgid "" "To improve the quality of our error message, we should be more specific " "about the return type and consider explicitly handling the error." msgstr "" "에러 메시지의 품질을 높이려면, 반환 타입에 대해 더 구체적이어야 하며 에러를 " "명시적으로 처리하는 것을 고려해야 합니다." #: src/error/result.md:48 msgid "Using `Result` in `main`" msgstr "`main`에서 `Result` 사용하기" #: src/error/result.md:50 msgid "" "The `Result` type can also be the return type of the `main` function if " "specified explicitly. Typically the `main` function will be of the form:" msgstr "" "`Result` 타입은 명시적으로 지정될 경우 `main` 함수의 반환 타입이 될 수도 있습" "니다. 일반적으로 `main` 함수는 다음과 같은 형태입니다:" #: src/error/result.md:59 msgid "" "However `main` is also able to have a return type of `Result`. If an error " "occurs within the `main` function it will return an error code and print a " "debug representation of the error (using the [`Debug`](https://doc.rust-" "lang.org/std/fmt/trait.Debug.html) trait). The following example shows such " "a scenario and touches on aspects covered in [the following section](result/" "early_returns.md)." msgstr "" "하지만 `main`은 반환 타입으로 `Result`를 가질 수도 있습니다. 만약 `main` 함" "수 내에서 에러가 발생하면, 에러 코드를 반환하고 에러의 디버그 표현([`Debug`]" "(https://doc.rust-lang.org/std/fmt/trait.Debug.html) 트레이트 사용)을 출력합" "니다. 다음 예제는 그러한 시나리오를 보여주며 [다음 섹션](result/" "early_returns.md)에서 다루는 측면들을 언급합니다." #: src/error/result/result_map.md:3 msgid "" "Panicking in the previous example's `multiply` does not make for robust " "code. Generally, we want to return the error to the caller so it can decide " "what is the right way to respond to errors." msgstr "" "이전 예제의 `multiply`에서 패닉을 일으키는 것은 견고한 코드가 아닙니다. 일반" "적으로 우리는 호출자가 에러에 대응하는 올바른 방법을 결정할 수 있도록 에러를 " "호출자에게 반환하기를 원합니다." #: src/error/result/result_map.md:7 msgid "" "We first need to know what kind of error type we are dealing with. To " "determine the `Err` type, we look to [`parse()`](https://doc.rust-lang.org/" "std/primitive.str.html#method.parse), which is implemented with the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "[`i32`](https://doc.rust-lang.org/std/primitive.i32.html). As a result, the " "`Err` type is specified as [`ParseIntError`](https://doc.rust-lang.org/std/" "num/struct.ParseIntError.html)." msgstr "" "먼저 우리가 어떤 종류의 에러 타입을 다루고 있는지 알아야 합니다. `Err` 타입" "을 결정하기 위해, [`i32`](https://doc.rust-lang.org/std/primitive.i32.html)" "에 대해 [`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) 트" "레이트로 구현된 [`parse()`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse)를 살펴봅니다. 그 결과, `Err` 타입은 " "[`ParseIntError`](https://doc.rust-lang.org/std/num/" "struct.ParseIntError.html)로 지정됩니다." #: src/error/result/result_map.md:12 msgid "" "In the example below, the straightforward `match` statement leads to code " "that is overall more cumbersome." msgstr "" "아래 예제에서, 단순한 `match` 문은 전체적으로 더 번거로운 코드로 이어집니다." #: src/error/result/result_map.md:17 msgid "" "// With the return type rewritten, we use pattern matching without " "`unwrap()`.\n" msgstr "" "// 반환 타입을 다시 작성했으므로, `unwrap()` 없이 패턴 매칭을 사용합니다.\n" #: src/error/result/result_map.md:35 src/error/result/result_map.md:68 #: src/error/result/result_alias.md:30 src/error/result/early_returns.md:30 #: src/error/result/enter_question_mark.md:28 #: src/error/result/enter_question_mark.md:61 msgid "\"n is {}\"" msgstr "\"n은 {}입니다\"" #: src/error/result/result_map.md:36 src/error/result/result_map.md:69 #: src/error/result/result_alias.md:31 src/error/result/early_returns.md:31 #: src/error/result/enter_question_mark.md:29 #: src/error/result/enter_question_mark.md:62 #: src/error/multiple_error_types/define_error_type.md:55 #: src/error/multiple_error_types/boxing_errors.md:42 #: src/error/multiple_error_types/reenter_question_mark.md:54 #: src/error/multiple_error_types/wrap_error.md:68 msgid "\"Error: {}\"" msgstr "\"에러: {}\"" #: src/error/result/result_map.md:41 src/error/result/result_map.md:74 msgid "// This still presents a reasonable answer.\n" msgstr "// 이는 여전히 합리적인 답을 제시합니다.\n" #: src/error/result/result_map.md:45 src/error/result/result_map.md:78 msgid "// The following now provides a much more helpful error message.\n" msgstr "// 다음은 이제 훨씬 더 도움이 되는 에러 메시지를 제공합니다.\n" #: src/error/result/result_map.md:51 msgid "" "Luckily, `Option`'s `map`, `and_then`, and many other combinators are also " "implemented for `Result`. [`Result`](https://doc.rust-lang.org/std/result/" "enum.Result.html) contains a complete listing." msgstr "" "다행히도 `Option`의 `map`, `and_then` 및 다른 많은 콤비네이터들이 `Result`에 " "대해서도 구현되어 있습니다. [`Result`](https://doc.rust-lang.org/std/result/" "enum.Result.html) 문서에 전체 목록이 나와 있습니다." #: src/error/result/result_map.md:56 msgid "" "// As with `Option`, we can use combinators such as `map()`.\n" "// This function is otherwise identical to the one above and reads:\n" "// Multiply if both values can be parsed from str, otherwise pass on the " "error.\n" msgstr "" "// `Option`과 마찬가지로 `map()`과 같은 콤비네이터를 사용할 수 있습니다.\n" "// 이 함수는 위와 동일하며 다음과 같이 읽힙니다:\n" "// 두 값 모두 문자열에서 파싱될 수 있으면 곱하고, 그렇지 않으면 에러를 넘깁니" "다.\n" #: src/error/result/result_alias.md:3 msgid "" "How about when we want to reuse a specific `Result` type many times? Recall " "that Rust allows us to create [aliases](../../types/alias.md). Conveniently, " "we can define one for the specific `Result` in question." msgstr "" "특정한 `Result` 타입을 여러 번 재사용하고 싶을 때는 어떨까요? Rust는 [별칭" "(aliases)](../../types/alias.md)을 만들 수 있게 해준다는 점을 기억하세요. 편" "리하게도 문제의 특정 `Result`에 대해 별칭을 정의할 수 있습니다." #: src/error/result/result_alias.md:7 msgid "" "At a module level, creating aliases can be particularly helpful. Errors " "found in a specific module often have the same `Err` type, so a single alias " "can succinctly define _all_ associated `Results`. This is so useful that the " "`std` library even supplies one: [`io::Result`](https://doc.rust-lang.org/" "std/io/type.Result.html)!" msgstr "" "모듈 수준에서 별칭을 만드는 것은 특히 유용할 수 있습니다. 특정 모듈에서 발견" "되는 에러들은 종종 동일한 `Err` 타입을 가지므로, 단일 별칭으로 모든 연관된 " "`Result`들을 간결하게 정의할 수 있습니다. 이는 매우 유용하여 표준 라이브러리" "에서도 하나를 제공합니다: [`io::Result`](https://doc.rust-lang.org/std/io/" "type.Result.html)!" #: src/error/result/result_alias.md:12 msgid "Here's a quick example to show off the syntax:" msgstr "다음은 문법을 보여주는 간단한 예제입니다:" #: src/error/result/result_alias.md:16 msgid "" "// Define a generic alias for a `Result` with the error type " "`ParseIntError`.\n" msgstr "" "// 에러 타입이 `ParseIntError`인 `Result`에 대한 제네릭 별칭을 정의합니다.\n" #: src/error/result/result_alias.md:19 msgid "// Use the above alias to refer to our specific `Result` type.\n" msgstr "// 위 별칭을 사용하여 우리의 특정한 `Result` 타입을 참조합니다.\n" #: src/error/result/result_alias.md:26 msgid "// Here, the alias again allows us to save some space.\n" msgstr "// 여기서도 별칭을 사용하여 공간을 절약할 수 있습니다.\n" #: src/error/result/result_alias.md:43 msgid "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" msgstr "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" #: src/error/result/early_returns.md:3 msgid "" "In the previous example, we explicitly handled the errors using combinators. " "Another way to deal with this case analysis is to use a combination of " "`match` statements and _early returns_." msgstr "" "이전 예제에서 우리는 콤비네이터를 사용하여 에러를 명시적으로 처리했습니다. 이" "러한 케이스 분석을 처리하는 또 다른 방법은 `match` 문과 *조기 리턴(early " "returns)*을 조합하여 사용하는 것입니다." #: src/error/result/early_returns.md:7 msgid "" "That is, we can simply stop executing the function and return the error if " "one occurs. For some, this form of code can be easier to both read and " "write. Consider this version of the previous example, rewritten using early " "returns:" msgstr "" "즉, 에러가 발생하면 단순히 함수의 실행을 멈추고 에러를 반환할 수 있습니다. 어" "떤 이들에게는 이런 형태의 코드가 읽고 쓰기에 더 쉬울 수 있습니다. 이전 예제" "를 조기 리턴을 사용하여 다시 작성한 버전을 살펴보세요:" #: src/error/result/early_returns.md:41 msgid "" "At this point, we've learned to explicitly handle errors using combinators " "and early returns. While we generally want to avoid panicking, explicitly " "handling all of our errors is cumbersome." msgstr "" "지금까지 우리는 콤비네이터와 조기 리턴을 사용하여 에러를 명시적으로 처리하는 " "방법을 배웠습니다. 일반적으로 패닉은 피하고 싶지만, 모든 에러를 명시적으로 처" "리하는 것은 번거로운 일입니다." #: src/error/result/early_returns.md:45 msgid "" "In the next section, we'll introduce `?` for the cases where we simply need " "to `unwrap` without possibly inducing `panic`." msgstr "" "다음 섹션에서는 `panic`을 일으키지 않고 단순히 `unwrap`이 필요한 경우를 위한 " "`?`를 소개하겠습니다." #: src/error/result/enter_question_mark.md:3 msgid "" "Sometimes we just want the simplicity of `unwrap` without the possibility of " "a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when " "what we really wanted was to get the variable _out_. This is exactly the " "purpose of `?`." msgstr "" "때로는 `panic`의 가능성 없이 `unwrap`의 단순함만을 원할 때가 있습니다. 지금까" "지 `unwrap`은 우리가 정말 원했던 것이 변수를 꺼내는 것임에도 불구하고 점점 " "더 깊게 중첩하도록 강제해 왔습니다. 이것이 바로 `?`의 목적입니다." #: src/error/result/enter_question_mark.md:7 msgid "Upon finding an `Err`, there are two valid actions to take:" msgstr "`Err`을 발견했을 때 취할 수 있는 유효한 조치는 두 가지입니다:" #: src/error/result/enter_question_mark.md:9 msgid "`panic!` which we already decided to try to avoid if possible" msgstr "가능하다면 피하기로 이미 결정한 `panic!`" #: src/error/result/enter_question_mark.md:10 msgid "`return` because an `Err` means it cannot be handled" msgstr "`Err`은 처리될 수 없음을 의미하므로 `return`" #: src/error/result/enter_question_mark.md:12 msgid "" "`?` is _almost_[^†] exactly equivalent to an `unwrap` which `return`s " "instead of `panic`king on `Err`s. Let's see how we can simplify the earlier " "example that used combinators:" msgstr "" "`?`는 `Err`에 대해 `panic`을 일으키는 대신 `return`하는 `unwrap`과 거의[^†] " "정확히 동일합니다. 콤비네이터를 사용했던 이전 예제를 어떻게 단순화할 수 있는" "지 봅시다:" #: src/error/result/enter_question_mark.md:39 msgid "The `try!` macro" msgstr "`try!` 매크로" #: src/error/result/enter_question_mark.md:41 msgid "" "Before there was `?`, the same functionality was achieved with the `try!` " "macro. The `?` operator is now recommended, but you may still find `try!` " "when looking at older code. The same `multiply` function from the previous " "example would look like this using `try!`:" msgstr "" "`?`가 나오기 전에는 동일한 기능을 `try!` 매크로로 구현했습니다. 현재는 `?` 연" "산자가 권장되지만, 오래된 코드를 볼 때 여전히 `try!`를 발견할 수도 있습니다. " "이전 예제의 동일한 `multiply` 함수는 `try!`를 사용하면 다음과 같습니다:" #: src/error/result/enter_question_mark.md:47 msgid "" "// To compile and run this example without errors, while using Cargo, change " "the value\n" "// of the `edition` field, in the `[package]` section of the `Cargo.toml` " "file, to \"2015\".\n" msgstr "" "// Cargo를 사용하면서 이 예제를 에러 없이 컴파일하고 실행하려면,\n" "// `Cargo.toml` 파일의 `[package]` 섹션에 있는 `edition` 필드 값을 " "\"2015\"로 변경하세요.\n" #: src/error/result/enter_question_mark.md:72 msgid "" "See [re-enter ?](../multiple_error_types/reenter_question_mark.md) for more " "details." msgstr "" "자세한 내용은 [? 다시 보기](../multiple_error_types/reenter_question_mark.md)" "를 참조하세요." #: src/error/multiple_error_types.md:3 msgid "" "The previous examples have always been very convenient; `Result`s interact " "with other `Result`s and `Option`s interact with other `Option`s." msgstr "" "이전 예제들은 항상 매우 편리했습니다. `Result`는 다른 `Result`와 상호작용하" "고, `Option`은 다른 `Option`과 상호작용했습니다." #: src/error/multiple_error_types.md:6 msgid "" "Sometimes an `Option` needs to interact with a `Result`, or a `Result` needs to interact with a `Result`. In those cases, we " "want to manage our different error types in a way that makes them composable " "and easy to interact with." msgstr "" "때때로는 `Option`이 `Result`와 상호작용해야 하거나, `Result`이 " "`Result`와 상호작용해야 할 때가 있습니다. 그런 경우, 우리는 서로 " "다른 에러 타입들을 구성 가능하고 상호작용하기 쉬운 방식으로 관리하고 싶어 합" "니다." #: src/error/multiple_error_types.md:11 msgid "" "In the following code, two instances of `unwrap` generate different error " "types. `Vec::first` returns an `Option`, while `parse::` returns a " "`Result`:" msgstr "" "다음 코드에서, 두 개의 `unwrap` 인스턴스는 서로 다른 에러 타입을 생성합니다. " "`Vec::first`는 `Option`을 반환하는 반면, `parse::`는 `Result`를 반환합니다:" #: src/error/multiple_error_types.md:17 msgid "// Generate error 1\n" msgstr "// 에러 1 발생\n" #: src/error/multiple_error_types.md:18 msgid "// Generate error 2\n" msgstr "// 에러 2 발생\n" #: src/error/multiple_error_types.md:22 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/wrap_error.md:77 src/error/iter_result.md:40 msgid "\"42\"" msgstr "\"42\"" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"93\"" msgstr "\"93\"" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"18\"" msgstr "\"18\"" #: src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"tofu\"" msgstr "\"두부\"" #: src/error/multiple_error_types.md:26 src/error/multiple_error_types.md:28 #: src/error/multiple_error_types.md:31 #: src/error/multiple_error_types/define_error_type.md:54 #: src/error/multiple_error_types/boxing_errors.md:41 #: src/error/multiple_error_types/reenter_question_mark.md:53 #: src/error/multiple_error_types/wrap_error.md:66 msgid "\"The first doubled is {}\"" msgstr "\"두 배가 된 첫 번째 값은 {}입니다\"" #: src/error/multiple_error_types.md:29 #: src/error/multiple_error_types/option_result.md:23 msgid "// Error 1: the input vector is empty\n" msgstr "// 에러 1: 입력 벡터가 비어 있습니다\n" #: src/error/multiple_error_types.md:32 #: src/error/multiple_error_types/option_result.md:26 msgid "// Error 2: the element doesn't parse to a number\n" msgstr "// 에러 2: 요소를 숫자로 파싱할 수 없습니다\n" #: src/error/multiple_error_types.md:36 msgid "" "Over the next sections, we'll see several strategies for handling these kind " "of problems." msgstr "" "다음 섹션들에서 이러한 종류의 문제들을 처리하기 위한 몇 가지 전략을 살펴볼 것" "입니다." #: src/error/multiple_error_types/option_result.md:3 msgid "" "The most basic way of handling mixed error types is to just embed them in " "each other." msgstr "" "혼합된 에러 타입들을 처리하는 가장 기본적인 방법은 단순히 서로를 내포시키는 " "것입니다." #: src/error/multiple_error_types/option_result.md:20 #: src/error/multiple_error_types/option_result.md:22 #: src/error/multiple_error_types/option_result.md:25 #: src/error/multiple_error_types/option_result.md:49 #: src/error/multiple_error_types/option_result.md:50 #: src/error/multiple_error_types/option_result.md:51 msgid "\"The first doubled is {:?}\"" msgstr "\"두 배가 된 첫 번째 값은 {:?}입니다\"" #: src/error/multiple_error_types/option_result.md:30 msgid "" "There are times when we'll want to stop processing on errors (like with [`?`]" "(../result/enter_question_mark.md)) but keep going when the `Option` is " "`None`. The `transpose` function comes in handy to swap the `Result` and " "`Option`." msgstr "" "에러가 발생하면 처리를 중단하고 싶지만([?](../result/enter_question_mark.md)" "와 같이), `Option`이 `None`일 때는 계속 진행하고 싶을 때가 있습니다. 이럴 때 " "`Result`와 `Option`을 서로 바꾸어 주는 `transpose` 함수가 유용합니다." #: src/error/multiple_error_types/define_error_type.md:3 msgid "" "Sometimes it simplifies the code to mask all of the different errors with a " "single type of error. We'll show this with a custom error." msgstr "" "때로는 모든 서로 다른 에러들을 하나의 에러 타입으로 마스킹하는 것이 코드를 단" "순화합니다. 이를 커스텀 에러를 통해 보여주겠습니다." #: src/error/multiple_error_types/define_error_type.md:6 msgid "" "Rust allows us to define our own error types. In general, a \"good\" error " "type:" msgstr "" "Rust에서는 우리만의 에러 타입을 정의할 수 있습니다. 일반적으로 \"좋은\" 에러 " "타입은 다음과 같습니다:" #: src/error/multiple_error_types/define_error_type.md:8 msgid "Represents different errors with the same type" msgstr "서로 다른 에러들을 동일한 타입으로 표현합니다" #: src/error/multiple_error_types/define_error_type.md:9 msgid "Presents nice error messages to the user" msgstr "사용자에게 보기 좋은 에러 메시지를 제공합니다" #: src/error/multiple_error_types/define_error_type.md:10 msgid "Is easy to compare with other types" msgstr "다른 타입들과 비교하기 쉽습니다" #: src/error/multiple_error_types/define_error_type.md:11 msgid "Good: `Err(EmptyVec)`" msgstr "좋은 예: `Err(EmptyVec)`" #: src/error/multiple_error_types/define_error_type.md:12 msgid "" "Bad: `Err(\"Please use a vector with at least one element\".to_owned())`" msgstr "" "나쁜 예: `Err(\"Please use a vector with at least one element\".to_owned())`" #: src/error/multiple_error_types/define_error_type.md:13 msgid "Can hold information about the error" msgstr "에러에 대한 정보를 담을 수 있습니다" #: src/error/multiple_error_types/define_error_type.md:14 msgid "Good: `Err(BadChar(c, position))`" msgstr "좋은 예: `Err(BadChar(c, position))`" #: src/error/multiple_error_types/define_error_type.md:15 msgid "Bad: `Err(\"+ cannot be used here\".to_owned())`" msgstr "나쁜 예: `Err(\"+ cannot be used here\".to_owned())`" #: src/error/multiple_error_types/define_error_type.md:16 msgid "Composes well with other errors" msgstr "다른 에러들과 잘 구성(compose)됩니다" #: src/error/multiple_error_types/define_error_type.md:22 msgid "" "// Define our error types. These may be customized for our error handling " "cases.\n" "// Now we will be able to write our own errors, defer to an underlying " "error\n" "// implementation, or do something in between.\n" msgstr "" "// 우리의 에러 타입들을 정의합니다. 이들은 우리의 에러 처리 케이스에 맞게 커" "스터마이징될 수 있습니다.\n" "// 이제 우리만의 에러를 작성하거나, 기저 에러 구현에 위임하거나, 혹은 그 사이" "의 작업을 수행할 수 있습니다.\n" #: src/error/multiple_error_types/define_error_type.md:28 msgid "" "// Generation of an error is completely separate from how it is displayed.\n" "// There's no need to be concerned about cluttering complex logic with the " "display style.\n" "//\n" "// Note that we don't store any extra info about the errors. This means we " "can't state\n" "// which string failed to parse without modifying our types to carry that " "information.\n" msgstr "" "// 에러의 생성은 표시 방식과 완전히 분리되어 있습니다.\n" "// 표시 스타일 때문에 복잡한 로직이 어지러워질까 봐 걱정할 필요가 없습니다.\n" "//\n" "// 참고로 우리는 에러에 대한 추가 정보를 저장하지 않습니다. 즉, 정보를 담도" "록 타입을 수정하지 않고서는\n" "// 어떤 문자열이 파싱에 실패했는지 알 수 없습니다.\n" #: src/error/multiple_error_types/define_error_type.md:36 #: src/error/multiple_error_types/boxing_errors.md:23 #: src/error/multiple_error_types/reenter_question_mark.md:37 msgid "\"invalid first item to double\"" msgstr "\"두 배로 만들 첫 번째 항목이 유효하지 않습니다\"" #: src/error/multiple_error_types/define_error_type.md:42 msgid "// Change the error to our new type.\n" msgstr "// 에러를 우리의 새로운 타입으로 변경합니다.\n" #: src/error/multiple_error_types/define_error_type.md:46 msgid "// Update to the new error type here also.\n" msgstr "// 여기서도 새로운 에러 타입으로 업데이트합니다.\n" #: src/error/multiple_error_types/boxing_errors.md:3 msgid "" "A way to write simple code while preserving the original errors is to [`Box`]" "(https://doc.rust-lang.org/std/boxed/struct.Box.html) them. The drawback is " "that the underlying error type is only known at runtime and not [statically " "determined](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-" "objects-perform-dynamic-dispatch)." msgstr "" "원본 에러를 보존하면서 단순한 코드를 작성하는 방법은 에러들을 [`Box`]" "(https://doc.rust-lang.org/std/boxed/struct.Box.html)하는 것입니다. 단점은 기" "저 에러 타입을 런타임에만 알 수 있고 [정적으로 결정](https://doc.rust-" "lang.org/book/ch17-02-trait-objects.html#trait-objects-perform-dynamic-" "dispatch)되지 않는다는 것입니다." #: src/error/multiple_error_types/boxing_errors.md:7 msgid "" "The stdlib helps in boxing our errors by having `Box` implement conversion " "from any type that implements the `Error` trait into the trait object " "`Box`, via [`From`](https://doc.rust-lang.org/std/convert/" "trait.From.html)." msgstr "" "표준 라이브러리는 `Box`가 [`From`](https://doc.rust-lang.org/std/convert/" "trait.From.html)을 통해 `Error` 트레이트를 구현하는 모든 타입으로부터 트레이" "트 객체 `Box`로의 변환을 구현하도록 함으로써 에러를 박싱하는 것을 돕습" "니다." #: src/error/multiple_error_types/boxing_errors.md:14 #: src/error/multiple_error_types/reenter_question_mark.md:28 msgid "// Change the alias to use `Box`.\n" msgstr "// 별칭이 `Box`를 사용하도록 변경합니다.\n" #: src/error/multiple_error_types/boxing_errors.md:31 msgid "// Converts to Box using Into trait.\n" msgstr "// Into 트레이트를 사용하여 Box로 변환합니다.\n" #: src/error/multiple_error_types/boxing_errors.md:34 msgid "// Converts to Box using From::from fn pointer.\n" msgstr "// From::from 함수 포인터를 사용하여 Box로 변환합니다.\n" #: src/error/multiple_error_types/boxing_errors.md:59 msgid "" "[Dynamic dispatch](https://doc.rust-lang.org/book/ch17-02-trait-" "objects.html#trait-objects-perform-dynamic-dispatch) and [`Error` trait]" "(https://doc.rust-lang.org/std/error/trait.Error.html)" msgstr "" "[동적 디스패치(Dynamic dispatch)](https://doc.rust-lang.org/book/ch17-02-" "trait-objects.html#trait-objects-perform-dynamic-dispatch)와 [`Error` 트레이" "트](https://doc.rust-lang.org/std/error/trait.Error.html)" #: src/error/multiple_error_types/reenter_question_mark.md:3 msgid "" "Notice in the previous example that our immediate reaction to calling " "`parse` is to `map` the error from a library error into a boxed error:" msgstr "" "이전 예제에서 `parse`를 호출했을 때 우리의 즉각적인 반응은 라이브러리 에러를 " "박싱된 에러로 `map`하는 것이었습니다:" #: src/error/multiple_error_types/reenter_question_mark.md:12 msgid "" "Since this is a simple and common operation, it would be convenient if it " "could be elided. Alas, because `and_then` is not sufficiently flexible, it " "cannot. However, we can instead use `?`." msgstr "" "이는 단순하고 흔한 작업이므로 생략할 수 있다면 편리할 것입니다. 아쉽게도 " "`and_then`은 충분히 유연하지 못해 생략할 수 없습니다. 하지만 대신 `?`를 사용" "할 수 있습니다." #: src/error/multiple_error_types/reenter_question_mark.md:16 msgid "" "`?` was previously explained as either `unwrap` or `return Err(err)`. This " "is only mostly true. It actually means `unwrap` or `return " "Err(From::from(err))`. Since `From::from` is a conversion utility between " "different types, this means that if you `?` where the error is convertible " "to the return type, it will convert automatically." msgstr "" "`?`는 이전에 `unwrap` 또는 `return Err(err)`로 설명되었습니다. 이는 거의 맞지" "만 전부는 아닙니다. 실제로는 `unwrap` 또는 `return Err(From::from(err))`를 의" "미합니다. `From::from`은 서로 다른 타입 간의 변환 유틸리티이므로, 에러가 반" "환 타입으로 변환 가능한 곳에서 `?`를 사용하면 자동으로 변환됩니다." #: src/error/multiple_error_types/reenter_question_mark.md:22 msgid "" "Here, we rewrite the previous example using `?`. As a result, the `map_err` " "will go away when `From::from` is implemented for our error type:" msgstr "" "여기서는 이전 예제를 `?`를 사용하여 다시 작성합니다. 결과적으로, 우리의 에러 " "타입에 대해 `From::from`이 구현되면 `map_err`이 사라질 것입니다:" #: src/error/multiple_error_types/reenter_question_mark.md:42 msgid "" "// The same structure as before but rather than chain all `Results`\n" "// and `Options` along, we `?` to get the inner value out immediately.\n" msgstr "" "// 이전과 동일한 구조이지만 모든 `Result`와 `Option`을 체인으로 연결하는 대" "신,\n" "// `?`를 사용하여 즉시 내부 값을 꺼냅니다.\n" #: src/error/multiple_error_types/reenter_question_mark.md:69 msgid "" "This is actually fairly clean now. Compared with the original `panic`, it is " "very similar to replacing the `unwrap` calls with `?` except that the return " "types are `Result`. As a result, they must be destructured at the top level." msgstr "" "이제 상당히 깔끔해졌습니다. 원본 `panic` 예제와 비교하면, 반환 타입이 " "`Result`라는 점을 제외하고는 `unwrap` 호출을 `?`로 대체한 것과 매우 유사합니" "다. 그 결과, 이들은 최상위 레벨에서 구조 분해(destructure)되어야 합니다." #: src/error/multiple_error_types/reenter_question_mark.md:76 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`?" "`](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" msgstr "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [`?`]" "(https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" #: src/error/multiple_error_types/wrap_error.md:3 msgid "An alternative to boxing errors is to wrap them in your own error type." msgstr "" "에러를 박싱하는 것의 대안은 에러를 여러분만의 에러 타입으로 감싸는 것입니다." #: src/error/multiple_error_types/wrap_error.md:16 msgid "" "// We will defer to the parse error implementation for their error.\n" " // Supplying extra info requires adding more data to the type.\n" msgstr "" "// 파싱 에러에 대해서는 해당 에러 구현에 위임할 것입니다.\n" "// 추가 정보를 제공하려면 타입에 더 많은 데이터를 추가해야 합니다.\n" #: src/error/multiple_error_types/wrap_error.md:25 msgid "\"please use a vector with at least one element\"" msgstr "\"최소한 하나의 요소를 가진 벡터를 사용하세요\"" #: src/error/multiple_error_types/wrap_error.md:26 msgid "" "// The wrapped error contains additional information and is available\n" " // via the source() method.\n" msgstr "" "// 감싸진 에러는 추가 정보를 포함하며 `source()` 메서드를 통해\n" "// 사용할 수 있습니다.\n" #: src/error/multiple_error_types/wrap_error.md:29 msgid "\"the provided string could not be parsed as int\"" msgstr "\"제공된 문자열을 정수로 파싱할 수 없습니다\"" #: src/error/multiple_error_types/wrap_error.md:38 msgid "" "// The cause is the underlying implementation error type. Is implicitly\n" " // cast to the trait object `&error::Error`. This works because " "the\n" " // underlying type already implements the `Error` trait.\n" msgstr "" "// 원인은 기저 구현 에러 타입입니다. 이는 트레이트 객체 `&error::Error`로\n" "// 암시적으로 캐스팅됩니다. 기저 타입이 이미 `Error` 트레이트를\n" "// 구현하고 있기 때문에 작동합니다.\n" #: src/error/multiple_error_types/wrap_error.md:45 msgid "" "// Implement the conversion from `ParseIntError` to `DoubleError`.\n" "// This will be automatically called by `?` if a `ParseIntError`\n" "// needs to be converted into a `DoubleError`.\n" msgstr "" "// `ParseIntError`에서 `DoubleError`로의 변환을 구현합니다.\n" "// `ParseIntError`를 `DoubleError`로 변환해야 할 때 `?`에 의해\n" "// 자동으로 호출됩니다.\n" #: src/error/multiple_error_types/wrap_error.md:57 msgid "" "// Here we implicitly use the `ParseIntError` implementation of `From` " "(which\n" " // we defined above) in order to create a `DoubleError`.\n" msgstr "" "// 여기서 우리는 `DoubleError`를 생성하기 위해 (위에서 정의한)\n" "// `From`의 `ParseIntError` 구현을 암시적으로 사용합니다.\n" #: src/error/multiple_error_types/wrap_error.md:70 msgid "\" Caused by: {}\"" msgstr "\" 원인: {}\"" #: src/error/multiple_error_types/wrap_error.md:87 msgid "" "This adds a bit more boilerplate for handling errors and might not be needed " "in all applications. There are some libraries that can take care of the " "boilerplate for you." msgstr "" "이는 에러 처리를 위해 상용구(boilerplate) 코드를 조금 더 추가하며, 모든 애플" "리케이션에서 필요하지는 않을 수 있습니다. 상용구 코드를 대신 처리해 주는 몇" "몇 라이브러리들이 있습니다." #: src/error/multiple_error_types/wrap_error.md:93 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Enums`](../../custom_types/enum.md)" msgstr "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [열거" "형(Enums)](../../custom_types/enum.md)" #: src/error/multiple_error_types/wrap_error.md:95 msgid "" "[`Crates for handling errors`](https://crates.io/keywords/error-handling)" msgstr "" "[에러 처리를 위한 크레이트들](https://crates.io/keywords/error-handling)" #: src/error/iter_result.md:3 msgid "An `Iter::map` operation might fail, for example:" msgstr "예를 들어, `Iter::map` 연산은 실패할 수 있습니다:" #: src/error/iter_result.md:12 src/error/iter_result.md:29 #: src/error/iter_result.md:65 msgid "\"Results: {:?}\"" msgstr "\"결과: {:?}\"" #: src/error/iter_result.md:16 msgid "Let's step through strategies for handling this." msgstr "이를 처리하기 위한 전략들을 단계별로 살펴봅시다." #: src/error/iter_result.md:18 msgid "Ignore the failed items with `filter_map()`" msgstr "`filter_map()`으로 실패한 항목 무시하기" #: src/error/iter_result.md:20 msgid "" "`filter_map` calls a function and filters out the results that are `None`." msgstr "`filter_map`은 함수를 호출하고 그 결과가 `None`인 것들을 걸러냅니다." #: src/error/iter_result.md:33 msgid "Collect the failed items with `map_err()` and `filter_map()`" msgstr "`map_err()`와 `filter_map()`으로 실패한 항목 수집하기" #: src/error/iter_result.md:35 msgid "" "`map_err` calls a function with the error, so by adding that to the previous " "`filter_map` solution we can save them off to the side while iterating." msgstr "" "`map_err`은 에러와 함께 함수를 호출하므로, 이를 이전의 `filter_map` 방식에 추" "가하여 순회하는 동안 에러들을 따로 저장해둘 수 있습니다." #: src/error/iter_result.md:40 msgid "\"999\"" msgstr "\"999\"" #: src/error/iter_result.md:47 src/error/iter_result.md:80 #: src/error/iter_result.md:97 msgid "\"Numbers: {:?}\"" msgstr "\"숫자: {:?}\"" #: src/error/iter_result.md:48 src/error/iter_result.md:81 #: src/error/iter_result.md:98 msgid "\"Errors: {:?}\"" msgstr "\"에러: {:?}\"" #: src/error/iter_result.md:52 msgid "Fail the entire operation with `collect()`" msgstr "`collect()`를 사용하여 전체 연산을 실패로 처리하기" #: src/error/iter_result.md:54 msgid "" "`Result` implements `FromIterator` so that a vector of results " "(`Vec>`) can be turned into a result with a vector " "(`Result, E>`). Once an `Result::Err` is found, the iteration will " "terminate." msgstr "" "`Result`는 `FromIterator`를 구현하므로 결과들의 벡터(`Vec>`)를 " "벡터를 가진 결과(`Result, E>`)로 바꿀 수 있습니다. `Result::Err`이 발" "견되면 즉시 순회가 종료됩니다." #: src/error/iter_result.md:69 msgid "This same technique can be used with `Option`." msgstr "동일한 기술을 `Option`에 대해서도 사용할 수 있습니다." #: src/error/iter_result.md:71 msgid "Collect all valid values and failures with `partition()`" msgstr "`partition()`을 사용하여 모든 유효한 값과 실패를 수집하기" #: src/error/iter_result.md:85 msgid "" "When you look at the results, you'll note that everything is still wrapped " "in `Result`. A little more boilerplate is needed for this." msgstr "" "결과를 보면 모든 것이 여전히 `Result`로 감싸져 있음을 알 수 있습니다. 이를 위" "해서는 상용구 코드가 조금 더 필요합니다." #: src/std.md:3 msgid "" "The `std` library provides many custom types which expands drastically on " "the `primitives`. Some of these include:" msgstr "" "표준 라이브러리는 `기본 자료형`을 대폭 확장한 많은 사용자 정의 타입을 제공합" "니다. 이들 중 일부는 다음과 같습니다:" #: src/std.md:6 msgid "growable `String`s like: `\"hello world\"`" msgstr "가변 크기 `String`: 예: `\"hello world\"`" #: src/std.md:7 msgid "growable vectors: `[1, 2, 3]`" msgstr "가변 크기 벡터: `[1, 2, 3]`" #: src/std.md:8 msgid "optional types: `Option`" msgstr "선택적 타입: `Option`" #: src/std.md:9 msgid "error handling types: `Result`" msgstr "에러 핸들링 타입: `Result`" #: src/std.md:10 msgid "heap allocated pointers: `Box`" msgstr "힙 할당 포인터: `Box`" #: src/std.md:14 src/std_misc.md:14 msgid "" "[primitives](primitives.md) and [the std library](https://doc.rust-lang.org/" "std/)" msgstr "" "[기본 자료형](primitives.md)과 [표준 라이브러리](https://doc.rust-lang.org/" "std/)" #: src/std/box.md:3 msgid "" "All values in Rust are stack allocated by default. Values can be _boxed_ " "(allocated on the heap) by creating a `Box`. A box is a smart pointer to " "a heap allocated value of type `T`. When a box goes out of scope, its " "destructor is called, the inner object is destroyed, and the memory on the " "heap is freed." msgstr "" "Rust의 모든 값은 기본적으로 스택에 할당됩니다. `Box`를 생성함으로써 값을 *" "박싱*(힙에 할당)할 수 있습니다. 박스는 힙에 할당된 `T` 타입 값을 가리키는 스" "마트 포인터입니다. 박스가 스코프를 벗어나면 데스트럭터가 호출되어 내부 객체" "가 파괴되고 힙 메모리가 해제됩니다." #: src/std/box.md:8 msgid "" "Boxed values can be dereferenced using the `*` operator; this removes one " "layer of indirection." msgstr "" "박싱된 값은 `*` 연산자를 사용하여 역참조할 수 있습니다. 이는 한 단계의 간접 " "참조를 제거합니다." #: src/std/box.md:20 msgid "" "// A Rectangle can be specified by where its top left and bottom right\n" "// corners are in space\n" msgstr "" "// 사각형은 공간상에서의 왼쪽 상단과 오른쪽 하단\n" "// 꼭짓점 위치로 지정될 수 있습니다\n" #: src/std/box.md:34 msgid "// Allocate this point on the heap, and return a pointer to it\n" msgstr "// 이 점을 힙에 할당하고, 그에 대한 포인터를 반환합니다\n" #: src/std/box.md:39 msgid "" "// (all the type annotations are superfluous)\n" " // Stack allocated variables\n" msgstr "" "// (모든 타입 어노테이션은 불필요합니다)\n" " // 스택에 할당된 변수들\n" #: src/std/box.md:47 msgid "// Heap allocated rectangle\n" msgstr "// 힙에 할당된 사각형\n" #: src/std/box.md:53 msgid "// The output of functions can be boxed\n" msgstr "// 함수의 출력은 박싱될 수 있습니다\n" #: src/std/box.md:56 msgid "// Double indirection\n" msgstr "// 이중 간접 참조\n" #: src/std/box.md:59 msgid "\"Point occupies {} bytes on the stack\"" msgstr "\"Point는 스택에서 {} 바이트를 차지합니다\"" #: src/std/box.md:61 msgid "\"Rectangle occupies {} bytes on the stack\"" msgstr "\"Rectangle은 스택에서 {} 바이트를 차지합니다\"" #: src/std/box.md:64 msgid "// box size == pointer size\n" msgstr "// 박스 크기 == 포인터 크기\n" #: src/std/box.md:65 msgid "\"Boxed point occupies {} bytes on the stack\"" msgstr "\"박싱된 point는 스택에서 {} 바이트를 차지합니다\"" #: src/std/box.md:67 msgid "\"Boxed rectangle occupies {} bytes on the stack\"" msgstr "\"박싱된 rectangle은 스택에서 {} 바이트를 차지합니다\"" #: src/std/box.md:69 msgid "\"Boxed box occupies {} bytes on the stack\"" msgstr "\"박싱된 박스는 스택에서 {} 바이트를 차지합니다\"" #: src/std/box.md:72 msgid "// Copy the data contained in `boxed_point` into `unboxed_point`\n" msgstr "// `boxed_point`에 담긴 데이터를 `unboxed_point`로 복사합니다\n" #: src/std/box.md:74 msgid "\"Unboxed point occupies {} bytes on the stack\"" msgstr "\"박싱 해제된 point는 스택에서 {} 바이트를 차지합니다\"" #: src/std/vec.md:3 msgid "" "Vectors are re-sizable arrays. Like slices, their size is not known at " "compile time, but they can grow or shrink at any time. A vector is " "represented using 3 parameters:" msgstr "" "벡터는 크기 조절이 가능한 배열입니다. 슬라이스와 마찬가지로 크기를 컴파일 타" "임에 알 수 없지만, 언제든지 늘리거나 줄일 수 있습니다. 벡터는 3개의 파라미터" "로 표현됩니다:" #: src/std/vec.md:7 msgid "pointer to the data" msgstr "데이터에 대한 포인터" #: src/std/vec.md:8 msgid "length" msgstr "길이" #: src/std/vec.md:9 msgid "capacity" msgstr "용량" #: src/std/vec.md:11 msgid "" "The capacity indicates how much memory is reserved for the vector. The " "vector can grow as long as the length is smaller than the capacity. When " "this threshold needs to be surpassed, the vector is reallocated with a " "larger capacity." msgstr "" "용량은 벡터를 위해 예약된 메모리 양을 나타냅니다. 벡터는 길이가 용량보다 작" "은 동안에는 계속 늘어날 수 있습니다. 이 임계값을 넘어야 할 때, 벡터는 더 큰 " "용량으로 재할당됩니다." #: src/std/vec.md:17 msgid "// Iterators can be collected into vectors\n" msgstr "// 이터레이터는 벡터로 수집(collect)될 수 있습니다\n" #: src/std/vec.md:19 msgid "\"Collected (0..10) into: {:?}\"" msgstr "\"(0..10)을 다음으로 수집함: {:?}\"" #: src/std/vec.md:21 msgid "// The `vec!` macro can be used to initialize a vector\n" msgstr "// `vec!` 매크로는 벡터를 초기화하는 데 사용될 수 있습니다\n" #: src/std/vec.md:23 msgid "\"Initial vector: {:?}\"" msgstr "\"초기 벡터: {:?}\"" #: src/std/vec.md:25 msgid "// Insert new element at the end of the vector\n" msgstr "// 벡터 끝에 새로운 요소를 삽입합니다\n" #: src/std/vec.md:26 msgid "\"Push 4 into the vector\"" msgstr "\"벡터에 4를 푸시합니다\"" #: src/std/vec.md:28 msgid "\"Vector: {:?}\"" msgstr "\"벡터: {:?}\"" #: src/std/vec.md:30 msgid "// Error! Immutable vectors can't grow\n" msgstr "// 에러! 불변 벡터는 늘어날 수 없습니다\n" #: src/std/vec.md:34 msgid "" "// The `len` method yields the number of elements currently stored in a " "vector\n" msgstr "// `len` 메서드는 현재 벡터에 저장된 요소의 개수를 반환합니다\n" #: src/std/vec.md:35 msgid "\"Vector length: {}\"" msgstr "\"벡터 길이: {}\"" #: src/std/vec.md:37 msgid "// Indexing is done using the square brackets (indexing starts at 0)\n" msgstr "// 인덱싱은 대괄호를 사용하여 수행됩니다 (인덱싱은 0부터 시작합니다)\n" #: src/std/vec.md:38 msgid "\"Second element: {}\"" msgstr "\"두 번째 요소: {}\"" #: src/std/vec.md:40 msgid "// `pop` removes the last element from the vector and returns it\n" msgstr "// `pop`은 벡터에서 마지막 요소를 제거하고 이를 반환합니다\n" #: src/std/vec.md:41 msgid "\"Pop last element: {:?}\"" msgstr "\"마지막 요소 팝: {:?}\"" #: src/std/vec.md:43 msgid "// Out of bounds indexing yields a panic\n" msgstr "// 범위를 벗어난 인덱싱은 패닉을 일으킵니다\n" #: src/std/vec.md:44 msgid "\"Fourth element: {}\"" msgstr "\"네 번째 요소: {}\"" #: src/std/vec.md:47 msgid "// `Vector`s can be easily iterated over\n" msgstr "// 벡터는 쉽게 순회(iterate)될 수 있습니다\n" #: src/std/vec.md:48 msgid "\"Contents of xs:\"" msgstr "\"xs의 내용:\"" #: src/std/vec.md:53 msgid "" "// A `Vector` can also be iterated over while the iteration\n" " // count is enumerated in a separate variable (`i`)\n" msgstr "" "// 벡터는 반복 횟수가 별도의 변수(`i`)에 열거되면서 순회될 수도 있습니다\n" #: src/std/vec.md:56 msgid "\"In position {} we have value {}\"" msgstr "\"{} 위치에 {} 값이 있습니다\"" #: src/std/vec.md:59 msgid "" "// Thanks to `iter_mut`, mutable `Vector`s can also be iterated\n" " // over in a way that allows modifying each value\n" msgstr "" "// `iter_mut` 덕분에 가변 벡터도 각 값을 수정할 수 있는 방식으로\n" " // 순회될 수 있습니다\n" #: src/std/vec.md:64 msgid "\"Updated vector: {:?}\"" msgstr "\"업데이트된 벡터: {:?}\"" #: src/std/vec.md:68 msgid "" "More `Vec` methods can be found under the [std::vec](https://doc.rust-" "lang.org/std/vec/) module" msgstr "" "더 많은 `Vec` 메서드는 [std::vec](https://doc.rust-lang.org/std/vec/) 모듈에" "서 찾을 수 있습니다" #: src/std/str.md:3 msgid "The two most used string types in Rust are `String` and `&str`." msgstr "" "Rust에서 가장 많이 사용되는 두 가지 문자열 타입은 `String`과 `&str`입니다." #: src/std/str.md:5 msgid "" "A `String` is stored as a vector of bytes (`Vec`), but guaranteed to " "always be a valid UTF-8 sequence. `String` is heap allocated, growable and " "not null terminated." msgstr "" "`String`은 바이트 벡터(`Vec`)로 저장되지만, 항상 유효한 UTF-8 시퀀스임이 " "보장됩니다. `String`은 힙에 할당되며, 크기 조절이 가능하고 널 종료(null " "terminated)되지 않습니다." #: src/std/str.md:9 msgid "" "`&str` is a slice (`&[u8]`) that always points to a valid UTF-8 sequence, " "and can be used to view into a `String`, just like `&[T]` is a view into " "`Vec`." msgstr "" "`&str`은 항상 유효한 UTF-8 시퀀스를 가리키는 슬라이스(`&[u8]`)이며, `&[T]`가 " "`Vec`를 들여다보는 창(view)인 것과 마찬가지로 `String`을 들여다보는 데 사" "용될 수 있습니다." #: src/std/str.md:14 msgid "" "// (all the type annotations are superfluous)\n" " // A reference to a string allocated in read only memory\n" msgstr "" "// (모든 타입 어노테이션은 불필요합니다)\n" " // 읽기 전용 메모리에 할당된 문자열에 대한 참조\n" #: src/std/str.md:16 msgid "\"the quick brown fox jumps over the lazy dog\"" msgstr "\"the quick brown fox jumps over the lazy dog\"" #: src/std/str.md:17 msgid "\"Pangram: {}\"" msgstr "\"팬그램(Pangram): {}\"" #: src/std/str.md:19 msgid "// Iterate over words in reverse, no new string is allocated\n" msgstr "// 단어들을 역순으로 순회합니다. 새로운 문자열은 할당되지 않습니다\n" #: src/std/str.md:20 msgid "\"Words in reverse\"" msgstr "\"역순 단어들\"" #: src/std/str.md:25 msgid "// Copy chars into a vector, sort and remove duplicates\n" msgstr "// 문자들을 벡터로 복사하고, 정렬한 뒤 중복을 제거합니다\n" #: src/std/str.md:30 msgid "// Create an empty and growable `String`\n" msgstr "// 비어 있고 크기 조절 가능한 `String`을 생성합니다\n" #: src/std/str.md:33 msgid "// Insert a char at the end of string\n" msgstr "// 문자열 끝에 문자를 삽입합니다\n" #: src/std/str.md:35 msgid "// Insert a string at the end of string\n" msgstr "// 문자열 끝에 문자열을 삽입합니다\n" #: src/std/str.md:39 msgid "" "// The trimmed string is a slice to the original string, hence no new\n" " // allocation is performed\n" msgstr "" "// 트림된 문자열은 원본 문자열에 대한 슬라이스이므로,\n" "// 새로운 할당이 수행되지 않습니다\n" #: src/std/str.md:43 msgid "\"Used characters: {}\"" msgstr "\"사용된 문자들: {}\"" #: src/std/str.md:45 msgid "// Heap allocate a string\n" msgstr "// 문자열을 힙에 할당합니다\n" #: src/std/str.md:46 msgid "\"I like dogs\"" msgstr "\"I like dogs\"" #: src/std/str.md:47 msgid "// Allocate new memory and store the modified string there\n" msgstr "// 새로운 메모리를 할당하고 수정된 문자열을 그곳에 저장합니다\n" #: src/std/str.md:48 msgid "\"dog\"" msgstr "\"dog\"" #: src/std/str.md:48 msgid "\"cat\"" msgstr "\"cat\"" #: src/std/str.md:50 msgid "\"Alice says: {}\"" msgstr "\"앨리스가 말합니다: {}\"" #: src/std/str.md:51 msgid "\"Bob says: {}\"" msgstr "\"밥이 말합니다: {}\"" #: src/std/str.md:55 msgid "" "More `str`/`String` methods can be found under the [std::str](https://" "doc.rust-lang.org/std/str/) and [std::string](https://doc.rust-lang.org/std/" "string/) modules" msgstr "" "더 많은 `str`/`String` 메서드는 [std::str](https://doc.rust-lang.org/std/" "str/) 및 [std::string](https://doc.rust-lang.org/std/string/) 모듈에서 찾을 " "수 있습니다" #: src/std/str.md:60 msgid "Literals and escapes" msgstr "리터럴과 이스케이프" #: src/std/str.md:62 msgid "" "There are multiple ways to write string literals with special characters in " "them. All result in a similar `&str` so it's best to use the form that is " "the most convenient to write. Similarly there are multiple ways to write " "byte string literals, which all result in `&[u8; N]`." msgstr "" "특수 문자가 포함된 문자열 리터럴을 작성하는 방법은 여러 가지가 있습니다. 모" "두 비슷한 `&str`을 결과로 내므로 가장 작성하기 편리한 형식을 사용하는 것이 좋" "습니다. 마찬가지로 바이트 문자열 리터럴을 작성하는 방법도 여러 가지가 있으" "며, 모두 `&[u8; N]` 결과를 냅니다." #: src/std/str.md:67 msgid "" "Generally special characters are escaped with a backslash character: `\\`. " "This way you can add any character to your string, even unprintable ones and " "ones that you don't know how to type. If you want a literal backslash, " "escape it with another one: `\\\\`" msgstr "" "일반적으로 특수 문자는 백슬래시 문자 `\\`로 이스케이프됩니다. 이 방법을 통해 " "출력 불가능한 문자나 입력 방법을 모르는 문자 등 어떤 문자든 문자열에 추가할 " "수 있습니다. 백슬래시 자체를 리터럴로 원한다면 백슬래시 하나를 더 붙여 `\\\\`" "와 같이 이스케이프하세요." #: src/std/str.md:72 msgid "" "String or character literal delimiters occurring within a literal must be " "escaped: `\"\\\"\"`, `'\\''`." msgstr "" "리터럴 내에 나타나는 문자열 또는 문자 리터럴 구분자는 반드시 이스케이프해야 " "합니다: `\"\\\"\"`, `'\\''`." #: src/std/str.md:76 msgid "// You can use escapes to write bytes by their hexadecimal values...\n" msgstr "" "// 16진수 값을 사용하여 바이트를 작성하기 위해 이스케이프를 사용할 수 있습니" "다...\n" #: src/std/str.md:77 msgid "\"I'm writing \\x52\\x75\\x73\\x74!\"" msgstr "\"I'm writing \\x52\\x75\\x73\\x74!\"" #: src/std/str.md:78 msgid "\"What are you doing\\x3F (\\\\x3F means ?) {}\"" msgstr "\"What are you doing\\x3F (\\\\x3F는 ?를 의미합니다) {}\"" #: src/std/str.md:80 msgid "// ...or Unicode code points.\n" msgstr "// ...또는 유니코드 코드 포인트.\n" #: src/std/str.md:81 msgid "\"\\u{211D}\"" msgstr "\"\\u{211D}\"" #: src/std/str.md:82 msgid "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\"" msgstr "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\"" #: src/std/str.md:84 msgid "\"Unicode character {} (U+211D) is called {}\"" msgstr "\"유니코드 문자 {} (U+211D)는 {}라고 불립니다\"" #: src/std/str.md:88 msgid "" "\"String literals\n" " can span multiple lines.\n" " The linebreak and indentation here ->\\\n" " <- can be escaped too!\"" msgstr "" "\"문자열 리터럴은\n" " 여러 줄에 걸쳐 있을 수 있습니다.\n" " 여기서의 줄바꿈과 들여쓰기 ->\\\n" " <- 역시 이스케이프될 수 있습니다!\"" #: src/std/str.md:96 msgid "" "Sometimes there are just too many characters that need to be escaped or it's " "just much more convenient to write a string out as-is. This is where raw " "string literals come into play." msgstr "" "때때로 이스케이프해야 할 문자가 너무 많거나 문자열을 있는 그대로 작성하는 것" "이 훨씬 더 편리할 때가 있습니다. 이때 로우(raw) 문자열 리터럴이 사용됩니다." #: src/std/str.md:101 msgid "r\"Escapes don't work here: \\x3F \\u{211D}\"" msgstr "r\"이스케이프가 여기선 작동하지 않습니다: \\x3F \\u{211D}\"" #: src/std/str.md:104 msgid "// If you need quotes in a raw string, add a pair of #s\n" msgstr "// 로우 문자열에서 따옴표가 필요하다면, # 쌍을 추가하세요\n" #: src/std/str.md:105 msgid "r#\"And then I said: \"There is no escape!\"\"#" msgstr "r#\"And then I said: \"There is no escape!\"\"#" #: src/std/str.md:108 msgid "" "// If you need \"# in your string, just use more #s in the delimiter.\n" " // You can use up to 255 #s.\n" msgstr "" "// 문자열 내에 \"#가 필요하다면, 구분자에 더 많은 #를 사용하세요.\n" " // 최대 255개의 #를 사용할 수 있습니다.\n" #: src/std/str.md:110 msgid "r###\"A string with \"# in it. And even \"##!\"###" msgstr "r###\"A string with \"# in it. And even \"##!\"###" #: src/std/str.md:115 msgid "" "Want a string that's not UTF-8? (Remember, `str` and `String` must be valid " "UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings " "to the rescue!" msgstr "" "UTF-8이 아닌 문자열을 원하시나요? (`str`과 `String`은 반드시 유효한 UTF-8이어" "야 함을 기억하세요). 아니면 대부분이 텍스트인 바이트 배열을 원하시나요? 바이" "트 문자열이 해결해 드립니다!" #: src/std/str.md:122 msgid "// Note that this is not actually a `&str`\n" msgstr "// 이는 실제로 `&str`이 아님에 유의하세요\n" #: src/std/str.md:123 msgid "b\"this is a byte string\"" msgstr "b\"this is a byte string\"" #: src/std/str.md:125 msgid "" "// Byte arrays don't have the `Display` trait, so printing them is a bit " "limited\n" msgstr "" "// 바이트 배열은 `Display` 트레이트를 가지고 있지 않으므로, 출력에 다소 제한" "이 있습니다\n" #: src/std/str.md:126 msgid "\"A byte string: {:?}\"" msgstr "\"바이트 문자열: {:?}\"" #: src/std/str.md:128 msgid "// Byte strings can have byte escapes...\n" msgstr "// 바이트 문자열은 바이트 이스케이프를 가질 수 있습니다...\n" #: src/std/str.md:129 msgid "b\"\\x52\\x75\\x73\\x74 as bytes\"" msgstr "b\"\\x52\\x75\\x73\\x74 as bytes\"" #: src/std/str.md:130 msgid "" "// ...but no unicode escapes\n" " // let escaped = b\"\\u{211D} is not allowed\";\n" msgstr "" "// ...하지만 유니코드 이스케이프는 허용되지 않습니다\n" " // let escaped = b\"\\u{211D} is not allowed\";\n" #: src/std/str.md:132 msgid "\"Some escaped bytes: {:?}\"" msgstr "\"일부 이스케이프된 바이트: {:?}\"" #: src/std/str.md:135 msgid "// Raw byte strings work just like raw strings\n" msgstr "// 로우 바이트 문자열은 로우 문자열과 똑같이 작동합니다\n" #: src/std/str.md:136 msgid "br\"\\u{211D} is not escaped here\"" msgstr "br\"\\u{211D} is not escaped here\"" #: src/std/str.md:139 msgid "// Converting a byte array to `str` can fail\n" msgstr "// 바이트 배열을 `str`로 변환하는 것은 실패할 수 있습니다\n" #: src/std/str.md:141 msgid "\"And the same as text: '{}'\"" msgstr "\"그리고 텍스트로 변환하면: '{}'\"" #: src/std/str.md:144 msgid "" "br#\"You can also use \"fancier\" formatting, \\\n" " like with normal raw strings\"#" msgstr "" "br#\"일반 로우 문자열처럼, \\\n" " 더 \"화려한\" 포맷팅을 사용할 수도 있습니다\"#" #: src/std/str.md:147 msgid "// Byte strings don't have to be UTF-8\n" msgstr "// 바이트 문자열은 UTF-8일 필요가 없습니다\n" #: src/std/str.md:148 msgid "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" msgstr "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" #: src/std/str.md:148 msgid "// \"ようこそ\" in SHIFT-JIS\n" msgstr "// SHIFT-JIS 인코딩의 \"ようこそ\"(환영합니다)\n" #: src/std/str.md:150 msgid "// But then they can't always be converted to `str`\n" msgstr "// 그런 경우에는 항상 `str`로 변환될 수는 없습니다\n" #: src/std/str.md:152 msgid "\"Conversion successful: '{}'\"" msgstr "\"변환 성공: '{}'\"" #: src/std/str.md:153 msgid "\"Conversion failed: {:?}\"" msgstr "\"변환 실패: {:?}\"" #: src/std/str.md:158 msgid "" "For conversions between character encodings check out the [encoding](https://" "crates.io/crates/encoding) crate." msgstr "" "문자 인코딩 간의 변환에 대해서는 [encoding](https://crates.io/crates/" "encoding) 크레이트를 확인해 보세요." #: src/std/str.md:160 msgid "" "A more detailed listing of the ways to write string literals and escape " "characters is given in the ['Tokens' chapter](https://doc.rust-lang.org/" "reference/tokens.html) of the Rust Reference." msgstr "" "문자열 리터럴을 작성하고 문자를 이스케이프하는 방법에 대한 더 자세한 목록은 " "Rust 레퍼런스의 ['Tokens' 장](https://doc.rust-lang.org/reference/" "tokens.html)에 나와 있습니다." #: src/std/option.md:3 msgid "" "Sometimes it's desirable to catch the failure of some parts of a program " "instead of calling `panic!`; this can be accomplished using the `Option` " "enum." msgstr "" "때로는 프로그램의 일부에서 발생하는 실패를 `panic!`을 호출하는 대신 포착하고 " "싶을 때가 있습니다. 이는 `Option` 열거형을 사용하여 수행할 수 있습니다." #: src/std/option.md:6 msgid "The `Option` enum has two variants:" msgstr "`Option` 열거형은 두 가지 변체를 가집니다:" #: src/std/option.md:8 msgid "`None`, to indicate failure or lack of value, and" msgstr "`None`: 실패나 값의 부재를 나타냄" #: src/std/option.md:9 msgid "`Some(value)`, a tuple struct that wraps a `value` with type `T`." msgstr "`Some(value)`: `T` 타입의 `value`를 감싸는 튜플 구조체" #: src/std/option.md:12 msgid "// An integer division that doesn't `panic!`\n" msgstr "// `panic!`을 일으키지 않는 정수 나눗셈\n" #: src/std/option.md:15 msgid "// Failure is represented as the `None` variant\n" msgstr "// 실패는 `None` 변체로 표현됩니다\n" #: src/std/option.md:18 msgid "// Result is wrapped in a `Some` variant\n" msgstr "// 결과는 `Some` 변체로 감싸집니다\n" #: src/std/option.md:22 msgid "// This function handles a division that may not succeed\n" msgstr "// 이 함수는 성공하지 않을 수 있는 나눗셈을 처리합니다\n" #: src/std/option.md:25 msgid "// `Option` values can be pattern matched, just like other enums\n" msgstr "// `Option` 값은 다른 열거형과 마찬가지로 패턴 매칭될 수 있습니다\n" #: src/std/option.md:27 msgid "\"{} / {} failed!\"" msgstr "\"{} / {} 실패!\"" #: src/std/option.md:29 msgid "\"{} / {} = {}\"" msgstr "\"{} / {} = {}\"" #: src/std/option.md:38 msgid "// Binding `None` to a variable needs to be type annotated\n" msgstr "// `None`을 변수에 바인딩할 때는 타입 어노테이션이 필요합니다\n" #: src/std/option.md:44 msgid "// Unwrapping a `Some` variant will extract the value wrapped.\n" msgstr "// `Some` 변체의 래핑을 해제(unwrap)하면 감싸진 값을 추출합니다.\n" #: src/std/option.md:45 src/std/option.md:48 msgid "\"{:?} unwraps to {:?}\"" msgstr "\"{:?}의 래핑을 해제하면 {:?}가 됩니다\"" #: src/std/option.md:47 msgid "// Unwrapping a `None` variant will `panic!`\n" msgstr "// `None` 변체의 래핑을 해제하면 `panic!`이 발생합니다\n" #: src/std/result.md:3 msgid "" "We've seen that the `Option` enum can be used as a return value from " "functions that may fail, where `None` can be returned to indicate failure. " "However, sometimes it is important to express _why_ an operation failed. To " "do this we have the `Result` enum." msgstr "" "우리는 실패할 수 있는 함수로부터 `None`을 반환하여 실패를 나타낼 때 `Option` " "열거형이 사용될 수 있음을 보았습니다. 하지만 때로는 작업이 *왜* 실패했는지 표" "현하는 것이 중요합니다. 이를 위해 우리는 `Result` 열거형을 가지고 있습니다." #: src/std/result.md:8 msgid "The `Result` enum has two variants:" msgstr "`Result` 열거형은 두 가지 변체를 가집니다:" #: src/std/result.md:10 msgid "" "`Ok(value)` which indicates that the operation succeeded, and wraps the " "`value` returned by the operation. (`value` has type `T`)" msgstr "" "`Ok(value)`: 작업이 성공했음을 나타내며, 작업에 의해 반환된 `value`를 감쌉니" "다. (`value`는 `T` 타입을 가집니다)" #: src/std/result.md:12 msgid "" "`Err(why)`, which indicates that the operation failed, and wraps `why`, " "which (hopefully) explains the cause of the failure. (`why` has type `E`)" msgstr "" "`Err(why)`: 작업이 실패했음을 나타내며, 실패의 원인을 설명하는 (바라건대) " "`why`를 감쌉니다. (`why`는 `E` 타입을 가집니다)" #: src/std/result.md:17 msgid "// Mathematical \"errors\" we want to catch\n" msgstr "// 우리가 포착하고 싶은 수학적 \"에러\"들\n" #: src/std/result.md:29 msgid "" "// This operation would `fail`, instead let's return the reason of\n" " // the failure wrapped in `Err`\n" msgstr "" "// 이 작업은 실패하게 되므로, 대신 실패의 원인을\n" "// `Err`로 감싸서 반환합시다\n" #: src/std/result.md:33 msgid "// This operation is valid, return the result wrapped in `Ok`\n" msgstr "// 이 작업은 유효하므로, 결과를 `Ok`로 감싸서 반환합니다\n" #: src/std/result.md:54 msgid "// `op(x, y)` === `sqrt(ln(x / y))`\n" msgstr "// `op(x, y)` === `sqrt(ln(x / y))`\n" #: src/std/result.md:57 msgid "// This is a three level match pyramid!\n" msgstr "// 이것은 3단계 `match` 피라미드입니다!\n" #: src/std/result.md:71 msgid "// Will this fail?\n" msgstr "// 이것은 실패할까요?\n" #: src/std/result/question_mark.md:3 msgid "" "Chaining results using match can get pretty untidy; luckily, the `?` " "operator can be used to make things pretty again. `?` is used at the end of " "an expression returning a `Result`, and is equivalent to a match expression, " "where the `Err(err)` branch expands to an early `return " "Err(From::from(err))`, and the `Ok(ok)` branch expands to an `ok` expression." msgstr "" "`match`를 사용하여 결과를 체인으로 연결하는 것은 꽤 지저분해질 수 있습니다. " "다행히 `?` 연산자를 사용하여 다시 깔끔하게 만들 수 있습니다. `?`는 `Result`" "를 반환하는 표현식의 끝에 사용되며, `match` 표현식과 동일하게 작동합니다. 여" "기서 `Err(err)` 가지는 조기 리턴인 `return Err(From::from(err))`로 확장되고, " "`Ok(ok)` 가지는 `ok` 표현식으로 확장됩니다." #: src/std/result/question_mark.md:44 msgid "// Intermediate function\n" msgstr "// 중간 함수\n" #: src/std/result/question_mark.md:46 msgid "// if `div` \"fails\", then `DivisionByZero` will be `return`ed\n" msgstr "// 만약 `div`가 \"실패\"하면, `DivisionByZero`가 반환됩니다\n" #: src/std/result/question_mark.md:49 msgid "// if `ln` \"fails\", then `NonPositiveLogarithm` will be `return`ed\n" msgstr "// 만약 `ln`가 \"실패\"하면, `NonPositiveLogarithm`이 반환됩니다\n" #: src/std/result/question_mark.md:59 msgid "\"logarithm of non-positive number\"" msgstr "\"0 이하의 수에 대한 로그\"" #: src/std/result/question_mark.md:61 src/std/panic.md:15 msgid "\"division by zero\"" msgstr "\"0으로 나누기\"" #: src/std/result/question_mark.md:63 msgid "\"square root of negative number\"" msgstr "\"음수의 제곱근\"" #: src/std/result/question_mark.md:75 msgid "" "Be sure to check the [documentation](https://doc.rust-lang.org/std/result/" "index.html), as there are many methods to map/compose `Result`." msgstr "" "`Result`를 매핑하거나 구성(compose)하는 많은 메서드들이 있으니, 반드시 [문서]" "(https://doc.rust-lang.org/std/result/index.html)를 확인해 보세요." #: src/std/panic.md:3 msgid "" "The `panic!` macro can be used to generate a panic and start unwinding its " "stack. While unwinding, the runtime will take care of freeing all the " "resources _owned_ by the thread by calling the destructor of all its objects." msgstr "" "`panic!` 매크로는 패닉을 생성하고 스택 되감기(unwinding)를 시작하는 데 사용" "될 수 있습니다. 되감기를 하는 동안, 런타임은 모든 객체의 데스트럭터를 호출하" "여 해당 스레드가 소유한 모든 리소스를 해제합니다." #: src/std/panic.md:7 msgid "" "Since we are dealing with programs with only one thread, `panic!` will cause " "the program to report the panic message and exit." msgstr "" "우리는 단일 스레드 프로그램만 다루고 있으므로, `panic!`은 프로그램이 패닉 메" "시지를 보고하고 종료하게 만듭니다." #: src/std/panic.md:11 msgid "// Re-implementation of integer division (/)\n" msgstr "// 정수 나눗셈(/)의 재구현\n" #: src/std/panic.md:14 msgid "// Division by zero triggers a panic\n" msgstr "// 0으로 나누기는 패닉을 트리거합니다\n" #: src/std/panic.md:20 msgid "// The `main` task\n" msgstr "// 메인 태스크\n" #: src/std/panic.md:23 msgid "// Heap allocated integer\n" msgstr "// 힙 할당 정수\n" #: src/std/panic.md:26 msgid "// This operation will trigger a task failure\n" msgstr "// 이 작업은 태스크 실패를 트리거합니다\n" #: src/std/panic.md:29 msgid "\"This point won't be reached!\"" msgstr "\"이 지점에는 도달하지 않습니다!\"" #: src/std/panic.md:31 msgid "// `_x` should get destroyed at this point\n" msgstr "// 이 지점에서 `_x`가 파괴되어야 합니다\n" #: src/std/panic.md:35 msgid "Let's check that `panic!` doesn't leak memory." msgstr "`panic!`이 메모리를 누수하지 않는지 확인해 봅시다." #: src/std/hash.md:3 msgid "" "Where vectors store values by an integer index, `HashMap`s store values by " "key. `HashMap` keys can be booleans, integers, strings, or any other type " "that implements the `Eq` and `Hash` traits. More on this in the next section." msgstr "" "벡터가 정수 인덱스로 값을 저장하는 반면, `HashMap`은 키(key)로 값을 저장합니" "다. `HashMap`의 키는 불리언, 정수, 문자열 또는 `Eq`와 `Hash` 트레이트를 구현" "하는 임의의 다른 타입이 될 수 있습니다. 이에 대해서는 다음 섹션에서 자세히 다" "룹니다." #: src/std/hash.md:8 msgid "" "Like vectors, `HashMap`s are growable, but HashMaps can also shrink " "themselves when they have excess space. You can create a HashMap with a " "certain starting capacity using `HashMap::with_capacity(uint)`, or use " "`HashMap::new()` to get a HashMap with a default initial capacity " "(recommended)." msgstr "" "벡터와 마찬가지로 `HashMap`은 늘어날 수 있지만, 공간이 남을 때는 스스로 줄어" "들 수도 있습니다. `HashMap::with_capacity(uint)`를 사용하여 특정 시작 용량으" "로 HashMap을 생성하거나, `HashMap::new()`를 사용하여 기본 초기 용량을 가진 " "HashMap을 얻을 수 있습니다(권장됨)." #: src/std/hash.md:19 src/std/hash.md:30 msgid "\"798-1364\"" msgstr "\"798-1364\"" #: src/std/hash.md:19 msgid "" "\"We're sorry, the call cannot be completed as dialed.\n" " Please hang up and try again.\"" msgstr "" "\"죄송합니다, 전화 연결을 할 수 없습니다.\n" " 전화를 끊고 다시 시도해 주세요.\"" #: src/std/hash.md:21 src/std/hash.md:31 msgid "\"645-7689\"" msgstr "\"645-7689\"" #: src/std/hash.md:21 msgid "" "\"Hello, this is Mr. Awesome's Pizza. My name is Fred.\n" " What can I get for you today?\"" msgstr "" "\"안녕하세요, 어썸 피자입니다. 저는 프레드라고 합니다.\n" " 오늘 무엇을 도와드릴까요?\"" #: src/std/hash.md:23 msgid "\"Hi! Who is this again?\"" msgstr "\"안녕! 누구시더라?\"" #: src/std/hash.md:30 src/std/hash.md:36 src/std/hash.md:43 msgid "\"Daniel\"" msgstr "\"다니엘\"" #: src/std/hash.md:31 src/std/hash.md:45 src/std/hash.md:50 msgid "\"Ashley\"" msgstr "\"애슐리\"" #: src/std/hash.md:32 msgid "\"Katie\"" msgstr "\"케이티\"" #: src/std/hash.md:32 msgid "\"435-8291\"" msgstr "\"435-8291\"" #: src/std/hash.md:33 msgid "\"Robert\"" msgstr "\"로버트\"" #: src/std/hash.md:33 msgid "\"956-1745\"" msgstr "\"956-1745\"" #: src/std/hash.md:35 msgid "// Takes a reference and returns Option<&V>\n" msgstr "// 참조를 인자로 받아 `Option<&V>`를 반환합니다\n" #: src/std/hash.md:37 msgid "\"Calling Daniel: {}\"" msgstr "\"다니엘에게 전화 거는 중: {}\"" #: src/std/hash.md:38 msgid "\"Don't have Daniel's number.\"" msgstr "\"다니엘의 번호가 없습니다.\"" #: src/std/hash.md:41 msgid "" "// `HashMap::insert()` returns `None`\n" " // if the inserted value is new, `Some(value)` otherwise\n" msgstr "" "// `HashMap::insert()`는 삽입된 값이 새로운 것이면 `None`을,\n" " // 그렇지 않으면 `Some(value)`를 반환합니다\n" #: src/std/hash.md:43 msgid "\"164-6743\"" msgstr "\"164-6743\"" #: src/std/hash.md:46 msgid "\"Calling Ashley: {}\"" msgstr "\"애슐리에게 전화 거는 중: {}\"" #: src/std/hash.md:47 msgid "\"Don't have Ashley's number.\"" msgstr "\"애슐리의 번호가 없습니다.\"" #: src/std/hash.md:52 msgid "" "// `HashMap::iter()` returns an iterator that yields\n" " // (&'a key, &'a value) pairs in arbitrary order.\n" msgstr "" "// `HashMap::iter()`는 (&'a key, &'a value) 쌍을\n" " // 임의의 순서로 내놓는 이터레이터를 반환합니다.\n" #: src/std/hash.md:55 msgid "\"Calling {}: {}\"" msgstr "\"{}에게 전화 거는 중: {}\"" #: src/std/hash.md:60 msgid "" "For more information on how hashing and hash maps (sometimes called hash " "tables) work, have a look at [Hash Table Wikipedia](https://en.wikipedia.org/" "wiki/Hash_table)" msgstr "" "해싱과 해시 맵(때때로 해시 테이블이라고도 불림)이 어떻게 작동하는지에 대한 " "더 자세한 정보는 [Wikipedia의 해시 테이블](https://en.wikipedia.org/wiki/" "Hash_table)을 참조하세요." #: src/std/hash/alt_key_types.md:3 msgid "" "Any type that implements the `Eq` and `Hash` traits can be a key in " "`HashMap`. This includes:" msgstr "" "`Eq`와 `Hash` 트레이트를 구현하는 어떤 타입이든 `HashMap`의 키가 될 수 있습니" "다. 여기에는 다음이 포함됩니다:" #: src/std/hash/alt_key_types.md:6 msgid "`bool` (though not very useful since there are only two possible keys)" msgstr "`bool` (가능한 키가 두 개뿐이라 그리 유용하진 않지만요)" #: src/std/hash/alt_key_types.md:7 msgid "`int`, `uint`, and all variations thereof" msgstr "`int`, `uint` 및 그 모든 변형들" #: src/std/hash/alt_key_types.md:8 msgid "" "`String` and `&str` (protip: you can have a `HashMap` keyed by `String` and " "call `.get()` with an `&str`)" msgstr "" "`String`과 `&str` (꿀팁: `String`을 키로 하는 `HashMap`을 만들고 `&str`을 사" "용하여 `.get()`을 호출할 수 있습니다)" #: src/std/hash/alt_key_types.md:11 msgid "" "Note that `f32` and `f64` do _not_ implement `Hash`, likely because " "[floating-point precision errors](https://en.wikipedia.org/wiki/" "Floating_point#Accuracy_problems) would make using them as hashmap keys " "horribly error-prone." msgstr "" "`f32`와 `f64`는 `Hash`를 구현하지 않는다는 점에 유의하세요. 아마도 [부동 소수" "점 정밀도 에러](https://en.wikipedia.org/wiki/" "Floating_point#Accuracy_problems)로 인해 이들을 해시 맵 키로 사용하는 것이 극" "도로 에러에 취약해질 수 있기 때문일 것입니다." #: src/std/hash/alt_key_types.md:15 msgid "" "All collection classes implement `Eq` and `Hash` if their contained type " "also respectively implements `Eq` and `Hash`. For example, `Vec` will " "implement `Hash` if `T` implements `Hash`." msgstr "" "모든 컬렉션 클래스는 포함된 타입이 각각 `Eq`와 `Hash`를 구현한다면 `Eq`와 " "`Hash`를 구현합니다. 예를 들어, `Vec`는 `T`가 `Hash`를 구현한다면 `Hash`" "를 구현합니다." #: src/std/hash/alt_key_types.md:19 msgid "" "You can easily implement `Eq` and `Hash` for a custom type with just one " "line: `#[derive(PartialEq, Eq, Hash)]`" msgstr "" "단 한 줄의 코드로 커스텀 타입에 대해 `Eq`와 `Hash`를 쉽게 구현할 수 있습니" "다: `#[derive(PartialEq, Eq, Hash)]`" #: src/std/hash/alt_key_types.md:22 msgid "" "The compiler will do the rest. If you want more control over the details, " "you can implement `Eq` and/or `Hash` yourself. This guide will not cover the " "specifics of implementing `Hash`." msgstr "" "컴파일러가 나머지를 알아서 할 것입니다. 만약 세부 사항을 더 제어하고 싶다면, " "`Eq`나 `Hash`를 직접 구현할 수 있습니다. 이 가이드에서는 `Hash` 구현의 구체적" "인 내용은 다루지 않습니다." #: src/std/hash/alt_key_types.md:26 msgid "" "To play around with using a `struct` in `HashMap`, let's try making a very " "simple user logon system:" msgstr "" "`HashMap`에서 `struct`를 사용하는 것을 연습해 보기 위해, 매우 간단한 사용자 " "로그인 시스템을 만들어 봅시다:" #: src/std/hash/alt_key_types.md:31 msgid "// Eq requires that you derive PartialEq on the type.\n" msgstr "// Eq는 해당 타입에 대해 PartialEq를 유도(derive)할 것을 요구합니다.\n" #: src/std/hash/alt_key_types.md:48 msgid "\"Username: {}\"" msgstr "\"사용자 이름: {}\"" #: src/std/hash/alt_key_types.md:49 msgid "\"Password: {}\"" msgstr "\"비밀번호: {}\"" #: src/std/hash/alt_key_types.md:50 msgid "\"Attempting logon...\"" msgstr "\"로그인 시도 중...\"" #: src/std/hash/alt_key_types.md:59 msgid "\"Successful logon!\"" msgstr "\"로그인 성공!\"" #: src/std/hash/alt_key_types.md:60 msgid "\"Name: {}\"" msgstr "\"이름: {}\"" #: src/std/hash/alt_key_types.md:61 msgid "\"Email: {}\"" msgstr "\"이메일: {}\"" #: src/std/hash/alt_key_types.md:63 msgid "\"Login failed!\"" msgstr "\"로그인 실패!\"" #: src/std/hash/alt_key_types.md:71 src/std/hash/alt_key_types.md:82 #: src/std/hash/alt_key_types.md:84 msgid "\"j.everyman\"" msgstr "\"j.everyman\"" #: src/std/hash/alt_key_types.md:72 src/std/hash/alt_key_types.md:84 msgid "\"password123\"" msgstr "\"password123\"" #: src/std/hash/alt_key_types.md:76 msgid "\"John Everyman\"" msgstr "\"John Everyman\"" #: src/std/hash/alt_key_types.md:77 msgid "\"j.everyman@email.com\"" msgstr "\"j.everyman@email.com\"" #: src/std/hash/alt_key_types.md:82 msgid "\"psasword123\"" msgstr "\"psasword123\"" #: src/std/hash/hashset.md:3 msgid "" "Consider a `HashSet` as a `HashMap` where we just care about the keys " "( `HashSet` is, in actuality, just a wrapper around `HashMap`)." msgstr "" "`HashSet`을 키에만 관심이 있는 `HashMap`이라고 생각해보세요 (`HashSet`는 " "실제로 `HashMap`의 래퍼(wrapper)일 뿐입니다)." #: src/std/hash/hashset.md:6 msgid "" "\"What's the point of that?\" you ask. \"I could just store the keys in a " "`Vec`.\"" msgstr "" "\"그게 무슨 소용이죠?\"라고 물으실 수 있습니다. \"그냥 키를 `Vec`에 저장할 수" "도 있잖아요.\"" #: src/std/hash/hashset.md:8 msgid "" "A `HashSet`'s unique feature is that it is guaranteed to not have duplicate " "elements. That's the contract that any set collection fulfills. `HashSet` is " "just one implementation. (see also: [`BTreeSet`](https://doc.rust-lang.org/" "std/collections/struct.BTreeSet.html))" msgstr "" "`HashSet`의 고유한 특징은 중복된 요소가 없음을 보장한다는 것입니다. 이는 모" "든 집합(set) 컬렉션이 지키는 계약입니다. `HashSet`은 그 중 하나의 구현일 뿐입" "니다. (참고: [`BTreeSet`](https://doc.rust-lang.org/std/collections/" "struct.BTreeSet.html))" #: src/std/hash/hashset.md:13 msgid "" "If you insert a value that is already present in the `HashSet`, (i.e. the " "new value is equal to the existing and they both have the same hash), then " "the new value will replace the old." msgstr "" "이미 `HashSet`에 존재하는 값을 삽입하면 (즉, 새 값이 기존 값과 같고 해시도 같" "다면), 새 값이 기존 값을 대체하게 됩니다." #: src/std/hash/hashset.md:17 msgid "" "This is great for when you never want more than one of something, or when " "you want to know if you've already got something." msgstr "" "이는 무언가를 중복 없이 유지하고 싶을 때나, 이미 가지고 있는지 알고 싶을 때 " "매우 유용합니다." #: src/std/hash/hashset.md:20 msgid "But sets can do more than that." msgstr "하지만 집합은 그 이상의 일을 할 수 있습니다." #: src/std/hash/hashset.md:22 msgid "" "Sets have 4 primary operations (all of the following calls return an " "iterator):" msgstr "" "집합은 4가지 주요 연산을 가집니다 (다음 호출들은 모두 이터레이터를 반환합니" "다):" #: src/std/hash/hashset.md:24 msgid "`union`: get all the unique elements in both sets." msgstr "`union`(합집합): 두 집합에 있는 모든 고유한 요소들을 가져옵니다." #: src/std/hash/hashset.md:26 msgid "" "`difference`: get all the elements that are in the first set but not the " "second." msgstr "" "`difference`(차집합): 첫 번째 집합에는 있지만 두 번째 집합에는 없는 모든 요소" "들을 가져옵니다." #: src/std/hash/hashset.md:28 msgid "`intersection`: get all the elements that are only in _both_ sets." msgstr "" "`intersection`(교집합): 오직 *양쪽* 집합 모두에 있는 모든 요소들을 가져옵니" "다." #: src/std/hash/hashset.md:30 msgid "" "`symmetric_difference`: get all the elements that are in one set or the " "other, but _not_ both." msgstr "" "`symmetric_difference`(대칭차집합): 한쪽 집합에는 있지만 *양쪽 모두*에 있지" "는 않은 모든 요소들을 가져옵니다." #: src/std/hash/hashset.md:33 msgid "Try all of these in the following example:" msgstr "다음 예제에서 이들 모두를 시도해 보세요:" #: src/std/hash/hashset.md:45 msgid "" "// `HashSet::insert()` returns false if\n" " // there was a value already present.\n" msgstr "// `HashSet::insert()`는 값이 이미 존재하면 false를 반환합니다.\n" #: src/std/hash/hashset.md:47 msgid "\"Value 4 is already in set B!\"" msgstr "\"값 4는 이미 집합 B에 있습니다!\"" #: src/std/hash/hashset.md:52 msgid "" "// If a collection's element type implements `Debug`,\n" " // then the collection implements `Debug`.\n" " // It usually prints its elements in the format `[elem1, elem2, ...]`\n" msgstr "" "// 컬렉션의 요소 타입이 `Debug`를 구현한다면,\n" "// 컬렉션도 `Debug`를 구현합니다.\n" "// 보통 `[elem1, elem2, ...]` 형식으로 요소를 출력합니다.\n" #: src/std/hash/hashset.md:55 msgid "\"A: {:?}\"" msgstr "\"A: {:?}\"" #: src/std/hash/hashset.md:56 msgid "\"B: {:?}\"" msgstr "\"B: {:?}\"" #: src/std/hash/hashset.md:58 msgid "// Print [1, 2, 3, 4, 5] in arbitrary order\n" msgstr "// [1, 2, 3, 4, 5]를 임의의 순서로 출력합니다\n" #: src/std/hash/hashset.md:59 msgid "\"Union: {:?}\"" msgstr "\"합집합: {:?}\"" #: src/std/hash/hashset.md:61 msgid "// This should print [1]\n" msgstr "// 이는 [1]을 출력해야 합니다\n" #: src/std/hash/hashset.md:62 msgid "\"Difference: {:?}\"" msgstr "\"차집합: {:?}\"" #: src/std/hash/hashset.md:64 msgid "// Print [2, 3, 4] in arbitrary order.\n" msgstr "// [2, 3, 4]를 임의의 순서로 출력합니다.\n" #: src/std/hash/hashset.md:65 msgid "\"Intersection: {:?}\"" msgstr "\"교집합: {:?}\"" #: src/std/hash/hashset.md:67 msgid "// Print [1, 5]\n" msgstr "// [1, 5]를 출력합니다\n" #: src/std/hash/hashset.md:68 msgid "\"Symmetric Difference: {:?}\"" msgstr "\"대칭차집합: {:?}\"" #: src/std/hash/hashset.md:73 msgid "" "(Examples are adapted from the [documentation.](https://doc.rust-lang.org/" "std/collections/struct.HashSet.html#method.difference))" msgstr "" "(예제는 [문서](https://doc.rust-lang.org/std/collections/" "struct.HashSet.html#method.difference)에서 발췌 및 수정되었습니다.)" #: src/std/rc.md:3 msgid "" "When multiple ownership is needed, `Rc`(Reference Counting) can be used. " "`Rc` keeps track of the number of the references which means the number of " "owners of the value wrapped inside an `Rc`." msgstr "" "다중 소유권이 필요한 경우, `Rc`(참조 횟수 계산, Reference Counting)를 사용할 " "수 있습니다. `Rc`는 참조의 개수를 추적하며, 이는 `Rc` 내부에 감싸진 값의 소유" "자 수를 의미합니다." #: src/std/rc.md:7 msgid "" "Reference count of an `Rc` increases by 1 whenever an `Rc` is cloned, and " "decreases by 1 whenever one cloned `Rc` is dropped out of the scope. When an " "`Rc`'s reference count becomes zero (which means there are no remaining " "owners), both the `Rc` and the value are all dropped." msgstr "" "`Rc`의 참조 횟수는 `Rc`가 클론될 때마다 1씩 증가하고, 클론된 `Rc`가 스코프를 " "벗어날 때마다 1씩 감소합니다. `Rc`의 참조 횟수가 0이 되면 (즉, 남은 소유자가 " "없으면), `Rc`와 그 내부의 값 모두 해제됩니다." #: src/std/rc.md:12 msgid "" "Cloning an `Rc` never performs a deep copy. Cloning creates just another " "pointer to the wrapped value, and increments the count." msgstr "" "`Rc`를 클론하는 것은 결코 깊은 복사(deep copy)를 수행하지 않습니다. 클론은 단" "지 감싸진 값을 가리키는 또 다른 포인터를 생성하고, 횟수를 증가시킬 뿐입니다." #: src/std/rc.md:19 msgid "\"Rc examples\"" msgstr "\"Rc 예제\"" #: src/std/rc.md:21 msgid "\"--- rc_a is created ---\"" msgstr "\"--- rc_a가 생성됨 ---\"" #: src/std/rc.md:24 src/std/rc.md:31 src/std/rc.md:43 msgid "\"Reference Count of rc_a: {}\"" msgstr "\"rc_a의 참조 횟수: {}\"" #: src/std/rc.md:27 msgid "\"--- rc_a is cloned to rc_b ---\"" msgstr "\"--- rc_a가 rc_b로 클론됨 ---\"" #: src/std/rc.md:30 msgid "\"Reference Count of rc_b: {}\"" msgstr "\"rc_b의 참조 횟수: {}\"" #: src/std/rc.md:33 msgid "// Two `Rc`s are equal if their inner values are equal\n" msgstr "// 두 `Rc`는 내부 값이 같으면 같습니다\n" #: src/std/rc.md:34 msgid "\"rc_a and rc_b are equal: {}\"" msgstr "\"rc_a와 rc_b는 같음: {}\"" #: src/std/rc.md:36 msgid "// We can use methods of a value directly\n" msgstr "// 값의 메서드들을 직접 사용할 수 있습니다\n" #: src/std/rc.md:37 msgid "\"Length of the value inside rc_a: {}\"" msgstr "\"rc_a 내부 값의 길이: {}\"" #: src/std/rc.md:38 msgid "\"Value of rc_b: {}\"" msgstr "\"rc_b의 값: {}\"" #: src/std/rc.md:40 msgid "\"--- rc_b is dropped out of scope ---\"" msgstr "\"--- rc_b가 스코프를 벗어나 해제됨 ---\"" #: src/std/rc.md:45 msgid "\"--- rc_a is dropped out of scope ---\"" msgstr "\"--- rc_a가 스코프를 벗어나 해제됨 ---\"" #: src/std/rc.md:48 msgid "" "// Error! `rc_examples` already moved into `rc_a`\n" " // And when `rc_a` is dropped, `rc_examples` is dropped together\n" " // println!(\"rc_examples: {}\", rc_examples);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 에러! `rc_examples`는 이미 `rc_a`로 이동되었습니다\n" " // 그리고 `rc_a`가 해제될 때, `rc_examples`도 함께 해제됩니다\n" " // println!(\"rc_examples: {}\", rc_examples);\n" " // TODO ^ 이 줄의 주석을 해제해 보세요\n" #: src/std/rc.md:57 msgid "" "[std::rc](https://doc.rust-lang.org/std/rc/index.html) and [std::sync::arc]" "(https://doc.rust-lang.org/std/sync/struct.Arc.html)." msgstr "" "[std::rc](https://doc.rust-lang.org/std/rc/index.html)와 [std::sync::arc]" "(https://doc.rust-lang.org/std/sync/struct.Arc.html)." #: src/std/arc.md:1 msgid "Arc" msgstr "Arc" #: src/std/arc.md:3 msgid "" "When shared ownership between threads is needed, `Arc`(Atomically Reference " "Counted) can be used. This struct, via the `Clone` implementation can create " "a reference pointer for the location of a value in the memory heap while " "increasing the reference counter. As it shares ownership between threads, " "when the last reference pointer to a value is out of scope, the variable is " "dropped." msgstr "" "스레드 간의 공유 소유권이 필요한 경우, `Arc`(원자적 참조 횟수 계산, " "Atomically Reference Counted)를 사용할 수 있습니다. 이 구조체는 `Clone` 구현" "을 통해 힙 메모리에 있는 값의 위치를 가리키는 참조 포인터를 생성하고 참조 횟" "수를 증가시킵니다. 스레드 간에 소유권을 공유하므로, 값에 대한 마지막 참조 포" "인터가 스코프를 벗어날 때 변수가 해제됩니다." #: src/std/arc.md:15 msgid "// This variable declaration is where its value is specified.\n" msgstr "// 이 변수 선언에서 값이 지정됩니다.\n" #: src/std/arc.md:16 msgid "\"the same apple\"" msgstr "\"같은 사과\"" #: src/std/arc.md:19 msgid "" "// Here there is no value specification as it is a pointer to a\n" " // reference in the memory heap.\n" msgstr "" "// 여기서는 힙 메모리의 참조를 가리키는 포인터이므로 별도의 값 지정이 없습니" "다.\n" #: src/std/arc.md:24 msgid "" "// As Arc was used, threads can be spawned using the value allocated\n" " // in the Arc variable pointer's location.\n" msgstr "" "// `Arc`를 사용했으므로, `Arc` 변수 포인터 위치에 할당된 값을 사용하여 스레드" "를 생성할 수 있습니다.\n" #: src/std/arc.md:30 msgid "// Make sure all Arc instances are printed from spawned threads.\n" msgstr "// 모든 `Arc` 인스턴스가 생성된 스레드에서 출력되도록 합니다.\n" #: src/std_misc.md:3 msgid "" "Many other types are provided by the std library to support things such as:" msgstr "" "표준 라이브러리는 다음과 같은 것들을 지원하기 위해 많은 다른 타입들을 제공합" "니다:" #: src/std_misc.md:10 msgid "These expand beyond what the [primitives](primitives.md) provide." msgstr "이들은 [기본 자료형](primitives.md)이 제공하는 것 이상으로 확장됩니다." #: src/std_misc/threads.md:3 msgid "" "Rust provides a mechanism for spawning native OS threads via the `spawn` " "function, the argument of this function is a moving closure." msgstr "" "Rust는 `spawn` 함수를 통해 네이티브 OS 스레드를 생성하는 메커니즘을 제공합니" "다. 이 함수의 인자는 이동(moving) 클로저입니다." #: src/std_misc/threads.md:10 src/std_misc/threads/testcase_mapreduce.md:28 msgid "// This is the `main` thread\n" msgstr "// 메인 스레드입니다\n" #: src/std_misc/threads.md:13 msgid "// Make a vector to hold the children which are spawned.\n" msgstr "// 생성된 자식 스레드들을 담을 벡터를 만듭니다.\n" #: src/std_misc/threads.md:17 msgid "// Spin up another thread\n" msgstr "// 또 다른 스레드를 생성합니다\n" #: src/std_misc/threads.md:19 msgid "\"this is thread number {}\"" msgstr "\"이것은 {}번 스레드입니다\"" #: src/std_misc/threads.md:24 msgid "// Wait for the thread to finish. Returns a result.\n" msgstr "// 스레드가 종료될 때까지 기다립니다. 결과를 반환합니다.\n" #: src/std_misc/threads.md:30 msgid "These threads will be scheduled by the OS." msgstr "이러한 스레드들은 OS에 의해 스케줄링됩니다." #: src/std_misc/threads/testcase_mapreduce.md:3 msgid "" "Rust makes it very easy to parallelize data processing, without many of the " "headaches traditionally associated with such an attempt." msgstr "" "Rust는 전통적으로 이러한 시도와 관련된 많은 골칫거리 없이 데이터 처리를 병렬" "화하는 것을 매우 쉽게 만들어 줍니다." #: src/std_misc/threads/testcase_mapreduce.md:5 msgid "" "The standard library provides great threading primitives out of the box. " "These, combined with Rust's concept of Ownership and aliasing rules, " "automatically prevent data races." msgstr "" "표준 라이브러리는 훌륭한 스레딩 프리미티브를 즉시 제공합니다. 이들은 Rust의 " "소유권 개념 및 에일리어싱 규칙과 결합하여 자동으로 데이터 경합(data races)을 " "방지합니다." #: src/std_misc/threads/testcase_mapreduce.md:9 msgid "" "The aliasing rules (one writable reference XOR many readable references) " "automatically prevent you from manipulating state that is visible to other " "threads. (Where synchronization is needed, there are synchronization " "primitives like `Mutex`es or `Channel`s.)" msgstr "" "에일리어싱 규칙(하나의 쓰기 가능 참조 XOR 여러 개의 읽기 가능 참조)은 다른 스" "레드에 보이는 상태를 조작하는 것을 자동으로 방지합니다. (동기화가 필요한 곳에" "는 `Mutex`나 `Channel`과 같은 동기화 프리미티브가 있습니다.)" #: src/std_misc/threads/testcase_mapreduce.md:14 msgid "" "In this example, we will calculate the sum of all digits in a block of " "numbers. We will do this by parcelling out chunks of the block into " "different threads. Each thread will sum its tiny block of digits, and " "subsequently we will sum the intermediate sums produced by each thread." msgstr "" "이 예제에서, 우리는 숫자 블록에 있는 모든 숫자의 합을 계산할 것입니다. 블록" "의 덩어리들을 서로 다른 스레드에 할당하여 이를 수행할 것입니다. 각 스레드는 " "자신의 작은 숫자 블록의 합을 구하고, 이어서 각 스레드에서 생성된 중간 합계들" "을 모두 더할 것입니다." #: src/std_misc/threads/testcase_mapreduce.md:19 msgid "" "Note that, although we're passing references across thread boundaries, Rust " "understands that we're only passing read-only references, and that thus no " "unsafety or data races can occur. Also because the references we're passing " "have `'static` lifetimes, Rust understands that our data won't be destroyed " "while these threads are still running. (When you need to share non-`static` " "data between threads, you can use a smart pointer like `Arc` to keep the " "data alive and avoid non-`static` lifetimes.)" msgstr "" "스레드 경계를 넘어 참조를 전달하고 있지만, Rust는 우리가 읽기 전용 참조만 전" "달하고 있음을 이해하며, 따라서 안전하지 않은 상황이나 데이터 경합이 발생할 " "수 없음을 알고 있습니다. 또한 우리가 전달하는 참조들이 `'static` 라이프타임" "을 가지고 있기 때문에, Rust는 이 스레드들이 실행되는 동안 데이터가 파괴되지 " "않을 것임을 이해합니다. (스레드 간에 `static`이 아닌 데이터를 공유해야 할 때" "는 `Arc`와 같은 스마트 포인터를 사용하여 데이터를 유지하고 `static`이 아닌 라" "이프타임 문제를 피할 수 있습니다.)" #: src/std_misc/threads/testcase_mapreduce.md:32 msgid "" "// This is our data to process.\n" " // We will calculate the sum of all digits via a threaded map-reduce " "algorithm.\n" " // Each whitespace separated chunk will be handled in a different " "thread.\n" " //\n" " // TODO: see what happens to the output if you insert spaces!\n" msgstr "" "// 처리할 데이터입니다.\n" " // 스레드된 맵-리듀스(map-reduce) 알고리즘을 통해 모든 숫자의 합을 계산" "할 것입니다.\n" " // 공백으로 구분된 각 덩어리는 서로 다른 스레드에서 처리될 것입니다.\n" " //\n" " // TODO: 공백을 삽입하면 출력에 어떤 변화가 생기는지 확인해 보세요!\n" #: src/std_misc/threads/testcase_mapreduce.md:37 msgid "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" msgstr "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" #: src/std_misc/threads/testcase_mapreduce.md:46 msgid "// Make a vector to hold the child-threads which we will spawn.\n" msgstr "// 우리가 생성할 자식 스레드들을 담을 벡터를 만듭니다.\n" #: src/std_misc/threads/testcase_mapreduce.md:49 msgid "" "/*************************************************************************\n" " * \"Map\" phase\n" " *\n" " * Divide our data into segments, and apply initial processing\n" " ************************************************************************/" msgstr "" "/*************************************************************************\n" " * \"Map\" 단계\n" " *\n" " * 데이터를 세그먼트로 나누고, 초기 처리를 적용합니다\n" " ************************************************************************/" #: src/std_misc/threads/testcase_mapreduce.md:55 msgid "" "// split our data into segments for individual calculation\n" " // each chunk will be a reference (&str) into the actual data\n" msgstr "" "// 개별 계산을 위해 데이터를 세그먼트로 나눕니다.\n" "// 각 덩어리는 실제 데이터에 대한 참조(&str)가 될 것입니다.\n" #: src/std_misc/threads/testcase_mapreduce.md:59 msgid "" "// Iterate over the data segments.\n" " // .enumerate() adds the current loop index to whatever is iterated\n" " // the resulting tuple \"(index, element)\" is then immediately\n" " // \"destructured\" into two variables, \"i\" and \"data_segment\" with " "a\n" " // \"destructuring assignment\"\n" msgstr "" "// 데이터 세그먼트들을 순회합니다.\n" "// `.enumerate()`는 순회하는 대상에 현재 루프 인덱스를 추가합니다.\n" "// 결과 튜플 \"(index, element)\"는 \"구조 분해 할당\"\n" "// 을 통해 즉시 두 변수 \"i\"와 \"data_segment\"로 \"구조 분해\"됩니다.\n" #: src/std_misc/threads/testcase_mapreduce.md:65 msgid "\"data segment {} is \\\"{}\\\"\"" msgstr "\"데이터 세그먼트 {}는 \\\"{}\\\"입니다\"" #: src/std_misc/threads/testcase_mapreduce.md:67 msgid "" "// Process each data segment in a separate thread\n" " //\n" " // spawn() returns a handle to the new thread,\n" " // which we MUST keep to access the returned value\n" " //\n" " // 'move || -> u32' is syntax for a closure that:\n" " // * takes no arguments ('||')\n" " // * takes ownership of its captured variables ('move') and\n" " // * returns an unsigned 32-bit integer ('-> u32')\n" " //\n" " // Rust is smart enough to infer the '-> u32' from\n" " // the closure itself so we could have left that out.\n" " //\n" " // TODO: try removing the 'move' and see what happens\n" msgstr "" "// 각 데이터 세그먼트를 별도의 스레드에서 처리합니다\n" " //\n" " // spawn()은 새 스레드에 대한 핸들을 반환하며,\n" " // 반환된 값에 접근하려면 이 핸들을 반드시 보관해야 합니다\n" " //\n" " // 'move || -> u32'는 다음과 같은 클로저 문법입니다:\n" " // * 인자를 취하지 않음 ('||')\n" " // * 캡처한 변수의 소유권을 가져옴 ('move')\n" " // * 부호 없는 32비트 정수를 반환함 ('-> u32')\n" " //\n" " // Rust는 클로저 자체에서 '-> u32'를 추론할 수 있을 만큼 영리하므로\n" " // 이를 생략할 수도 있었습니다.\n" " //\n" " // TODO: 'move'를 제거해 보고 어떤 일이 일어나는지 확인해 보세요\n" #: src/std_misc/threads/testcase_mapreduce.md:82 msgid "// Calculate the intermediate sum of this segment:\n" msgstr "// 이 세그먼트의 중간 합계를 계산합니다:\n" #: src/std_misc/threads/testcase_mapreduce.md:84 msgid "// iterate over the characters of our segment..\n" msgstr "// 세그먼트의 문자들을 순회합니다..\n" #: src/std_misc/threads/testcase_mapreduce.md:86 msgid "// .. convert text-characters to their number value..\n" msgstr "// .. 텍스트 문자를 숫자 값으로 변환합니다..\n" #: src/std_misc/threads/testcase_mapreduce.md:87 msgid "\"should be a digit\"" msgstr "\"숫자여야 합니다\"" #: src/std_misc/threads/testcase_mapreduce.md:88 msgid "// .. and sum the resulting iterator of numbers\n" msgstr "// .. 그리고 결과 숫지 이터레이터의 합을 구합니다\n" #: src/std_misc/threads/testcase_mapreduce.md:91 msgid "// println! locks stdout, so no text-interleaving occurs\n" msgstr "// println!은 표준 출력을 잠그므로, 텍스트가 서로 섞이지 않습니다\n" #: src/std_misc/threads/testcase_mapreduce.md:92 msgid "\"processed segment {}, result={}\"" msgstr "\"세그먼트 {} 처리됨, 결과={}\"" #: src/std_misc/threads/testcase_mapreduce.md:94 msgid "" "// \"return\" not needed, because Rust is an \"expression language\", the\n" " // last evaluated expression in each block is automatically its " "value.\n" msgstr "" "// Rust는 \"표현식 언어\"이므로 \"return\"이 필요하지 않습니다.\n" " // 각 블록에서 마지막으로 평가된 표현식이 자동으로 그 값이 됩니" "다.\n" #: src/std_misc/threads/testcase_mapreduce.md:102 msgid "" "/*************************************************************************\n" " * \"Reduce\" phase\n" " *\n" " * Collect our intermediate results, and combine them into a final " "result\n" " ************************************************************************/" msgstr "" "/*************************************************************************\n" " * \"Reduce\" 단계\n" " *\n" " * 중간 결과들을 수집하여 최종 결과로 결합합니다\n" " ************************************************************************/" #: src/std_misc/threads/testcase_mapreduce.md:108 msgid "" "// combine each thread's intermediate results into a single final sum.\n" " //\n" " // we use the \"turbofish\" ::<> to provide sum() with a type hint.\n" " //\n" " // TODO: try without the turbofish, by instead explicitly\n" " // specifying the type of final_result\n" msgstr "" "// 각 스레드의 중간 결과들을 하나의 최종 합계로 결합합니다.\n" "//\n" "// `sum()`에 타입 힌트를 제공하기 위해 \"터보피쉬(turbofish)\" `::<>`를 사용" "합니다.\n" "//\n" "// TODO: 터보피쉬 대신 `final_result`의 타입을 명시적으로 지정하여 시도해 보" "세요\n" #: src/std_misc/threads/testcase_mapreduce.md:116 msgid "\"Final sum result: {}\"" msgstr "\"최종 합계 결과: {}\"" #: src/std_misc/threads/testcase_mapreduce.md:120 msgid "Assignments" msgstr "과제" #: src/std_misc/threads/testcase_mapreduce.md:122 msgid "" "It is not wise to let our number of threads depend on user inputted data. " "What if the user decides to insert a lot of spaces? Do we _really_ want to " "spawn 2,000 threads? Modify the program so that the data is always chunked " "into a limited number of chunks, defined by a static constant at the " "beginning of the program." msgstr "" "스레드 개수가 사용자 입력 데이터에 의존하게 하는 것은 현명하지 않습니다. 사용" "자가 많은 공백을 삽입하기로 한다면 어떨까요? 정말로 2,000개의 스레드를 생성하" "고 싶으신가요? 프로그램 시작 부분에 정의된 정적 상수에 따라 데이터가 항상 제" "한된 개수의 덩어리로 나뉘도록 프로그램을 수정해 보세요." #: src/std_misc/threads/testcase_mapreduce.md:129 msgid "[Threads](../threads.md)" msgstr "[스레드](../threads.md)" #: src/std_misc/threads/testcase_mapreduce.md:130 msgid "[vectors](../../std/vec.md) and [iterators](../../trait/iter.md)" msgstr "[벡터](../../std/vec.md)와 [이터레이터](../../trait/iter.md)" #: src/std_misc/threads/testcase_mapreduce.md:131 msgid "" "[closures](../../fn/closures.md), [move](../../scope/move.md) semantics and " "[`move` closures](https://doc.rust-lang.org/book/ch13-01-" "closures.html#closures-can-capture-their-environment)" msgstr "" "[클로저](../../fn/closures.md), [이동(move)](../../scope/move.md) 의미론 및 " "[`move` 클로저](https://doc.rust-lang.org/book/ch13-01-" "closures.html#closures-can-capture-their-environment)" #: src/std_misc/threads/testcase_mapreduce.md:132 msgid "" "[destructuring](https://doc.rust-lang.org/book/ch18-03-pattern-" "syntax.html#destructuring-to-break-apart-values) assignments" msgstr "" "[구조 분해(destructuring)](https://doc.rust-lang.org/book/ch18-03-pattern-" "syntax.html#destructuring-to-break-apart-values) 할당" #: src/std_misc/threads/testcase_mapreduce.md:133 msgid "" "[turbofish notation](https://doc.rust-lang.org/book/appendix-02-" "operators.html?highlight=turbofish) to help type inference" msgstr "" "타입 추론을 돕기 위한 [터보피쉬 표기법](https://doc.rust-lang.org/book/" "appendix-02-operators.html?highlight=turbofish)" #: src/std_misc/threads/testcase_mapreduce.md:134 msgid "[unwrap vs. expect](../../error/option_unwrap.md)" msgstr "[unwrap vs. expect](../../error/option_unwrap.md)" #: src/std_misc/threads/testcase_mapreduce.md:135 msgid "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" msgstr "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" #: src/std_misc/channels.md:3 msgid "" "Rust provides asynchronous `channels` for communication between threads. " "Channels allow a unidirectional flow of information between two end-points: " "the `Sender` and the `Receiver`." msgstr "" "Rust는 스레드 간 통신을 위한 비동기 `채널(channels)`을 제공합니다. 채널은 " "`Sender`와 `Receiver`라는 두 끝점 사이에서 정보의 단방향 흐름을 가능하게 합니" "다." #: src/std_misc/channels.md:15 msgid "" "// Channels have two endpoints: the `Sender` and the `Receiver`,\n" " // where `T` is the type of the message to be transferred\n" " // (type annotation is superfluous)\n" msgstr "" "// 채널에는 두 끝점이 있습니다: `Sender`와 `Receiver`.\n" "// 여기서 `T`는 전송될 메시지의 타입입니다\n" "// (타입 어노테이션은 불필요합니다)\n" #: src/std_misc/channels.md:22 msgid "// The sender endpoint can be copied\n" msgstr "// 발신자(sender) 끝점은 복사될 수 있습니다\n" #: src/std_misc/channels.md:25 msgid "// Each thread will send its id via the channel\n" msgstr "// 각 스레드는 채널을 통해 자신의 id를 보낼 것입니다\n" #: src/std_misc/channels.md:27 msgid "" "// The thread takes ownership over `thread_tx`\n" " // Each thread queues a message in the channel\n" msgstr "" "// 스레드가 `thread_tx`에 대한 소유권을 가져갑니다\n" "// 각 스레드는 채널에 메시지를 큐에 넣습니다\n" #: src/std_misc/channels.md:31 msgid "" "// Sending is a non-blocking operation, the thread will continue\n" " // immediately after sending its message\n" msgstr "" "// 보내기는 비차단(non-blocking) 연산이므로, 스레드는\n" "// 메시지를 보낸 직후 계속 실행됩니다\n" #: src/std_misc/channels.md:33 msgid "\"thread {} finished\"" msgstr "\"{}번 스레드 종료\"" #: src/std_misc/channels.md:39 msgid "// Here, all the messages are collected\n" msgstr "// 여기서 모든 메시지가 수집됩니다\n" #: src/std_misc/channels.md:42 msgid "" "// The `recv` method picks a message from the channel\n" " // `recv` will block the current thread if there are no messages " "available\n" msgstr "" "// `recv` 메서드는 채널에서 메시지를 하나 꺼냅니다\n" "// `recv`는 사용 가능한 메시지가 없으면 현재 스레드를 차단(block)합니다\n" #: src/std_misc/channels.md:47 msgid "// Wait for the threads to complete any remaining work\n" msgstr "// 스레드들이 남은 작업을 모두 완료할 때까지 기다립니다\n" #: src/std_misc/channels.md:49 msgid "\"oops! the child thread panicked\"" msgstr "\"이런! 자식 스레드에서 패닉이 발생했습니다\"" #: src/std_misc/channels.md:52 msgid "// Show the order in which the messages were sent\n" msgstr "// 메시지가 전송된 순서를 보여줍니다\n" #: src/std_misc/path.md:3 msgid "" "The `Path` type represents file paths in the underlying filesystem. Across " "all platforms there is a single `std::path::Path` that abstracts over " "platform-specific path semantics and separators. Bring it into scope with " "`use std::path::Path;` when needed." msgstr "" "`Path` 타입은 기저 파일 시스템의 파일 경로를 나타냅니다. 모든 플랫폼에 걸쳐 " "플랫폼별 경로 의미론과 구분자를 추상화하는 단일 `std::path::Path`가 존재합니" "다. 필요할 때 `use std::path::Path;`를 사용하여 스코프로 가져오세요." #: src/std_misc/path.md:8 msgid "" "A `Path` can be created from an `OsStr`, and provides several methods to get " "information from the file/directory the path points to." msgstr "" "`Path`는 `OsStr`로부터 생성될 수 있으며, 경로가 가리키는 파일/디렉터리로부터 " "정보를 얻기 위한 여러 메서드를 제공합니다." #: src/std_misc/path.md:11 msgid "" "A `Path` is immutable. The owned version of `Path` is `PathBuf`. The " "relation between `Path` and `PathBuf` is similar to that of `str` and " "`String`: a `PathBuf` can be mutated in-place, and can be dereferenced to a " "`Path`." msgstr "" "`Path`는 불변(immutable)입니다. `Path`의 소유형(owned) 버전은 `PathBuf`입니" "다. `Path`와 `PathBuf`의 관계는 `str`과 `String`의 관계와 유사합니다. " "`PathBuf`는 그 자리에서 수정될 수 있으며, `Path`로 역참조(dereference)될 수 " "있습니다." #: src/std_misc/path.md:15 msgid "" "Note that a `Path` is _not_ internally represented as an UTF-8 string, but " "instead is stored as an `OsString`. Therefore, converting a `Path` to a " "`&str` is _not_ free and may fail (an `Option` is returned). However, a " "`Path` can be freely converted to an `OsString` or `&OsStr` using " "`into_os_string` and `as_os_str`, respectively." msgstr "" "`Path`는 내부적으로 UTF-8 문자열로 표현되지 않고, 대신 `OsString`으로 저장됩" "니다. 따라서 `Path`를 `&str`로 변환하는 것은 비용이 들며 실패할 수도 있습니다" "(`Option`이 반환됩니다). 하지만 `Path`는 각각 `into_os_string`과 `as_os_str`" "을 사용하여 `OsString`이나 `&OsStr`로 자유롭게 변환될 수 있습니다." #: src/std_misc/path.md:25 msgid "// Create a `Path` from an `&'static str`\n" msgstr "// &'static str로부터 Path를 생성합니다\n" #: src/std_misc/path.md:26 msgid "\".\"" msgstr "\".\"" #: src/std_misc/path.md:28 msgid "// The `display` method returns a `Display`able structure\n" msgstr "// `display` 메서드는 `Display` 가능한 구조체를 반환합니다\n" #: src/std_misc/path.md:31 msgid "" "// `join` merges a path with a byte container using the OS specific\n" " // separator, and returns a `PathBuf`\n" msgstr "" "// `join`은 OS 전용 구분자를 사용하여 경로를 바이트 컨테이너와 병합하고, " "`PathBuf`를 반환합니다.\n" #: src/std_misc/path.md:35 msgid "// `push` extends the `PathBuf` with a `&Path`\n" msgstr "// `push`는 `PathBuf`를 `&Path`로 확장합니다\n" #: src/std_misc/path.md:37 msgid "\"myfile.tar.gz\"" msgstr "\"myfile.tar.gz\"" #: src/std_misc/path.md:39 msgid "// `set_file_name` updates the file name of the `PathBuf`\n" msgstr "// `set_file_name`은 `PathBuf`의 파일 이름을 업데이트합니다\n" #: src/std_misc/path.md:40 msgid "\"package.tgz\"" msgstr "\"package.tgz\"" #: src/std_misc/path.md:42 msgid "// Convert the `PathBuf` into a string slice\n" msgstr "// `PathBuf`를 문자열 슬라이스로 변환합니다\n" #: src/std_misc/path.md:44 msgid "\"new path is not a valid UTF-8 sequence\"" msgstr "\"새 경로가 유효한 UTF-8 시퀀스가 아닙니다\"" #: src/std_misc/path.md:45 msgid "\"new path is {}\"" msgstr "\"새 경로는 {}입니다\"" #: src/std_misc/path.md:50 msgid "Be sure to check other `Path` methods and the `Metadata` struct." msgstr "다른 `Path` 메서드들과 `Metadata` 구조체도 반드시 확인해 보세요." #: src/std_misc/path.md:54 msgid "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) and [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)." msgstr "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html)와 [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)." #: src/std_misc/file.md:3 msgid "" "The `File` struct represents a file that has been opened (it wraps a file " "descriptor), and gives read and/or write access to the underlying file." msgstr "" "`File` 구조체는 열려 있는 파일을 나타내며(파일 디스크립터를 감쌉니다), 기저 " "파일에 대해 읽기 및/또는 쓰기 접근 권한을 제공합니다." #: src/std_misc/file.md:6 msgid "" "Since many things can go wrong when doing file I/O, all the `File` methods " "return the `io::Result` type, which is an alias for `Result`." msgstr "" "파일 입출력을 수행할 때는 많은 것들이 잘못될 수 있으므로, 모든 `File` 메서드" "는 `Result`의 별칭인 `io::Result` 타입을 반환합니다." #: src/std_misc/file.md:9 msgid "" "This makes the failure of all I/O operations _explicit_. Thanks to this, the " "programmer can see all the failure paths, and is encouraged to handle them " "in a proactive manner." msgstr "" "이는 모든 입출력 연산의 실패를 *명시적*으로 만듭니다. 덕분에 프로그래머는 모" "든 실패 경로를 확인할 수 있으며, 이를 적극적인 방식으로 처리하도록 권장됩니" "다." #: src/std_misc/file/open.md:3 msgid "The `open` function can be used to open a file in read-only mode." msgstr "`open` 함수는 파일을 읽기 전용 모드로 여는 데 사용될 수 있습니다." #: src/std_misc/file/open.md:5 msgid "" "A `File` owns a resource, the file descriptor and takes care of closing the " "file when it is `drop`ed." msgstr "" "`File`은 리소스인 파일 디스크립터를 소유하며, `drop`될 때 파일을 닫는 것을 책" "임집니다." #: src/std_misc/file/open.md:14 msgid "// Create a path to the desired file\n" msgstr "// 원하는 파일에 대한 경로를 생성합니다\n" #: src/std_misc/file/open.md:15 msgid "\"hello.txt\"" msgstr "\"hello.txt\"" #: src/std_misc/file/open.md:18 msgid "// Open the path in read-only mode, returns `io::Result`\n" msgstr "// 경로를 읽기 전용 모드로 엽니다. `io::Result`을 반환합니다\n" #: src/std_misc/file/open.md:20 msgid "\"couldn't open {}: {}\"" msgstr "\"{}를 열 수 없습니다: {}\"" #: src/std_misc/file/open.md:24 msgid "// Read the file contents into a string, returns `io::Result`\n" msgstr "// 파일 내용을 문자열로 읽어옵니다. `io::Result`를 반환합니다\n" #: src/std_misc/file/open.md:27 msgid "\"couldn't read {}: {}\"" msgstr "\"{}를 읽을 수 없습니다: {}\"" #: src/std_misc/file/open.md:28 msgid "\"{} contains:\\n{}\"" msgstr "\"{}의 내용:\\n{}\"" #: src/std_misc/file/open.md:31 msgid "// `file` goes out of scope, and the \"hello.txt\" file gets closed\n" msgstr "// `file`이 스코프를 벗어나고, \"hello.txt\" 파일이 닫힙니다\n" #: src/std_misc/file/open.md:35 src/std_misc/file/create.md:39 #: src/std_misc/fs.md:108 msgid "Here's the expected successful output:" msgstr "예상되는 성공적인 출력 결과는 다음과 같습니다:" #: src/std_misc/file/open.md:37 msgid "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt contains:\n" "Hello World!\n" "```" msgstr "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt의 내용:\n" "Hello World!\n" "```" #: src/std_misc/file/open.md:44 msgid "" "(You are encouraged to test the previous example under different failure " "conditions: `hello.txt` doesn't exist, or `hello.txt` is not readable, etc.)" msgstr "" "(이전 예제를 `hello.txt`가 존재하지 않거나, 읽기 권한이 없는 등 다양한 실패 " "조건에서 테스트해 보시길 권장합니다.)" #: src/std_misc/file/create.md:3 msgid "" "The `create` function opens a file in write-only mode. If the file already " "existed, the old content is destroyed. Otherwise, a new file is created." msgstr "" "`create` 함수는 파일을 쓰기 전용 모드로 엽니다. 파일이 이미 존재한다면 이전 " "내용은 파괴됩니다. 그렇지 않으면 새로운 파일이 생성됩니다." #: src/std_misc/file/create.md:9 msgid "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" msgstr "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" #: src/std_misc/file/create.md:22 msgid "\"lorem_ipsum.txt\"" msgstr "\"lorem_ipsum.txt\"" #: src/std_misc/file/create.md:25 msgid "// Open a file in write-only mode, returns `io::Result`\n" msgstr "// 파일을 쓰기 전용 모드로 엽니다. `io::Result`을 반환합니다\n" #: src/std_misc/file/create.md:27 msgid "\"couldn't create {}: {}\"" msgstr "\"{}를 생성할 수 없습니다: {}\"" #: src/std_misc/file/create.md:31 msgid "// Write the `LOREM_IPSUM` string to `file`, returns `io::Result<()>`\n" msgstr "" "// `LOREM_IPSUM` 문자열을 `file`에 씁니다. `io::Result<()>`를 반환합니다\n" #: src/std_misc/file/create.md:33 msgid "\"couldn't write to {}: {}\"" msgstr "\"{}에 쓸 수 없습니다: {}\"" #: src/std_misc/file/create.md:34 msgid "\"successfully wrote to {}\"" msgstr "\"{}에 성공적으로 썼습니다\"" #: src/std_misc/file/create.md:54 msgid "" "(As in the previous example, you are encouraged to test this example under " "failure conditions.)" msgstr "" "(이전 예제와 마찬가지로, 이 예제를 실패 조건에서 테스트해 보시길 권장합니다.)" #: src/std_misc/file/create.md:57 msgid "" "The [`OpenOptions`](https://doc.rust-lang.org/std/fs/" "struct.OpenOptions.html) struct can be used to configure how a file is " "opened." msgstr "" "[`OpenOptions`](https://doc.rust-lang.org/std/fs/struct.OpenOptions.html) 구" "조체는 파일이 열리는 방식을 구성하는 데 사용될 수 있습니다." #: src/std_misc/file/read_lines.md:3 msgid "A naive approach" msgstr "단순한 접근 방식" #: src/std_misc/file/read_lines.md:5 msgid "" "This might be a reasonable first attempt for a beginner's first " "implementation for reading lines from a file." msgstr "" "이는 초보자가 파일에서 줄을 읽기 위해 처음 시도해 볼 만한 합리적인 방식일 수 " "있습니다." #: src/std_misc/file/read_lines.md:22 msgid "" "Since the method `lines()` returns an iterator over the lines in the file, " "we can also perform a map inline and collect the results, yielding a more " "concise and fluent expression." msgstr "" "`lines()` 메서드가 파일의 줄들에 대한 이터레이터를 반환하므로, 인라인에서 " "`map`을 수행하고 결과를 `collect`하여 더 간결하고 유려한 표현식을 만들 수도 " "있습니다." #: src/std_misc/file/read_lines.md:31 msgid "// panic on possible file-reading errors\n" msgstr "// 발생 가능한 파일 읽기 에러에 대해 패닉을 일으킵니다\n" #: src/std_misc/file/read_lines.md:32 msgid "// split the string into an iterator of string slices\n" msgstr "// 문자열을 문자열 슬라이스 이터레이터로 분할합니다\n" #: src/std_misc/file/read_lines.md:33 msgid "// make each slice into a string\n" msgstr "// 각 슬라이스를 String으로 만듭니다\n" #: src/std_misc/file/read_lines.md:34 msgid "// gather them together into a vector\n" msgstr "// 이들을 벡터로 모읍니다\n" #: src/std_misc/file/read_lines.md:38 msgid "" "Note that in both examples above, we must convert the `&str` reference " "returned from `lines()` to the owned type `String`, using `.to_string()` and " "`String::from` respectively." msgstr "" "위의 두 예제 모두에서, `lines()`가 반환한 `&str` 참조를 `.to_string()` 또는 " "`String::from`을 사용하여 소유형인 `String`으로 변환해야 한다는 점에 유의하세" "요." #: src/std_misc/file/read_lines.md:42 msgid "A more efficient approach" msgstr "더 효율적인 접근 방식" #: src/std_misc/file/read_lines.md:44 msgid "" "Here we pass ownership of the open `File` to a `BufReader` struct. " "`BufReader` uses an internal buffer to reduce intermediate allocations." msgstr "" "여기서는 열려 있는 `File`의 소유권을 `BufReader` 구조체로 넘깁니다. " "`BufReader`는 내부 버퍼를 사용하여 중간 할당을 줄입니다." #: src/std_misc/file/read_lines.md:47 msgid "" "We also update `read_lines` to return an iterator instead of allocating new " "`String` objects in memory for each line." msgstr "" "또한 각 줄마다 메모리에 새로운 `String` 객체를 할당하는 대신 이터레이터를 반" "환하도록 `read_lines`를 업데이트합니다." #: src/std_misc/file/read_lines.md:56 msgid "// File hosts.txt must exist in the current path\n" msgstr "// hosts.txt 파일이 현재 경로에 존재해야 합니다\n" #: src/std_misc/file/read_lines.md:57 msgid "\"./hosts.txt\"" msgstr "\"./hosts.txt\"" #: src/std_misc/file/read_lines.md:58 msgid "// Consumes the iterator, returns an (Optional) String\n" msgstr "// 이터레이터를 소비하여, (선택적인) String을 반환합니다\n" #: src/std_misc/file/read_lines.md:64 msgid "" "// The output is wrapped in a Result to allow matching on errors.\n" "// Returns an Iterator to the Reader of the lines of the file.\n" msgstr "" "// 에러에 대한 매칭이 가능하도록 출력을 `Result`로 감쌉니다.\n" "// 파일의 각 줄을 읽어오는 이터레이터를 반환합니다.\n" #: src/std_misc/file/read_lines.md:74 msgid "Running this program simply prints the lines individually." msgstr "이 프로그램을 실행하면 단순히 각 줄을 개별적으로 출력합니다." #: src/std_misc/file/read_lines.md:76 msgid "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" msgstr "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" #: src/std_misc/file/read_lines.md:83 msgid "" "(Note that since `File::open` expects a generic `AsRef` as argument, " "we define our generic `read_lines()` method with the same generic " "constraint, using the `where` keyword.)" msgstr "" "(`File::open`이 인자로 제네릭 `AsRef`를 요구하므로, 우리의 제네릭 " "`read_lines()` 메서드도 `where` 키워드를 사용하여 동일한 제네릭 제약 조건을 " "정의한다는 점에 유의하세요.)" #: src/std_misc/file/read_lines.md:86 msgid "" "This process is more efficient than creating a `String` in memory with all " "of the file's contents. This can especially cause performance issues when " "working with larger files." msgstr "" "이 과정은 파일의 모든 내용을 메모리에 `String`으로 생성하는 것보다 효율적입니" "다. 특히 대용량 파일을 다룰 때 메모리에 모두 올리는 방식은 성능 문제를 일으" "킬 수 있습니다." #: src/std_misc/process.md:3 msgid "" "The `process::Output` struct represents the output of a finished child " "process, and the `process::Command` struct is a process builder." msgstr "" "`process::Output` 구조체는 종료된 자식 프로세스의 출력을 나타내며, " "`process::Command` 구조체는 프로세스 빌더입니다." #: src/std_misc/process.md:10 msgid "\"rustc\"" msgstr "\"rustc\"" #: src/std_misc/process.md:11 msgid "\"--version\"" msgstr "\"--version\"" #: src/std_misc/process.md:13 msgid "\"failed to execute process: {}\"" msgstr "\"프로세스 실행 실패: {}\"" #: src/std_misc/process.md:19 msgid "\"rustc succeeded and stdout was:\\n{}\"" msgstr "\"rustc가 성공했으며 표준 출력은 다음과 같습니다:\\n{}\"" #: src/std_misc/process.md:23 msgid "\"rustc failed and stderr was:\\n{}\"" msgstr "\"rustc가 실패했으며 표준 에러는 다음과 같습니다:\\n{}\"" #: src/std_misc/process.md:28 msgid "" "(You are encouraged to try the previous example with an incorrect flag " "passed to `rustc`)" msgstr "" "(이전 예제에서 `rustc`에 잘못된 플래그를 전달하여 시도해 보시길 권장합니다.)" #: src/std_misc/process/pipe.md:3 msgid "" "The `std::process::Child` struct represents a child process, and exposes the " "`stdin`, `stdout` and `stderr` handles for interaction with the underlying " "process via pipes." msgstr "" "`std::process::Child` 구조체는 자식 프로세스를 나타내며, 파이프를 통해 기저 " "프로세스와 상호작용하기 위한 `stdin`, `stdout`, `stderr` 핸들을 노출합니다." #: src/std_misc/process/pipe.md:11 msgid "\"the quick brown fox jumps over the lazy dog\\n\"" msgstr "\"the quick brown fox jumps over the lazy dog\\n\"" #: src/std_misc/process/pipe.md:15 msgid "// Spawn the `wc` command\n" msgstr "// `wc` 명령어를 실행(spawn)합니다\n" #: src/std_misc/process/pipe.md:16 src/std_misc/fs.md:12 src/std_misc/fs.md:73 #: src/std_misc/ffi.md:11 msgid "\"windows\"" msgstr "\"windows\"" #: src/std_misc/process/pipe.md:17 msgid "\"powershell\"" msgstr "\"powershell\"" #: src/std_misc/process/pipe.md:18 msgid "\"-Command\"" msgstr "\"-Command\"" #: src/std_misc/process/pipe.md:18 msgid "\"$input | Measure-Object -Line -Word -Character\"" msgstr "\"$input | Measure-Object -Line -Word -Character\"" #: src/std_misc/process/pipe.md:21 msgid "\"wc\"" msgstr "\"wc\"" #: src/std_misc/process/pipe.md:27 msgid "\"couldn't spawn wc: {}\"" msgstr "\"wc를 실행할 수 없습니다: {}\"" #: src/std_misc/process/pipe.md:31 msgid "" "// Write a string to the `stdin` of `wc`.\n" " //\n" " // `stdin` has type `Option`, but since we know this " "instance\n" " // must have one, we can directly `unwrap` it.\n" msgstr "" "// `wc`의 표준 입력(stdin)에 문자열을 씁니다.\n" "//\n" "// `stdin`은 `Option` 타입이지만, 이 인스턴스에는 반드시\n" "// 존재한다는 것을 알고 있으므로 직접 `unwrap`할 수 있습니다.\n" #: src/std_misc/process/pipe.md:36 msgid "\"couldn't write to wc stdin: {}\"" msgstr "\"wc의 표준 입력에 쓸 수 없습니다: {}\"" #: src/std_misc/process/pipe.md:37 msgid "\"sent pangram to wc\"" msgstr "\"wc에 팬그램을 보냈습니다\"" #: src/std_misc/process/pipe.md:40 msgid "" "// Because `stdin` does not live after the above calls, it is `drop`ed,\n" " // and the pipe is closed.\n" " //\n" " // This is very important, otherwise `wc` wouldn't start processing the\n" " // input we just sent.\n" msgstr "" "// 위의 호출 이후에는 `stdin`이 더 이상 살아있지 않으므로 `drop`되고,\n" "// 파이프가 닫힙니다.\n" "//\n" "// 이는 매우 중요합니다. 그렇지 않으면 `wc`가 우리가 보낸 입력을\n" "// 처리하기 시작하지 않을 것이기 때문입니다.\n" #: src/std_misc/process/pipe.md:46 msgid "" "// The `stdout` field also has type `Option` so must be " "unwrapped.\n" msgstr "" "// `stdout` 필드도 `Option` 타입이므로 `unwrap`해야 합니다.\n" #: src/std_misc/process/pipe.md:49 msgid "\"couldn't read wc stdout: {}\"" msgstr "\"wc의 표준 출력을 읽을 수 없습니다: {}\"" #: src/std_misc/process/pipe.md:50 msgid "\"wc responded with:\\n{}\"" msgstr "\"wc의 응답:\\n{}\"" #: src/std_misc/process/wait.md:3 msgid "" "If you'd like to wait for a `process::Child` to finish, you must call " "`Child::wait`, which will return a `process::ExitStatus`." msgstr "" "`process::Child`가 종료될 때까지 기다리려면 `Child::wait`를 호출해야 하며, 이" "는 `process::ExitStatus`를 반환합니다." #: src/std_misc/process/wait.md:10 msgid "\"sleep\"" msgstr "\"sleep\"" #: src/std_misc/process/wait.md:13 msgid "\"reached end of main\"" msgstr "\"메인의 끝에 도달함\"" #: src/std_misc/process/wait.md:18 msgid "" "# `wait` keeps running for 5 seconds until the `sleep 5` command finishes\n" msgstr "# `wait`는 `sleep 5` 명령어가 끝날 때까지 5초 동안 계속 실행됩니다\n" #: src/std_misc/fs.md:3 msgid "" "The `std::fs` module contains several functions that deal with the " "filesystem." msgstr "`std::fs` 모듈은 파일 시스템을 다루는 여러 함수들을 포함하고 있습니다." #: src/std_misc/fs.md:10 src/std_misc/fs.md:68 src/std_misc/ffi.md:20 msgid "\"unix\"" msgstr "\"unix\"" #: src/std_misc/fs.md:15 msgid "// A simple implementation of `% cat path`\n" msgstr "// `% cat path`를 간단히 구현한 것\n" #: src/std_misc/fs.md:25 msgid "// A simple implementation of `% echo s > path`\n" msgstr "// `% echo s > path`를 간단히 구현한 것\n" #: src/std_misc/fs.md:32 msgid "// A simple implementation of `% touch path` (ignores existing files)\n" msgstr "// `% touch path`를 간단히 구현한 것 (기존 파일은 무시함)\n" #: src/std_misc/fs.md:42 msgid "\"`mkdir a`\"" msgstr "\"`mkdir a`\"" #: src/std_misc/fs.md:43 msgid "// Create a directory, returns `io::Result<()>`\n" msgstr "// 디렉터리를 생성합니다. `io::Result<()>`를 반환합니다\n" #: src/std_misc/fs.md:45 src/std_misc/fs.md:52 src/std_misc/fs.md:58 #: src/std_misc/fs.md:63 src/std_misc/fs.md:70 src/std_misc/fs.md:75 #: src/std_misc/fs.md:81 src/std_misc/fs.md:88 src/std_misc/fs.md:97 #: src/std_misc/fs.md:103 msgid "\"! {:?}\"" msgstr "\"! {:?}\"" #: src/std_misc/fs.md:49 msgid "\"`echo hello > a/b.txt`\"" msgstr "\"`echo hello > a/b.txt`\"" #: src/std_misc/fs.md:50 msgid "" "// The previous match can be simplified using the `unwrap_or_else` method\n" msgstr "" "// 이전의 `match`는 `unwrap_or_else` 메서드를 사용하여 단순화될 수 있습니다\n" #: src/std_misc/fs.md:51 msgid "\"a/b.txt\"" msgstr "\"a/b.txt\"" #: src/std_misc/fs.md:55 msgid "\"`mkdir -p a/c/d`\"" msgstr "\"`mkdir -p a/c/d`\"" #: src/std_misc/fs.md:56 msgid "// Recursively create a directory, returns `io::Result<()>`\n" msgstr "// 디렉터리를 재귀적으로 생성합니다. `io::Result<()>`를 반환합니다\n" #: src/std_misc/fs.md:57 src/std_misc/fs.md:102 msgid "\"a/c/d\"" msgstr "\"a/c/d\"" #: src/std_misc/fs.md:61 msgid "\"`touch a/c/e.txt`\"" msgstr "\"`touch a/c/e.txt`\"" #: src/std_misc/fs.md:62 src/std_misc/fs.md:96 msgid "\"a/c/e.txt\"" msgstr "\"a/c/e.txt\"" #: src/std_misc/fs.md:66 msgid "\"`ln -s ../b.txt a/c/b.txt`\"" msgstr "\"`ln -s ../b.txt a/c/b.txt`\"" #: src/std_misc/fs.md:67 msgid "// Create a symbolic link, returns `io::Result<()>`\n" msgstr "// 심볼릭 링크를 생성합니다. `io::Result<()>`를 반환합니다\n" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 msgid "\"../b.txt\"" msgstr "\"../b.txt\"" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 src/std_misc/fs.md:80 msgid "\"a/c/b.txt\"" msgstr "\"a/c/b.txt\"" #: src/std_misc/fs.md:79 msgid "\"`cat a/c/b.txt`\"" msgstr "\"`cat a/c/b.txt`\"" #: src/std_misc/fs.md:85 msgid "\"`ls a`\"" msgstr "\"`ls a`\"" #: src/std_misc/fs.md:86 msgid "// Read the contents of a directory, returns `io::Result>`\n" msgstr "// 디렉터리의 내용을 읽습니다. `io::Result>`를 반환합니다\n" #: src/std_misc/fs.md:94 msgid "\"`rm a/c/e.txt`\"" msgstr "\"`rm a/c/e.txt`\"" #: src/std_misc/fs.md:95 msgid "// Remove a file, returns `io::Result<()>`\n" msgstr "// 파일을 제거합니다. `io::Result<()>`를 반환합니다\n" #: src/std_misc/fs.md:100 msgid "\"`rmdir a/c/d`\"" msgstr "\"`rmdir a/c/d`\"" #: src/std_misc/fs.md:101 msgid "// Remove an empty directory, returns `io::Result<()>`\n" msgstr "// 빈 디렉터리를 제거합니다. `io::Result<()>`를 반환합니다\n" #: src/std_misc/fs.md:110 msgid "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" msgstr "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" #: src/std_misc/fs.md:126 msgid "And the final state of the `a` directory is:" msgstr "`a` 디렉터리의 최종 상태는 다음과 같습니다:" #: src/std_misc/fs.md:138 msgid "An alternative way to define the function `cat` is with `?` notation:" msgstr "`cat` 함수를 정의하는 또 다른 방법은 `?` 표기법을 사용하는 것입니다:" #: src/std_misc/fs.md:151 msgid "[`cfg!`](../attribute/cfg.md)" msgstr "[`cfg!`](../attribute/cfg.md)" #: src/std_misc/arg.md:3 msgid "Standard Library" msgstr "표준 라이브러리" #: src/std_misc/arg.md:5 msgid "" "The command line arguments can be accessed using `std::env::args`, which " "returns an iterator that yields a `String` for each argument:" msgstr "" "커맨드 라인 인자들은 `std::env::args`를 통해 접근할 수 있으며, 이는 각 인자" "에 대해 `String`을 내놓는 이터레이터를 반환합니다:" #: src/std_misc/arg.md:14 msgid "// The first argument is the path that was used to call the program.\n" msgstr "// 첫 번째 인자는 프로그램을 호출하는 데 사용된 경로입니다.\n" #: src/std_misc/arg.md:15 msgid "\"My path is {}.\"" msgstr "\"제 경로는 {}입니다.\"" #: src/std_misc/arg.md:17 msgid "" "// The rest of the arguments are the passed command line parameters.\n" " // Call the program like this:\n" " // $ ./args arg1 arg2\n" msgstr "" "// 나머지 인자들은 전달된 커맨드 라인 파라미터들입니다.\n" "// 프로그램을 다음과 같이 호출해 보세요:\n" "// $ ./args arg1 arg2\n" #: src/std_misc/arg.md:20 msgid "\"I got {:?} arguments: {:?}.\"" msgstr "\"{}개의 인자를 받았습니다: {:?}.\"" #: src/std_misc/arg.md:24 msgid "" "```shell\n" "$ ./args 1 2 3\n" "My path is ./args.\n" "I got 3 arguments: [\"1\", \"2\", \"3\"].\n" "```" msgstr "" "```shell\n" "$ ./args 1 2 3\n" "제 경로는 ./args입니다.\n" "3개의 인자를 받았습니다: [\"1\", \"2\", \"3\"].\n" "```" #: src/std_misc/arg.md:32 msgid "" "Alternatively, there are numerous crates that can provide extra " "functionality when creating command-line applications. One of the more " "popular command line argument crates being [`clap`](https://rust-" "cli.github.io/book/tutorial/cli-args.html#parsing-cli-arguments-with-clap)." msgstr "" "또는 커맨드 라인 애플리케이션을 만들 때 추가 기능을 제공하는 수많은 크레이트" "들이 있습니다. 가장 인기 있는 커맨드 라인 인자 크레이트 중 하나는 [`clap`]" "(https://rust-cli.github.io/book/tutorial/cli-args.html#parsing-cli-" "arguments-with-clap)입니다." #: src/std_misc/arg/matching.md:3 msgid "Matching can be used to parse simple arguments:" msgstr "`match`를 사용하여 간단한 인자들을 파싱할 수 있습니다:" #: src/std_misc/arg/matching.md:17 msgid "" "\"usage:\n" "match_args \n" " Check whether given string is the answer.\n" "match_args {{increase|decrease}} \n" " Increase or decrease given integer by one.\"" msgstr "" "\"사용법:\n" "match_args \n" " 주어진 문자열이 정답인지 확인합니다.\n" "match_args {{increase|decrease}} \n" " 주어진 정수를 1만큼 증가시키거나 감소시킵니다.\"" #: src/std_misc/arg/matching.md:28 msgid "// no arguments passed\n" msgstr "// 전달된 인자가 없음\n" #: src/std_misc/arg/matching.md:30 msgid "\"My name is 'match_args'. Try passing some arguments!\"" msgstr "\"제 이름은 'match_args'입니다. 인자를 전달해 보세요!\"" #: src/std_misc/arg/matching.md:32 msgid "// one argument passed\n" msgstr "// 한 개의 인자가 전달됨\n" #: src/std_misc/arg/matching.md:35 msgid "\"This is the answer!\"" msgstr "\"정답입니다!\"" #: src/std_misc/arg/matching.md:36 msgid "\"This is not the answer.\"" msgstr "\"정답이 아닙니다.\"" #: src/std_misc/arg/matching.md:39 msgid "// one command and one argument passed\n" msgstr "// 하나의 명령어와 하나의 인자가 전달됨\n" #: src/std_misc/arg/matching.md:43 msgid "// parse the number\n" msgstr "// 숫자를 파싱합니다\n" #: src/std_misc/arg/matching.md:49 msgid "\"error: second argument not an integer\"" msgstr "\"에러: 두 번째 인자가 정수가 아닙니다\"" #: src/std_misc/arg/matching.md:54 msgid "// parse the command\n" msgstr "// 명령어를 파싱합니다\n" #: src/std_misc/arg/matching.md:56 msgid "\"increase\"" msgstr "\"increase\"" #: src/std_misc/arg/matching.md:57 msgid "\"decrease\"" msgstr "\"decrease\"" #: src/std_misc/arg/matching.md:59 msgid "\"error: invalid command\"" msgstr "\"에러: 유효하지 않은 명령어\"" #: src/std_misc/arg/matching.md:64 msgid "// all the other cases\n" msgstr "// 그 외의 모든 경우\n" #: src/std_misc/arg/matching.md:66 msgid "// show a help message\n" msgstr "// 도움말 메시지를 표시함\n" #: src/std_misc/arg/matching.md:73 msgid "" "If you named your program `match_args.rs` and compile it like this `rustc " "match_args.rs`, you can execute it as follows:" msgstr "" "프로그램 이름을 `match_args.rs`라고 짓고 `rustc match_args.rs`와 같이 컴파일" "했다면, 다음과 같이 실행할 수 있습니다:" #: src/std_misc/ffi.md:3 msgid "" "Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign " "functions must be declared inside an `extern` block annotated with a " "`#[link]` attribute containing the name of the foreign library." msgstr "" "Rust는 C 라이브러리에 대한 외부 함수 인터페이스(Foreign Function Interface, " "FFI)를 제공합니다. 외부 함수는 외부 라이브러리의 이름이 포함된 `#[link]` 속성" "이 달린 `extern` 블록 내에 선언되어야 합니다." #: src/std_misc/ffi.md:9 msgid "// this extern block links to the libm library\n" msgstr "// 이 extern 블록은 libm 라이브러리에 링크됩니다\n" #: src/std_misc/ffi.md:12 msgid "\"msvcrt\"" msgstr "\"msvcrt\"" #: src/std_misc/ffi.md:14 src/std_misc/ffi.md:23 msgid "" "// this is a foreign function\n" " // that computes the square root of a single precision complex number\n" msgstr "" "// 이는 단정도 복소수의 제곱근을 계산하는\n" "// 외부 함수입니다\n" #: src/std_misc/ffi.md:21 msgid "\"m\"" msgstr "\"m\"" #: src/std_misc/ffi.md:29 msgid "" "// Since calling foreign functions is considered unsafe,\n" "// it's common to write safe wrappers around them.\n" msgstr "" "// 외부 함수를 호출하는 것은 안전하지 않은(unsafe) 것으로 간주되므로,\n" "// 이를 감싸는 안전한 래퍼(wrapper)를 작성하는 것이 일반적입니다.\n" #: src/std_misc/ffi.md:37 msgid "// z = -1 + 0i\n" msgstr "// z = -1 + 0i\n" #: src/std_misc/ffi.md:40 msgid "// calling a foreign function is an unsafe operation\n" msgstr "// 외부 함수를 호출하는 것은 안전하지 않은(unsafe) 작업입니다\n" #: src/std_misc/ffi.md:43 msgid "\"the square root of {:?} is {:?}\"" msgstr "\"{:?}의 제곱근은 {:?}입니다\"" #: src/std_misc/ffi.md:45 msgid "// calling safe API wrapped around unsafe operation\n" msgstr "// unsafe 연산을 감싼 안전한 API 호출\n" #: src/std_misc/ffi.md:46 msgid "\"cos({:?}) = {:?}\"" msgstr "\"cos({:?}) = {:?}\"" #: src/std_misc/ffi.md:48 msgid "// Minimal implementation of single precision complex numbers\n" msgstr "// 단정밀도 복소수의 최소 구현\n" #: src/std_misc/ffi.md:60 msgid "\"{}-{}i\"" msgstr "\"{}-{}i\"" #: src/std_misc/ffi.md:62 msgid "\"{}+{}i\"" msgstr "\"{}+{}i\"" #: src/testing.md:3 msgid "" "Rust is a programming language that cares a lot about correctness and it " "includes support for writing software tests within the language itself." msgstr "" "Rust는 올바름(correctness)을 매우 중요하게 생각하는 프로그래밍 언어이며, 언" "어 자체에서 소프트웨어 테스트 작성을 지원합니다." #: src/testing.md:6 msgid "Testing comes in three styles:" msgstr "테스트는 세 가지 스타일로 제공됩니다:" #: src/testing.md:8 msgid "[Unit](testing/unit_testing.md) testing." msgstr "[유닛(Unit)](testing/unit_testing.md) 테스트." #: src/testing.md:9 msgid "[Doc](testing/doc_testing.md) testing." msgstr "[문서(Doc)](testing/doc_testing.md) 테스트." #: src/testing.md:10 msgid "[Integration](testing/integration_testing.md) testing." msgstr "[통합(Integration)](testing/integration_testing.md) 테스트." #: src/testing.md:12 msgid "Also Rust has support for specifying additional dependencies for tests:" msgstr "또한 Rust는 테스트를 위한 추가 의존성 지정을 지원합니다:" #: src/testing.md:14 msgid "[Dev-dependencies](testing/dev_dependencies.md)" msgstr "[개발 의존성(Dev-dependencies)](testing/dev_dependencies.md)" #: src/testing.md:18 msgid "" "[The Book](https://doc.rust-lang.org/book/ch11-00-testing.html) chapter on " "testing" msgstr "" "테스트에 관한 [The Book](https://doc.rust-lang.org/book/ch11-00-" "testing.html) 장" #: src/testing.md:19 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on doc-testing" msgstr "" "문서 테스트(doc-testing)에 관한 [API 가이드라인](https://rust-lang-" "nursery.github.io/api-guidelines/documentation.html)" #: src/testing/unit_testing.md:3 msgid "" "Tests are Rust functions that verify that the non-test code is functioning " "in the expected manner. The bodies of test functions typically perform some " "setup, run the code we want to test, then assert whether the results are " "what we expect." msgstr "" "테스트는 테스트 대상 코드가 예상대로 작동하는지 확인하는 Rust 함수입니다. 테" "스트 함수의 본문은 일반적으로 설정을 수행하고, 테스트하려는 코드를 실행한 다" "음, 결과가 예상과 일치하는지 단언(assert)합니다." #: src/testing/unit_testing.md:8 msgid "" "Most unit tests go into a `tests` [mod](../mod.md) with the `#[cfg(test)]` " "[attribute](../attribute.md). Test functions are marked with the `#[test]` " "attribute." msgstr "" "대부분의 유닛 테스트는 `#[cfg(test)]` [속성](../attribute.md)이 있는 `tests` " "[모듈](../mod.md)에 들어갑니다. 테스트 함수는 `#[test]` 속성으로 표시됩니다." #: src/testing/unit_testing.md:11 msgid "" "Tests fail when something in the test function [panics](../std/panic.md). " "There are some helper [macros](../macros.md):" msgstr "" "테스트 함수 내에서 [패닉](../std/panic.md)이 발생하면 테스트가 실패합니다. 다" "음과 같은 몇 가지 도우미 [매크로](../macros.md)가 있습니다:" #: src/testing/unit_testing.md:14 msgid "`assert!(expression)` - panics if expression evaluates to `false`." msgstr "" "`assert!(expression)` - 표현식의 평가 결과가 `false`이면 패닉을 발생시킵니다." #: src/testing/unit_testing.md:15 msgid "" "`assert_eq!(left, right)` and `assert_ne!(left, right)` - testing left and " "right expressions for equality and inequality respectively." msgstr "" "`assert_eq!(left, right)` 및 `assert_ne!(left, right)` - 왼쪽과 오른쪽 표현식" "이 각각 같은지 또는 다른지를 테스트합니다." #: src/testing/unit_testing.md:22 msgid "" "// This is a really bad adding function, its purpose is to fail in this\n" "// example.\n" msgstr "" "// 이것은 정말 형편없는 더하기 함수입니다. 이 예제에서 실패하도록 만드는 것" "이 목적입니다.\n" #: src/testing/unit_testing.md:32 msgid "" "// Note this useful idiom: importing names from outer (for mod tests) " "scope.\n" msgstr "" "// 이 유용한 관용구를 기억하세요: 외부 스코프(mod tests의 경우)에서 이름들을 " "가져옵니다.\n" #: src/testing/unit_testing.md:42 msgid "" "// This assert would fire and test will fail.\n" " // Please note, that private functions can be tested too!\n" msgstr "" "// 이 단언(assert)은 실행될 것이고 테스트는 실패할 것입니다.\n" " // 참고로, 프라이빗 함수도 테스트할 수 있습니다!\n" #: src/testing/unit_testing.md:49 msgid "Tests can be run with `cargo test`." msgstr "테스트는 `cargo test`로 실행할 수 있습니다." #: src/testing/unit_testing.md:73 msgid "Tests and `?`" msgstr "테스트와 `?`" #: src/testing/unit_testing.md:75 msgid "" "None of the previous unit test examples had a return type. But in Rust 2018, " "your unit tests can return `Result<()>`, which lets you use `?` in them! " "This can make them much more concise." msgstr "" "이전의 유닛 테스트 예제들에는 반환 타입이 없었습니다. 하지만 Rust 2018에서는 " "유닛 테스트가 `Result<()>`를 반환할 수 있어, 테스트 내에서 `?`를 사용할 수 있" "습니다! 이를 통해 테스트를 훨씬 더 간결하게 만들 수 있습니다." #: src/testing/unit_testing.md:84 msgid "\"negative floats don't have square roots\"" msgstr "\"음수 부동 소수점은 제곱근을 가질 수 없습니다\"" #: src/testing/unit_testing.md:101 msgid "" "See [\"The Edition Guide\"](https://doc.rust-lang.org/edition-guide/" "rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html) " "for more details." msgstr "" "더 자세한 내용은 [\"The Edition Guide\"](https://doc.rust-lang.org/edition-" "guide/rust-2018/error-handling-and-panics/question-mark-in-main-and-" "tests.html)를 참조하세요." #: src/testing/unit_testing.md:103 msgid "Testing panics" msgstr "패닉 테스트" #: src/testing/unit_testing.md:105 msgid "" "To check functions that should panic under certain circumstances, use " "attribute `#[should_panic]`. This attribute accepts optional parameter " "`expected = ` with the text of the panic message. If your function can panic " "in multiple ways, it helps make sure your test is testing the correct panic." msgstr "" "특정 상황에서 패닉이 발생해야 하는 함수를 확인하려면 `#[should_panic]` 속성" "을 사용합니다. 이 속성은 선택적 파라미터 `expected = `를 받으며, 패닉 메시지" "의 텍스트를 확인합니다. 만약 여러분의 함수가 여러 방식으로 패닉을 일으킬 수 " "있다면, 이 파라미터는 예상한 패닉이 발생했는지 확인하는 데 도움이 됩니다." #: src/testing/unit_testing.md:110 msgid "" "**Note**: Rust also allows a shorthand form `#[should_panic = \"message\"]`, " "which works exactly like `#[should_panic(expected = \"message\")]`. Both are " "valid; the latter is more commonly used and is considered more explicit." msgstr "" "**참고**: Rust는 `#[should_panic = \"message\"]`와 같은 단축 형태도 허용하" "며, 이는 `#[should_panic(expected = \"message\")]`와 정확히 똑같이 작동합니" "다. 둘 다 유효하지만, 후자가 더 일반적으로 사용되며 더 명시적인 것으로 간주됩" "니다." #: src/testing/unit_testing.md:117 src/testing/doc_testing.md:46 msgid "\"Divide-by-zero error\"" msgstr "\"0으로 나누기 에러\"" #: src/testing/unit_testing.md:119 src/testing/unit_testing.md:140 #: src/testing/unit_testing.md:146 msgid "\"Divide result is zero\"" msgstr "\"나눗셈 결과가 0입니다\"" #: src/testing/unit_testing.md:146 msgid "// This also works\n" msgstr "// 이 방식도 작동합니다\n" #: src/testing/unit_testing.md:153 msgid "Running these tests gives us:" msgstr "이 테스트들을 실행하면 다음과 같은 결과를 얻습니다:" #: src/testing/unit_testing.md:173 msgid "Running specific tests" msgstr "특정 테스트 실행하기" #: src/testing/unit_testing.md:175 msgid "" "To run specific tests one may specify the test name to `cargo test` command." msgstr "" "특정 테스트를 실행하려면 `cargo test` 명령에 테스트 이름을 지정하면 됩니다." #: src/testing/unit_testing.md:191 msgid "" "To run multiple tests one may specify part of a test name that matches all " "the tests that should be run." msgstr "" "여러 테스트를 실행하려면 실행하려는 모든 테스트와 매칭되는 테스트 이름의 일부" "분을 지정하면 됩니다." #: src/testing/unit_testing.md:210 msgid "Ignoring tests" msgstr "테스트 무시하기" #: src/testing/unit_testing.md:212 msgid "" "Tests can be marked with the `#[ignore]` attribute to exclude some tests. Or " "to run them with command `cargo test -- --ignored`" msgstr "" "일부 테스트를 제외하기 위해 `#[ignore]` 속성을 표시할 수 있습니다. 또는 " "`cargo test -- --ignored` 명령으로 무시된 테스트들만 실행할 수도 있습니다." #: src/testing/doc_testing.md:3 msgid "" "The primary way of documenting a Rust project is through annotating the " "source code. Documentation comments are written in [CommonMark Markdown " "specification](https://commonmark.org/) and support code blocks in them. " "Rust takes care about correctness, so these code blocks are compiled and " "used as documentation tests." msgstr "" "Rust 프로젝트를 문서화하는 기본 방법은 소스 코드에 주석을 다는 것입니다. 문서" "화 주석은 [CommonMark Markdown 명세](https://commonmark.org/)로 작성되며 코" "드 블록을 지원합니다. Rust는 올바름(correctness)을 중요하게 생각하므로, 이러" "한 코드 블록들은 컴파일되어 문서 테스트(documentation tests)로 사용됩니다." #: src/testing/doc_testing.md:10 msgid "" "/// First line is a short summary describing function.\n" "///\n" "/// The next lines present detailed documentation. Code blocks start with\n" "/// triple backquotes and have implicit `fn main()` inside\n" "/// and `extern crate `. Assume we're testing a `playground` " "library\n" "/// crate or using the Playground's Test action:\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" msgstr "" "/// 첫 번째 줄은 함수를 설명하는 짧은 요약입니다.\n" "///\n" "/// 다음 줄들은 상세한 문서화를 보여줍니다. 코드 블록은 백틱 세 개로 시작하" "며,\n" "/// 내부적으로 암시적인 `fn main()`과 `extern crate `을 가집니" "다.\n" "/// `playground` 라이브러리 크레이트를 테스트하거나 플레이그라운드의\n" "/// Test 액션을 사용하는 예시라고 가정해 봅시다:\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" #: src/testing/doc_testing.md:24 msgid "" "/// Usually doc comments may include sections \"Examples\", \"Panics\" and " "\"Failures\".\n" "///\n" "/// The next function divides two numbers.\n" "///\n" "/// # Examples\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # Panics\n" "///\n" "/// The function panics if the second argument is zero.\n" "///\n" "/// ```rust,should_panic\n" "/// // panics on division by zero\n" "/// playground::div(10, 0);\n" "/// ```\n" msgstr "" "/// 일반적으로 문서 주석에는 \"Examples\", \"Panics\", \"Failures\" 섹션이 포" "함될 수 있습니다.\n" "///\n" "/// 다음 함수는 두 수를 나눕니다.\n" "///\n" "/// # Examples\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # Panics\n" "///\n" "/// 두 번째 인자가 0이면 함수가 패닉을 발생시킵니다.\n" "///\n" "/// ```rust,should_panic\n" "/// // 0으로 나누기 시 패닉 발생\n" "/// playground::div(10, 0);\n" "/// ```\n" #: src/testing/doc_testing.md:53 msgid "" "Code blocks in documentation are automatically tested when running the " "regular `cargo test` command:" msgstr "" "문서 내의 코드 블록은 일반적인 `cargo test` 명령을 실행할 때 자동으로 테스트" "됩니다:" #: src/testing/doc_testing.md:72 msgid "Motivation behind documentation tests" msgstr "문서 테스트의 의도" #: src/testing/doc_testing.md:74 msgid "" "The main purpose of documentation tests is to serve as examples that " "exercise the functionality, which is one of the most important [guidelines]" "(https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html#examples-use--not-try-not-unwrap-c-question-mark). It " "allows using examples from docs as complete code snippets. But using `?` " "makes compilation fail since `main` returns `unit`. The ability to hide some " "source lines from documentation comes to the rescue: one may write `fn " "try_main() -> Result<(), ErrorType>`, hide it and `unwrap` it in hidden " "`main`. Sounds complicated? Here's an example:" msgstr "" "문서 테스트의 주된 목적은 기능을 실행해보는 예시로서의 역할을 하는 것이며, 이" "는 가장 중요한 [가이드라인](https://rust-lang-nursery.github.io/api-" "guidelines/documentation.html#examples-use--not-try-not-unwrap-c-question-" "mark) 중 하나입니다. 이를 통해 문서의 예시를 완전한 코드 스니펫으로 사용할 " "수 있습니다. 하지만 `main`이 유닛 타입(`unit`)을 반환하기 때문에 `?`를 사용하" "면 컴파일에 실패합니다. 이때 문서에서 일부 소스 라인을 숨길 수 있는 기능이 도" "움이 됩니다. `fn try_main() -> Result<(), ErrorType>`을 작성하고, 이를 숨긴 " "뒤 숨겨진 `main`에서 `unwrap` 할 수 있습니다. 복잡하게 들리나요? 여기 예시가 " "있습니다:" #: src/testing/doc_testing.md:83 msgid "" "/// Using hidden `try_main` in doc tests.\n" "///\n" "/// ```\n" "/// # // hidden lines start with `#` symbol, but they're still compilable!\n" "/// # fn try_main() -> Result<(), String> { // line that wraps the body " "shown in doc\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // returning from try_main\n" "/// # }\n" "/// # fn main() { // starting main that'll unwrap()\n" "/// # try_main().unwrap(); // calling try_main and unwrapping\n" "/// # // so that test will panic in case of error\n" "/// # }\n" "/// ```\n" msgstr "" "/// 문서 테스트에서 숨겨진 `try_main` 사용하기.\n" "///\n" "/// ```\n" "/// # // `#` 기호로 시작하는 줄은 숨겨지지만, 여전히 컴파일 가능합니다!\n" "/// # fn try_main() -> Result<(), String> { // 문서에 보여지는 본문을 감싸는 " "줄\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // try_main에서 반환\n" "/// # }\n" "/// # fn main() { // unwrap()을 호출할 main 시작\n" "/// # try_main().unwrap(); // try_main을 호출하고 unwrap하여\n" "/// # // 에러 발생 시 테스트가 패닉을 일으키도록 함\n" "/// # }\n" "/// ```\n" #: src/testing/doc_testing.md:98 msgid "\"Divide-by-zero\"" msgstr "\"0으로 나누기\"" #: src/testing/doc_testing.md:107 msgid "" "[RFC505](https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-" "conventions.md) on documentation style" msgstr "" "문서 스타일에 관한 [RFC505](https://github.com/rust-lang/rfcs/blob/master/" "text/0505-api-comment-conventions.md)" #: src/testing/doc_testing.md:108 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on documentation guidelines" msgstr "" "문서 가이드라인에 관한 [API 가이드라인](https://rust-lang-nursery.github.io/" "api-guidelines/documentation.html)" #: src/testing/integration_testing.md:3 msgid "" "[Unit tests](unit_testing.md) are testing one module in isolation at a time: " "they're small and can test private code. Integration tests are external to " "your crate and use only its public interface in the same way any other code " "would. Their purpose is to test that many parts of your library work " "correctly together." msgstr "" "[유닛 테스트](unit_testing.md)는 한 번에 하나의 모듈을 격리하여 테스트합니" "다. 유닛 테스트는 크기가 작고 프라이빗 코드도 테스트할 수 있습니다. 통합 테스" "트는 크레이트 외부에 존재하며, 다른 코드와 마찬가지로 공개(public) 인터페이스" "만 사용합니다. 통합 테스트의 목적은 라이브러리의 여러 부분이 함께 올바르게 작" "동하는지 테스트하는 것입니다." #: src/testing/integration_testing.md:8 msgid "Cargo looks for integration tests in `tests` directory next to `src`." msgstr "Cargo는 `src` 옆의 `tests` 디렉터리에서 통합 테스트를 찾습니다." #: src/testing/integration_testing.md:10 src/testing/dev_dependencies.md:17 msgid "File `src/lib.rs`:" msgstr "`src/lib.rs` 파일:" #: src/testing/integration_testing.md:13 msgid "// Define this in a crate called `adder`.\n" msgstr "// `adder`라는 이름의 크레이트에 이를 정의합니다.\n" #: src/testing/integration_testing.md:19 msgid "File with test: `tests/integration_test.rs`:" msgstr "테스트 파일: `tests/integration_test.rs`:" #: src/testing/integration_testing.md:28 msgid "Running tests with `cargo test` command:" msgstr "`cargo test` 명령으로 테스트 실행하기:" #: src/testing/integration_testing.md:50 msgid "" "Each Rust source file in the `tests` directory is compiled as a separate " "crate. In order to share some code between integration tests we can make a " "module with public functions, importing and using it within tests." msgstr "" "통합 테스트 간에 일부 코드를 공유하기 위해 공개 함수가 있는 모듈을 만들고, 이" "를 테스트 내에서 가져와 사용할 수 있습니다." #: src/testing/integration_testing.md:54 msgid "File `tests/common/mod.rs`:" msgstr "`tests/common/mod.rs` 파일:" #: src/testing/integration_testing.md:58 msgid "" "// some setup code, like creating required files/directories, starting\n" " // servers, etc.\n" msgstr "// 필요한 파일/디렉터리 생성, 서버 시작 등과 같은 일부 설정 코드\n" #: src/testing/integration_testing.md:63 msgid "File with test: `tests/integration_test.rs`" msgstr "테스트 파일: `tests/integration_test.rs`" #: src/testing/integration_testing.md:66 msgid "// importing common module.\n" msgstr "// common 모듈 가져오기.\n" #: src/testing/integration_testing.md:71 msgid "// using common code.\n" msgstr "// 공통 코드 사용하기.\n" #: src/testing/integration_testing.md:77 msgid "" "Creating the module as `tests/common.rs` also works, but is not recommended " "because the test runner will treat the file as a test crate and try to run " "tests inside it." msgstr "" "`tests/common.rs`로 모듈을 만드는 것도 가능하지만, 테스트 러너가 이 파일을 테" "스트 크레이트로 취급하여 내부의 테스트를 실행하려 하므로 권장되지 않습니다." #: src/testing/dev_dependencies.md:1 msgid "Development dependencies" msgstr "개발 의존성" #: src/testing/dev_dependencies.md:3 msgid "" "Sometimes there is a need to have dependencies for tests (or examples, or " "benchmarks) only. Such dependencies are added to `Cargo.toml` in the `[dev-" "dependencies]` section. These dependencies are not propagated to other " "packages which depend on this package." msgstr "" "가끔 테스트(또는 예제, 벤치마크)만을 위한 의존성이 필요할 때가 있습니다. 이러" "한 의존성은 `Cargo.toml`의 `[dev-dependencies]` 섹션에 추가됩니다. 이 의존성" "들은 이 패키지에 의존하는 다른 패키지들로는 전파되지 않습니다." #: src/testing/dev_dependencies.md:8 msgid "" "One such example is [`pretty_assertions`](https://docs.rs/pretty_assertions/" "1.0.0/pretty_assertions/index.html), which extends standard `assert_eq!` and " "`assert_ne!` macros, to provide colorful diff. File `Cargo.toml`:" msgstr "" "그러한 예 중 하나로 표준 `assert_eq!` 및 `assert_ne!` 매크로를 확장하여 색상" "화된 diff를 제공하는 [`pretty_assertions`](https://docs.rs/pretty_assertions/" "1.0.0/pretty_assertions/index.html)가 있습니다. `Cargo.toml` 파일:" #: src/testing/dev_dependencies.md:11 msgid "" "```toml\n" "# standard crate data is left out\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" msgstr "" "```toml\n" "# 표준 크레이트 데이터는 생략되었습니다\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" #: src/testing/dev_dependencies.md:27 msgid "// crate for test-only use. Cannot be used in non-test code.\n" msgstr "" "// 테스트 전용으로만 사용되는 크레이트입니다. 테스트가 아닌 코드에서는 사용" "할 수 없습니다.\n" #: src/testing/dev_dependencies.md:38 msgid "" "[Cargo](http://doc.crates.io/specifying-dependencies.html) docs on " "specifying dependencies." msgstr "" "의존성 지정에 관한 [Cargo](http://doc.crates.io/specifying-" "dependencies.html) 문서." #: src/unsafe.md:3 msgid "" "As an introduction to this section, to borrow from [the official docs]" "(https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html), \"one should try " "to minimize the amount of unsafe code in a code base.\" With that in mind, " "let's get started! Unsafe annotations in Rust are used to bypass protections " "put in place by the compiler; specifically, there are four primary things " "that unsafe is used for:" msgstr "" "이 섹션을 시작하며 [공식 문서](https://doc.rust-lang.org/book/ch19-01-unsafe-" "rust.html)의 말을 빌리자면, \"코드베이스에서 unsafe 코드의 양을 최소화하도록 " "노력해야 합니다.\" 이 점을 염두에 두고 시작해 봅시다! Rust에서 Unsafe 어노테" "이션은 컴파일러가 제공하는 보호 기능을 우회하는 데 사용됩니다. 구체적으로, " "unsafe는 다음과 같은 네 가지 주요 작업에 사용됩니다:" #: src/unsafe.md:9 msgid "dereferencing raw pointers" msgstr "raw 포인터 역참조하기" #: src/unsafe.md:10 msgid "" "calling functions or methods which are `unsafe` (including calling a " "function over FFI, see [a previous chapter](std_misc/ffi.md) of the book)" msgstr "" "`unsafe` 함수나 메서드 호출하기 (FFI를 통한 함수 호출 포함, 이 책의 [이전 장]" "(std_misc/ffi.md) 참조)" #: src/unsafe.md:12 msgid "accessing or modifying static mutable variables" msgstr "정적 가변(static mutable) 변수에 접근하거나 수정하기" #: src/unsafe.md:13 msgid "implementing unsafe traits" msgstr "unsafe 트레이트 구현하기" #: src/unsafe.md:15 msgid "Raw Pointers" msgstr "Raw 포인터" #: src/unsafe.md:17 msgid "" "Raw pointers `*` and references `&T` function similarly, but references are " "always safe because they are guaranteed to point to valid data due to the " "borrow checker. Dereferencing a raw pointer can only be done through an " "unsafe block." msgstr "" "Raw 포인터 `*`와 참조 `&T`는 비슷하게 작동하지만, 참조는 빌림 검사기(borrow " "checker) 덕분에 항상 유효한 데이터를 가리킨다는 것이 보장되므로 항상 안전합니" "다. Raw 포인터의 역참조는 unsafe 블록을 통해서만 수행될 수 있습니다." #: src/unsafe.md:32 msgid "Calling Unsafe Functions" msgstr "Unsafe 함수 호출하기" #: src/unsafe.md:34 msgid "" "Some functions can be declared as `unsafe`, meaning it is the programmer's " "responsibility to ensure correctness instead of the compiler's. One example " "of this is [`std::slice::from_raw_parts`](https://doc.rust-lang.org/std/" "slice/fn.from_raw_parts.html) which will create a slice given a pointer to " "the first element and a length." msgstr "" "일부 함수는 `unsafe`로 선언될 수 있는데, 이는 컴파일러 대신 프로그래머가 올바" "름을 보장해야 할 책임이 있음을 의미합니다. 그 예로 첫 번째 요소에 대한 포인터" "와 길이를 받아 슬라이스를 생성하는 [`std::slice::from_raw_parts`](https://" "doc.rust-lang.org/std/slice/fn.from_raw_parts.html)가 있습니다." #: src/unsafe.md:56 msgid "" "For `slice::from_raw_parts`, one of the assumptions which _must_ be upheld " "is that the pointer passed in points to valid memory and that the memory " "pointed to is of the correct type. If these invariants aren't upheld then " "the program's behaviour is undefined and there is no knowing what will " "happen." msgstr "" "`slice::from_raw_parts`의 경우, 반드시 지켜져야 하는 가정 중 하나는 전달된 포" "인터가 유효한 메모리를 가리키고 가리키는 메모리가 올바른 타입이어야 한다는 것" "입니다. 이러한 불변성(invariant)이 지켜지지 않으면 프로그램의 동작은 정의되" "지 않으며 어떤 일이 일어날지 알 수 없습니다." #: src/unsafe/asm.md:3 msgid "" "Rust provides support for inline assembly via the `asm!` macro. It can be " "used to embed handwritten assembly in the assembly output generated by the " "compiler. Generally this should not be necessary, but might be where the " "required performance or timing cannot be otherwise achieved. Accessing low " "level hardware primitives, e.g. in kernel code, may also demand this " "functionality." msgstr "" "Rust는 `asm!` 매크로를 통해 인라인 어셈블리를 지원합니다. 이를 통해 컴파일러" "가 생성하는 어셈블리 출력에 수기로 작성한 어셈블리를 삽입할 수 있습니다. 일반" "적으로 이는 필요하지 않지만, 다른 방법으로는 필요한 성능이나 타이밍을 달성할 " "수 없는 경우에 유용할 수 있습니다. 커널 코드와 같은 저수준 하드웨어 프리미티" "브에 접근하는 경우에도 이 기능이 필요할 수 있습니다." #: src/unsafe/asm.md:8 msgid "" "**Note**: the examples here are given in x86/x86-64 assembly, but other " "architectures are also supported." msgstr "" "**참고**: 여기의 예제들은 x86/x86-64 어셈블리로 제공되지만, 다른 아키텍처도 " "지원됩니다." #: src/unsafe/asm.md:10 msgid "Inline assembly is currently supported on the following architectures:" msgstr "인라인 어셈블리는 현재 다음 아키텍처에서 지원됩니다:" #: src/unsafe/asm.md:12 msgid "x86 and x86-64" msgstr "x86 및 x86-64" #: src/unsafe/asm.md:13 msgid "ARM" msgstr "ARM" #: src/unsafe/asm.md:14 msgid "AArch64" msgstr "AArch64" #: src/unsafe/asm.md:15 msgid "RISC-V" msgstr "RISC-V" #: src/unsafe/asm.md:17 msgid "Basic usage" msgstr "기본 사용법" #: src/unsafe/asm.md:19 msgid "Let us start with the simplest possible example:" msgstr "가장 간단한 예제부터 시작해 봅시다:" #: src/unsafe/asm.md:22 src/unsafe/asm.md:42 src/unsafe/asm.md:69 #: src/unsafe/asm.md:107 src/unsafe/asm.md:124 src/unsafe/asm.md:149 #: src/unsafe/asm.md:183 src/unsafe/asm.md:204 src/unsafe/asm.md:221 #: src/unsafe/asm.md:260 src/unsafe/asm.md:296 src/unsafe/asm.md:312 #: src/unsafe/asm.md:338 src/unsafe/asm.md:376 src/unsafe/asm.md:403 #: src/unsafe/asm.md:427 src/unsafe/asm.md:465 msgid "\"x86_64\"" msgstr "\"x86_64\"" #: src/unsafe/asm.md:26 msgid "\"nop\"" msgstr "\"nop\"" #: src/unsafe/asm.md:31 msgid "" "This will insert a NOP (no operation) instruction into the assembly " "generated by the compiler. Note that all `asm!` invocations have to be " "inside an `unsafe` block, as they could insert arbitrary instructions and " "break various invariants. The instructions to be inserted are listed in the " "first argument of the `asm!` macro as a string literal." msgstr "" "이 코드는 컴파일러가 생성한 어셈블리에 NOP (no operation) 명령어를 삽입합니" "다. `asm!` 호출은 임의의 명령어를 삽입하여 다양한 불변성을 깰 수 있으므로 모" "두 `unsafe` 블록 안에 있어야 한다는 점에 유의하세요. 삽입할 명령어는 `asm!` " "매크로의 첫 번째 인자에 문자열 리터럴로 나열됩니다." #: src/unsafe/asm.md:36 msgid "Inputs and outputs" msgstr "입력과 출력" #: src/unsafe/asm.md:38 msgid "" "Now inserting an instruction that does nothing is rather boring. Let us do " "something that actually acts on data:" msgstr "" "아무것도 하지 않는 명령어를 넣는 것은 꽤 지루합니다. 실제로 데이터에 작용하" "는 무언가를 해봅시다:" #: src/unsafe/asm.md:47 msgid "\"mov {}, 5\"" msgstr "\"mov {}, 5\"" #: src/unsafe/asm.md:53 msgid "" "This will write the value `5` into the `u64` variable `x`. You can see that " "the string literal we use to specify instructions is actually a template " "string. It is governed by the same rules as Rust [format strings](https://" "doc.rust-lang.org/std/fmt/#syntax). The arguments that are inserted into the " "template however look a bit different than you may be familiar with. First " "we need to specify if the variable is an input or an output of the inline " "assembly. In this case it is an output. We declared this by writing `out`. " "We also need to specify in what kind of register the assembly expects the " "variable. In this case we put it in an arbitrary general purpose register by " "specifying `reg`. The compiler will choose an appropriate register to insert " "into the template and will read the variable from there after the inline " "assembly finishes executing." msgstr "" "이 코드는 값 `5`를 `u64` 변수 `x`에 씁니다. 명령어를 지정하는 데 사용하는 문" "자열 리터럴이 실제로는 템플릿 문자열이라는 것을 알 수 있습니다. 이는 Rust [형" "식 문자열](https://doc.rust-lang.org/std/fmt/#syntax)과 동일한 규칙의 적용을 " "받습니다. 하지만 템플릿에 삽입되는 인자들은 여러분에게 익숙한 것과는 조금 달" "라 보일 수 있습니다. 먼저 변수가 인라인 어셈블리의 입력인지 출력인지를 지정해" "야 합니다. 이 경우에는 출력입니다. 우리는 `out`을 작성하여 이를 선언했습니" "다. 또한 어셈블리가 변수를 어떤 종류의 레지스터에 두기를 기대하는지도 지정해" "야 합니다. 이 경우에는 `reg`를 지정하여 임의의 범용 레지스터에 넣었습니다. 컴" "파일러는 템플릿에 삽입할 적절한 레지스터를 선택하고, 인라인 어셈블리 실행이 " "끝난 후 해당 레지스터에서 변수를 읽어올 것입니다." #: src/unsafe/asm.md:66 msgid "Let us see another example that also uses an input:" msgstr "입력을 사용하는 또 다른 예제를 살펴봅시다:" #: src/unsafe/asm.md:76 msgid "\"mov {0}, {1}\"" msgstr "\"mov {0}, {1}\"" #: src/unsafe/asm.md:77 src/unsafe/asm.md:112 src/unsafe/asm.md:130 msgid "\"add {0}, 5\"" msgstr "\"add {0}, 5\"" #: src/unsafe/asm.md:86 msgid "" "This will add `5` to the input in variable `i` and write the result to " "variable `o`. The particular way this assembly does this is first copying " "the value from `i` to the output, and then adding `5` to it." msgstr "" "이 코드는 변수 `i`의 입력에 `5`를 더하고 그 결과를 변수 `o`에 씁니다. 이 어셈" "블리가 이를 수행하는 구체적인 방식은 먼저 `i`의 값을 출력으로 복사한 다음, 거" "기에 `5`를 더하는 것입니다." #: src/unsafe/asm.md:90 msgid "The example shows a few things:" msgstr "이 예제는 몇 가지를 보여줍니다:" #: src/unsafe/asm.md:92 msgid "" "First, we can see that `asm!` allows multiple template string arguments; " "each one is treated as a separate line of assembly code, as if they were all " "joined together with newlines between them. This makes it easy to format " "assembly code." msgstr "" "첫째, `asm!`이 여러 템플릿 문자열 인자를 허용한다는 것을 알 수 있습니다. 각각" "은 별도의 어셈블리 코드 줄로 처리되며, 마치 줄바꿈으로 모두 연결된 것처럼 작" "동합니다. 이를 통해 어셈블리 코드를 쉽게 포맷팅할 수 있습니다." #: src/unsafe/asm.md:97 msgid "" "Second, we can see that inputs are declared by writing `in` instead of `out`." msgstr "" "둘째, `out` 대신 `in`을 작성하여 입력을 선언한다는 것을 알 수 있습니다." #: src/unsafe/asm.md:99 msgid "" "Third, we can see that we can specify an argument number, or name as in any " "format string. For inline assembly templates this is particularly useful as " "arguments are often used more than once. For more complex inline assembly " "using this facility is generally recommended, as it improves readability, " "and allows reordering instructions without changing the argument order." msgstr "" "셋째, 다른 형식 문자열에서처럼 인자 번호나 이름을 지정할 수 있음을 알 수 있습" "니다. 인라인 어셈블리 템플릿에서는 인자가 한 번 이상 사용되는 경우가 많기 때" "문에 이 기능이 특히 유용합니다. 복잡한 인라인 어셈블리의 경우 이 기능을 사용" "하는 것이 일반적으로 권장되는데, 가독성을 높이고 인자 순서를 변경하지 않고도 " "명령어를 재배치할 수 있게 해주기 때문입니다." #: src/unsafe/asm.md:104 msgid "We can further refine the above example to avoid the `mov` instruction:" msgstr "위의 예제를 더 개선하여 `mov` 명령어를 피할 수 있습니다:" #: src/unsafe/asm.md:118 msgid "" "We can see that `inout` is used to specify an argument that is both input " "and output. This is different from specifying an input and output separately " "in that it is guaranteed to assign both to the same register." msgstr "" "`inout`이 입력과 출력 모두로 사용되는 인자를 지정하는 데 사용됨을 알 수 있습" "니다. 이는 입력과 출력을 따로 지정하는 것과 다른데, `inout`은 두 경우 모두 동" "일한 레지스터에 할당됨을 보장하기 때문입니다." #: src/unsafe/asm.md:121 msgid "" "It is also possible to specify different variables for the input and output " "parts of an `inout` operand:" msgstr "" "`inout` 피연산자의 입력과 출력 부분에 대해 서로 다른 변수를 지정하는 것도 가" "능합니다:" #: src/unsafe/asm.md:136 msgid "Late output operands" msgstr "늦은(Late) 출력 피연산자" #: src/unsafe/asm.md:85 msgid "" "The Rust compiler is conservative with its allocation of operands. It is " "assumed that an `out` can be written at any time, and can therefore share " "its location with any other argument. However, to guarantee that the " "compiler will not use the same register for another argument because it is " "still required, use `&mut` operands:" msgstr "" "Rust 컴파일러는 피연산자 할당에 보수적입니다. `out`은 언제든지 쓰일 수 있다" "고 가정되며, 따라서 다른 인자와 위치를 공유할 수 있습니다. 하지만 컴파일러" "가 여전히 필요하다는 이유로 다른 인자에 같은 레지스터를 사용하지 않도록 보장" "하려면 `&mut` 피연산자를 사용하세요:" #: src/unsafe/asm.md:146 msgid "" "Here is an example where `inlateout` _cannot_ be used in `release` mode or " "other optimized cases:" msgstr "" "`release` 모드나 기타 최적화된 경우에 `inlateout`을 사용할 수 _없는_ 예시는 " "다음과 같습니다:" #: src/unsafe/asm.md:157 src/unsafe/asm.md:189 src/unsafe/asm.md:472 msgid "\"add {0}, {1}\"" msgstr "\"add {0}, {1}\"" #: src/unsafe/asm.md:158 msgid "\"add {0}, {2}\"" msgstr "\"add {0}, {2}\"" #: src/unsafe/asm.md:168 msgid "" "In unoptimized cases (e.g. `Debug` mode), replacing `inout(reg) a` with " "`inlateout(reg) a` in the above example can continue to give the expected " "result. However, with `release` mode or other optimized cases, using " "`inlateout(reg) a` can instead lead to the final value `a = 16`, causing the " "assertion to fail." msgstr "" "최적화되지 않은 경우(예: `Debug` 모드), 위 예제에서 `inout(reg) a`를 " "`inlateout(reg) a`로 대체해도 계속해서 예상된 결과를 얻을 수 있습니다. 그러" "나 `release` 모드나 기타 최적화된 경우에는 `inlateout(reg) a`를 사용하면 최" "종 값이 `a = 16`이 되어 단언(assertion)이 실패할 수 있습니다." #: src/unsafe/asm.md:173 msgid "" "This is because in optimized cases, the compiler is free to allocate the " "same register for inputs `b` and `c` since it knows that they have the same " "value. Furthermore, when `inlateout` is used, `a` and `c` could be allocated " "to the same register, in which case the first `add` instruction would " "overwrite the initial load from variable `c`. This is in contrast to how " "using `inout(reg) a` ensures a separate register is allocated for `a`." msgstr "" "이는 최적화된 경우 컴파일러가 입력 `b`와 `c`에 대해 동일한 값을 가지고 있음" "을 알고 있으므로 동일한 레지스터를 할당할 수 있기 때문입니다. 또한 " "`inlateout`이 사용될 때 `a`와 `c`가 동일한 레지스터에 할당될 수 있는데, 이 경" "우 첫 번째 `add` 명령어가 변수 `c`로부터의 초기 로드 값을 덮어쓰게 됩니다. 이" "는 `inout(reg) a`를 사용하여 `a`에 대해 별도의 레지스터가 할당되도록 보장하" "는 것과 대조적입니다." #: src/unsafe/asm.md:179 msgid "" "However, the following example can use `inlateout` since the output is only " "modified after all input registers have been read:" msgstr "" "하지만 다음 예제에서는 모든 입력 레지스터를 읽은 후에만 출력이 수정되므로 " "`inlateout`을 사용할 수 있습니다:" #: src/unsafe/asm.md:195 msgid "" "As you can see, this assembly fragment will still work correctly if `a` and " "`b` are assigned to the same register." msgstr "" "보시다시피, `a`와 `b`가 동일한 레지스터에 할당되더라도 이 어셈블리 조각은 여" "전히 올바르게 작동할 것입니다." #: src/unsafe/asm.md:197 msgid "Explicit register operands" msgstr "명시적 레지스터 피연산자" #: src/unsafe/asm.md:199 msgid "" "Some instructions require that the operands be in a specific register. " "Therefore, Rust inline assembly provides some more specific constraint " "specifiers. While `reg` is generally available on any architecture, explicit " "registers are highly architecture specific. E.g. for x86 the general purpose " "registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi` among others " "can be addressed by their name." msgstr "" "일부 명령어는 피연산자가 특정 레지스터에 있어야 함을 요구합니다. 따라서 Rust " "인라인 어셈블리는 몇 가지 더 구체적인 제약 지정자를 제공합니다. `reg`는 일반" "적으로 모든 아키텍처에서 사용할 수 있지만, 명시적 레지스터는 아키텍처에 따라 " "매우 다릅니다. 예를 들어 x86의 경우 `eax`, `ebx`, `ecx`, `edx`, `ebp`, " "`esi`, `edi` 등의 범용 레지스터를 이름으로 지정할 수 있습니다." #: src/unsafe/asm.md:209 msgid "\"out 0x64, eax\"" msgstr "\"out 0x64, eax\"" #: src/unsafe/asm.md:209 src/unsafe/asm.md:285 msgid "\"eax\"" msgstr "\"eax\"" #: src/unsafe/asm.md:214 msgid "" "In this example we call the `out` instruction to output the content of the " "`cmd` variable to port `0x64`. Since the `out` instruction only accepts " "`eax` (and its sub registers) as operand we had to use the `eax` constraint " "specifier." msgstr "" "이 예제에서는 `out` 명령어를 호출하여 `cmd` 변수의 내용을 포트 `0x64`로 출력" "합니다. `out` 명령어는 `eax` (및 그 하위 레지스터)만을 피연산자로 받아들이므" "로 `eax` 제약 지정자를 사용해야 했습니다." #: src/unsafe/asm.md:216 msgid "" "**Note**: unlike other operand types, explicit register operands cannot be " "used in the template string: you can't use `{}` and should write the " "register name directly instead. Also, they must appear at the end of the " "operand list after all other operand types." msgstr "" "**참고**: 다른 피연산자 타입과 달리 명시적 레지스터 피연산자는 템플릿 문자열" "에서 사용할 수 없습니다. `{}`를 사용할 수 없으며 대신 레지스터 이름을 직접 작" "성해야 합니다. 또한 다른 모든 피연산자 타입 뒤에 피연산자 목록의 마지막에 나" "타나야 합니다." #: src/unsafe/asm.md:218 msgid "Consider this example which uses the x86 `mul` instruction:" msgstr "x86 `mul` 명령어를 사용하는 이 예제를 살펴보세요:" #: src/unsafe/asm.md:230 msgid "" "// The x86 mul instruction takes rax as an implicit input and writes\n" " // the 128-bit result of the multiplication to rax:rdx.\n" " \"mul {}\"" msgstr "" "// x86 mul 명령어는 rax를 암시적 입력으로 받고\n" " // 128비트 곱셈 결과를 rax:rdx에 씁니다.\n" " \"mul {}\"" #: src/unsafe/asm.md:234 src/unsafe/asm.md:356 msgid "\"rax\"" msgstr "\"rax\"" #: src/unsafe/asm.md:235 msgid "\"rdx\"" msgstr "\"rdx\"" #: src/unsafe/asm.md:244 msgid "" "This uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit " "result. The only explicit operand is a register, that we fill from the " "variable `a`. The second operand is implicit, and must be the `rax` " "register, which we fill from the variable `b`. The lower 64 bits of the " "result are stored in `rax` from which we fill the variable `lo`. The higher " "64 bits are stored in `rdx` from which we fill the variable `hi`." msgstr "" "이 코드는 `mul` 명령어를 사용하여 두 개의 64비트 입력을 곱해 128비트 결과를 " "얻습니다. 유일한 명시적 피연산자는 레지스터이며, 변수 `a`로 채웁니다. 두 번" "째 피연산자는 암시적이며 `rax` 레지스터여야 하는데, 이는 변수 `b`로 채웁니" "다. 결과의 하위 64비트는 `rax`에 저장되어 변수 `lo`를 채우고, 상위 64비트는 " "`rdx`에 저장되어 변수 `hi`를 채웁니다." #: src/unsafe/asm.md:250 msgid "Clobbered registers" msgstr "클로버(Clobbered) 레지스터" #: src/unsafe/asm.md:252 msgid "" "In many cases inline assembly will modify state that is not needed as an " "output. Usually this is either because we have to use a scratch register in " "the assembly or because instructions modify state that we don't need to " "further examine. This state is generally referred to as being \"clobbered\". " "We need to tell the compiler about this since it may need to save and " "restore this state around the inline assembly block." msgstr "" "많은 경우 인라인 어셈블리는 출력으로 필요하지 않은 상태를 수정합니다. 보통 어" "셈블리 내에서 스크래치 레지스터를 사용해야 하거나, 명령어가 더 이상 검사할 필" "요가 없는 상태를 수정하기 때문입니다. 이러한 상태를 일반적으로 \"클로버" "(clobbered)\" 되었다고 합니다. 컴파일러가 인라인 어셈블리 블록 전후로 이러한 " "상태를 저장하고 복원해야 할 수도 있으므로 이를 컴파일러에 알려야 합니다." #: src/unsafe/asm.md:262 msgid "// three entries of four bytes each\n" msgstr "// 각각 4바이트인 3개의 엔트리\n" #: src/unsafe/asm.md:264 msgid "" "// String is stored as ascii in ebx, edx, ecx in order\n" " // Because ebx is reserved, the asm needs to preserve the value of it.\n" " // So we push and pop it around the main asm.\n" " // 64 bit mode on 64 bit processors does not allow pushing/popping of\n" " // 32 bit registers (like ebx), so we have to use the extended rbx " "register instead.\n" msgstr "" "// 문자열은 ebx, edx, ecx 순서대로 ASCII로 저장됩니다.\n" " // ebx는 예약되어 있으므로, 어셈블리는 이 값을 보존해야 합니다.\n" " // 따라서 메인 어셈블리 전후로 push와 pop을 수행합니다.\n" " // 64비트 프로세서의 64비트 모드에서는 32비트 레지스터(ebx와 같은)를\n" " // push/pop 하는 것을 허용하지 않으므로, 대신 확장된 rbx 레지스터를 사용" "해야 합니다.\n" #: src/unsafe/asm.md:272 msgid "\"push rbx\"" msgstr "\"push rbx\"" #: src/unsafe/asm.md:273 msgid "\"cpuid\"" msgstr "\"cpuid\"" #: src/unsafe/asm.md:274 msgid "\"mov [rdi], ebx\"" msgstr "\"mov [rdi], ebx\"" #: src/unsafe/asm.md:275 msgid "\"mov [rdi + 4], edx\"" msgstr "\"mov [rdi + 4], edx\"" #: src/unsafe/asm.md:276 msgid "\"mov [rdi + 8], ecx\"" msgstr "\"mov [rdi + 8], ecx\"" #: src/unsafe/asm.md:277 msgid "\"pop rbx\"" msgstr "\"pop rbx\"" #: src/unsafe/asm.md:278 msgid "" "// We use a pointer to an array for storing the values to simplify\n" " // the Rust code at the cost of a couple more asm instructions\n" " // This is more explicit with how the asm works however, as " "opposed\n" " // to explicit register outputs such as `out(\"ecx\") val`\n" " // The *pointer itself* is only an input even though it's " "written behind\n" msgstr "" "// 몇 가지 어셈블리 명령어를 더 사용하는 대신 Rust 코드를 단순화하기 위해\n" " // 값을 저장하는 데 배열 포인터를 사용합니다.\n" " // 하지만 이는 `out(\"ecx\") val`과 같은 명시적 레지스터 출력과" "는 반대로\n" " // 어셈블리가 어떻게 작동하는지 더 명시적으로 보여줍니다.\n" " // *포인터 자체*는 비록 그 뒤에 값이 쓰여지더라도 입력일 뿐입니" "다.\n" #: src/unsafe/asm.md:283 src/unsafe/asm.md:354 msgid "\"rdi\"" msgstr "\"rdi\"" #: src/unsafe/asm.md:284 msgid "// select cpuid 0, also specify eax as clobbered\n" msgstr "// cpuid 0을 선택하고, eax를 클로버된 것으로 지정합니다.\n" #: src/unsafe/asm.md:286 msgid "// cpuid clobbers these registers too\n" msgstr "// cpuid는 이 레지스터들도 클로버합니다.\n" #: src/unsafe/asm.md:287 msgid "\"ecx\"" msgstr "\"ecx\"" #: src/unsafe/asm.md:288 msgid "\"edx\"" msgstr "\"edx\"" #: src/unsafe/asm.md:293 msgid "\"CPU Manufacturer ID: {}\"" msgstr "\"CPU 제조사 ID: {}\"" #: src/unsafe/asm.md:300 msgid "" "In the example above we use the `cpuid` instruction to read the CPU " "manufacturer ID. This instruction writes to `eax` with the maximum supported " "`cpuid` argument and `ebx`, `edx`, and `ecx` with the CPU manufacturer ID as " "ASCII bytes in that order." msgstr "" "위의 예제에서는 `cpuid` 명령어를 사용하여 CPU 제조사 ID를 읽습니다. 이 명령어" "는 `eax`에 지원되는 최대 `cpuid` 인자를 쓰고, `ebx`, `edx`, `ecx` 순서대로 " "CPU 제조사 ID를 ASCII 바이트로 씁니다." #: src/unsafe/asm.md:303 msgid "" "Even though `eax` is never read we still need to tell the compiler that the " "register has been modified so that the compiler can save any values that " "were in these registers before the asm. This is done by declaring it as an " "output but with `_` instead of a variable name, which indicates that the " "output value is to be discarded." msgstr "" "`eax`는 결코 읽히지 않지만, 컴파일러가 어셈블리 이전의 레지스터 값을 저장할 " "수 있도록 레지스터가 수정되었음을 알려야 합니다. 이는 출력으로 선언하되 변수 " "이름 대신 `_`를 사용하여 수행하며, 이는 출력 값을 버림을 나타냅니다." #: src/unsafe/asm.md:305 msgid "" "This code also works around the limitation that `ebx` is a reserved register " "by LLVM. That means that LLVM assumes that it has full control over the " "register and it must be restored to its original state before exiting the " "asm block, so it cannot be used as an input or output **except** if the " "compiler uses it to fulfill a general register class (e.g. `in(reg)`). This " "makes `reg` operands dangerous when using reserved registers as we could " "unknowingly corrupt our input or output because they share the same register." msgstr "" "이 코드는 `ebx`가 LLVM에 의해 예약된 레지스터라는 제한 사항도 해결합니다. 이" "는 LLVM이 해당 레지스터를 완전히 제어한다고 가정하며 어셈블리 블록을 종료하" "기 전에 원래 상태로 복원해야 함을 의미합니다. 따라서 컴파일러가 일반 레지스" "터 클래스(예: `in(reg)`)를 충족하기 위해 사용하는 경우를 **제외**하고는 입력" "이나 출력으로 사용할 수 없습니다. 이로 인해 예약된 레지스터를 사용할 때 " "`reg` 피연산자는 위험할 수 있는데, 동일한 레지스터를 공유하여 자신도 모르게 " "입력이나 출력을 손상시킬 수 있기 때문입니다." #: src/unsafe/asm.md:307 msgid "" "To work around this we use `rdi` to store the pointer to the output array, " "save `ebx` via `push`, read from `ebx` inside the asm block into the array " "and then restore `ebx` to its original state via `pop`. The `push` and `pop` " "use the full 64-bit `rbx` version of the register to ensure that the entire " "register is saved. On 32 bit targets the code would instead use `ebx` in the " "`push`/`pop`." msgstr "" "이를 해결하기 위해 `rdi`를 사용하여 출력 배열에 대한 포인터를 저장하고, " "`push`를 통해 `ebx`를 저장한 후, 어셈블리 블록 내에서 `ebx`로부터 배열로 읽" "어 들인 다음, `pop`을 통해 `ebx`를 원래 상태로 복원합니다. 전체 레지스터가 저" "장되도록 `push`와 `pop`은 레지스터의 64비트 버전인 `rbx`를 사용합니다. 32비" "트 타겟의 경우 코드에서 대신 `ebx`를 `push`/`pop`에 사용할 것입니다." #: src/unsafe/asm.md:309 msgid "" "This can also be used with a general register class to obtain a scratch " "register for use inside the asm code:" msgstr "" "이는 어셈블리 코드 내부에서 사용할 스크래치 레지스터를 얻기 위해 일반 레지스" "터 클래스와 함께 사용될 수도 있습니다." #: src/unsafe/asm.md:314 msgid "// Multiply x by 6 using shifts and adds\n" msgstr "// 시프트와 더하기를 사용하여 x에 6을 곱함\n" #: src/unsafe/asm.md:319 msgid "\"mov {tmp}, {x}\"" msgstr "\"mov {tmp}, {x}\"" #: src/unsafe/asm.md:320 msgid "\"shl {tmp}, 1\"" msgstr "\"shl {tmp}, 1\"" #: src/unsafe/asm.md:321 msgid "\"shl {x}, 2\"" msgstr "\"shl {x}, 2\"" #: src/unsafe/asm.md:322 msgid "\"add {x}, {tmp}\"" msgstr "\"add {x}, {tmp}\"" #: src/unsafe/asm.md:331 msgid "Symbol operands and ABI clobbers" msgstr "심볼 피연산자와 ABI 클로버" #: src/unsafe/asm.md:333 msgid "" "By default, `asm!` assumes that any register not specified as an output will " "have its contents preserved by the assembly code. The [`clobber_abi`]" "(https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-" "clobbers) argument to `asm!` tells the compiler to automatically insert the " "necessary clobber operands according to the given calling convention ABI: " "any register which is not fully preserved in that ABI will be treated as " "clobbered. Multiple `clobber_abi` arguments may be provided and all " "clobbers from all specified ABIs will be inserted." msgstr "" "기본적으로 `asm!`은 출력으로 지정되지 않은 모든 레지스터의 내용이 어셈블리 코" "드에 의해 보존된다고 가정합니다. `asm!`의 [`clobber_abi`](https://doc.rust-" "lang.org/stable/reference/inline-assembly.html#abi-clobbers) 인자는 컴파일러" "가 주어진 호출 규약 ABI에 따라 필요한 클로버 피연산자를 자동으로 삽입하도록 " "지시합니다. 해당 ABI에서 완전히 보존되지 않는 모든 레지스터는 클로버된 것으" "로 취급됩니다. 여러 `clobber_abi` 인자를 제공할 수 있으며, 지정된 모든 ABI의 " "모든 클로버가 삽입됩니다." #: src/unsafe/asm.md:341 src/unsafe/asm.md:359 msgid "\"C\"" msgstr "\"C\"" #: src/unsafe/asm.md:342 msgid "\"arg = {}\"" msgstr "\"인자 = {}\"" #: src/unsafe/asm.md:350 msgid "\"call {}\"" msgstr "\"call {}\"" #: src/unsafe/asm.md:351 msgid "// Function pointer to call\n" msgstr "// 호출할 함수 포인터\n" #: src/unsafe/asm.md:353 msgid "// 1st argument in rdi\n" msgstr "// 첫 번째 인자는 rdi에\n" #: src/unsafe/asm.md:355 msgid "// Return value in rax\n" msgstr "// 반환 값은 rax에\n" #: src/unsafe/asm.md:357 msgid "" "// Mark all registers which are not preserved by the \"C\" calling\n" " // convention as clobbered.\n" msgstr "" "// \"C\" 호출 규약에 의해 보존되지 않는 모든 레지스터를 클로버된 것으로 표시" "합니다.\n" #: src/unsafe/asm.md:367 msgid "Register template modifiers" msgstr "레지스터 템플릿 수정자" #: src/unsafe/asm.md:369 msgid "" "In some cases, fine control is needed over the way a register name is " "formatted when inserted into the template string. This is needed when an " "architecture's assembly language has several names for the same register, " "each typically being a \"view\" over a subset of the register (e.g. the low " "32 bits of a 64-bit register)." msgstr "" "어떤 경우에는 템플릿 문자열에 삽입될 때 레지스터 이름이 포맷팅되는 방식에 대" "해 세밀한 제어가 필요합니다. 이는 아키텍처의 어셈블리 언어에 동일한 레지스터" "에 대한 여러 이름이 있을 때 필요하며, 각 이름은 일반적으로 레지스터 일부에 대" "한 \"뷰(view)\"입니다(예: 64비트 레지스터의 하위 32비트)." #: src/unsafe/asm.md:371 msgid "" "By default the compiler will always choose the name that refers to the full " "register size (e.g. `rax` on x86-64, `eax` on x86, etc)." msgstr "" "기본적으로 컴파일러는 항상 전체 레지스터 크기를 참조하는 이름을 선택합니다" "(예: x86-64의 `rax`, x86의 `eax` 등)." #: src/unsafe/asm.md:373 msgid "" "This default can be overridden by using modifiers on the template string " "operands, just like you would with format strings:" msgstr "" "이 기본값은 형식 문자열에서처럼 템플릿 문자열 피연산자에 수정자를 사용하여 재" "정의할 수 있습니다." #: src/unsafe/asm.md:382 msgid "\"mov {0:h}, {0:l}\"" msgstr "\"mov {0:h}, {0:l}\"" #: src/unsafe/asm.md:389 msgid "" "In this example, we use the `reg_abcd` register class to restrict the " "register allocator to the 4 legacy x86 registers (`ax`, `bx`, `cx`, `dx`) of " "which the first two bytes can be addressed independently." msgstr "" "이 예제에서는 `reg_abcd` 레지스터 클래스를 사용하여 레지스터 할당자를 처음 " "두 바이트를 독립적으로 주소 지정할 수 있는 4개의 레거시 x86 레지스터(`ax`, " "`bx`, `cx`, `dx`)로 제한합니다." #: src/unsafe/asm.md:391 msgid "" "Let us assume that the register allocator has chosen to allocate `x` in the " "`ax` register. The `h` modifier will emit the register name for the high " "byte of that register and the `l` modifier will emit the register name for " "the low byte. The asm code will therefore be expanded as `mov ah, al` which " "copies the low byte of the value into the high byte." msgstr "" "레지스터 할당자가 `x`를 `ax` 레지스터에 할당하기로 선택했다고 가정해 봅시다. " "`h` 수정자는 해당 레지스터의 상위 바이트에 대한 레지스터 이름을 출력하고, " "`l` 수정자는 하위 바이트에 대한 레지스터 이름을 출력합니다. 따라서 어셈블리 " "코드는 `mov ah, al`로 확장되어 값의 하위 바이트를 상위 바이트로 복사합니다." #: src/unsafe/asm.md:394 msgid "" "If you use a smaller data type (e.g. `u16`) with an operand and forget to " "use template modifiers, the compiler will emit a warning and suggest the " "correct modifier to use." msgstr "" "피연산자와 함께 더 작은 데이터 타입(예: `u16`)을 사용하면서 템플릿 수정자를 " "사용하는 것을 잊은 경우, 컴파일러는 경고를 내보내고 사용할 올바른 수정자를 제" "안합니다." #: src/unsafe/asm.md:396 msgid "Memory address operands" msgstr "메모리 주소 피연산자" #: src/unsafe/asm.md:398 msgid "" "Sometimes assembly instructions require operands passed via memory addresses/" "memory locations. You have to manually use the memory address syntax " "specified by the target architecture. For example, on x86/x86_64 using Intel " "assembly syntax, you should wrap inputs/outputs in `[]` to indicate they are " "memory operands:" msgstr "" "때로는 어셈블리 명령어가 메모리 주소/메모리 위치를 통해 전달되는 피연산자를 " "요구합니다. 타겟 아키텍처에 지정된 메모리 주소 구문을 수동으로 사용해야 합니" "다. 예를 들어, Intel 어셈블리 구문을 사용하는 x86/x86_64에서는 입력/출력을 " "`[]`로 감싸서 메모리 피연산자임을 나타내야 합니다." #: src/unsafe/asm.md:408 msgid "\"fldcw [{}]\"" msgstr "\"fldcw [{}]\"" #: src/unsafe/asm.md:414 msgid "Labels" msgstr "레이블" #: src/unsafe/asm.md:416 msgid "" "Any reuse of a named label, local or otherwise, can result in an assembler " "or linker error or may cause other strange behavior. Reuse of a named label " "can happen in a variety of ways including:" msgstr "" "이름이 지정된 레이블(로컬이든 아니든)을 재사용하면 어셈블러나 링커 오류가 발" "생하거나 기타 이상한 동작이 발생할 수 있습니다. 이름이 지정된 레이블의 재사용" "은 다음과 같은 다양한 방식으로 발생할 수 있습니다." #: src/unsafe/asm.md:418 msgid "" "explicitly: using a label more than once in one `asm!` block, or multiple " "times across blocks." msgstr "" "명시적으로: 하나의 `asm!` 블록에서 레이블을 두 번 이상 사용하거나, 블록 간에 " "여러 번 사용하는 경우." #: src/unsafe/asm.md:419 msgid "" "implicitly via inlining: the compiler is allowed to instantiate multiple " "copies of an `asm!` block, for example when the function containing it is " "inlined in multiple places." msgstr "" "인라이닝을 통한 암시적 방식: 컴파일러는 `asm!` 블록의 여러 복사본을 인스턴스" "화할 수 있습니다. 예를 들어 해당 블록을 포함하는 함수가 여러 위치에서 인라이" "닝되는 경우가 이에 해당합니다." #: src/unsafe/asm.md:420 msgid "" "implicitly via LTO: LTO can cause code from _other crates_ to be placed in " "the same codegen unit, and so could bring in arbitrary labels." msgstr "" "LTO를 통한 암시적 방식: LTO는 _다른 크레이트_의 코드를 동일한 코드 생성 단위" "에 배치할 수 있으며, 이로 인해 임의의 레이블이 유입될 수 있습니다." #: src/unsafe/asm.md:422 msgid "" "As a consequence, you should only use GNU assembler **numeric** [local " "labels](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-" "Labels) inside inline assembly code. Defining symbols in assembly code may " "lead to assembler and/or linker errors due to duplicate symbol definitions." msgstr "" "결과적으로, 인라인 어셈블리 코드 내부에서는 GNU 어셈블러 **숫자** [로컬 레이" "블](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels)" "만 사용해야 합니다. 어셈블리 코드에서 심볼을 정의하면 심볼 중복 정의로 인해 " "어셈블러 및/또는 링커 오류가 발생할 수 있습니다." #: src/unsafe/asm.md:424 msgid "" "Moreover, on x86 when using the default Intel syntax, due to [an LLVM bug]" "(https://bugs.llvm.org/show_bug.cgi?id=36144), you shouldn't use labels " "exclusively made of `0` and `1` digits, e.g. `0`, `11` or `101010`, as they " "may end up being interpreted as binary values. Using `options(att_syntax)` " "will avoid any ambiguity, but that affects the syntax of the _entire_ `asm!` " "block. (See [Options](#options), below, for more on `options`.)" msgstr "" "또한 x86에서 기본 Intel 구문을 사용할 때, [LLVM 버그](https://bugs.llvm.org/" "show_bug.cgi?id=36144)로 인해 `0`, `11` 또는 `101010`과 같이 `0`과 `1` 숫자로" "만 구성된 레이블은 사용하지 말아야 합니다. 이는 바이너리 값으로 해석될 수 있" "기 때문입니다. `options(att_syntax)`를 사용하면 모호함을 피할 수 있지만, 이" "는 `asm!` 블록 _전체_의 구문에 영향을 미칩니다. (`options`에 대한 자세한 내용" "은 아래의 [옵션](#options) 섹션을 참조하세요.)" #: src/unsafe/asm.md:433 msgid "\"mov {0}, 10\"" msgstr "\"mov {0}, 10\"" #: src/unsafe/asm.md:434 src/unsafe/asm.md:439 msgid "\"2:\"" msgstr "\"2:\"" #: src/unsafe/asm.md:435 msgid "\"sub {0}, 1\"" msgstr "\"sub {0}, 1\"" #: src/unsafe/asm.md:436 msgid "\"cmp {0}, 3\"" msgstr "\"cmp {0}, 3\"" #: src/unsafe/asm.md:437 msgid "\"jle 2f\"" msgstr "\"jle 2f\"" #: src/unsafe/asm.md:438 msgid "\"jmp 2b\"" msgstr "\"jmp 2b\"" #: src/unsafe/asm.md:440 msgid "\"add {0}, 2\"" msgstr "\"add {0}, 2\"" #: src/unsafe/asm.md:448 msgid "" "This will decrement the `{0}` register value from 10 to 3, then add 2 and " "store it in `a`." msgstr "" "이 코드는 `{0}` 레지스터 값을 10에서 3으로 감소시킨 다음, 2를 더하고 그 결과" "를 `a`에 저장합니다." #: src/unsafe/asm.md:450 msgid "This example shows a few things:" msgstr "이 예제는 몇 가지를 보여줍니다:" #: src/unsafe/asm.md:452 msgid "" "First, that the same number can be used as a label multiple times in the " "same inline block." msgstr "" "첫째, 동일한 숫자를 하나의 인라인 블록 내에서 레이블로 여러 번 사용할 수 있습" "니다." #: src/unsafe/asm.md:453 msgid "" "Second, that when a numeric label is used as a reference (as an instruction " "operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) " "should be added to the numeric label. It will then refer to the nearest " "label defined by this number in this direction." msgstr "" "둘째, 숫자 레이블이 참조(예: 명령어 피연산자)로 사용될 때는 숫자 레이블에 접" "미사 “b” (“backward”, 뒤로) 또는 ”f” (“forward”, 앞으로)를 추가해야 합니다. " "그러면 해당 방향에서 이 숫자로 정의된 가장 가까운 레이블을 참조하게 됩니다." #: src/unsafe/asm.md:458 msgid "Options" msgstr "옵션" #: src/unsafe/asm.md:460 msgid "" "By default, an inline assembly block is treated the same way as an external " "FFI function call with a custom calling convention: it may read/write " "memory, have observable side effects, etc. However, in many cases it is " "desirable to give the compiler more information about what the assembly code " "is actually doing so that it can optimize better." msgstr "" "기본적으로 인라인 어셈블리 블록은 커스텀 호출 규약을 사용하는 외부 FFI 함수 " "호출과 동일하게 취급됩니다. 즉, 메모리를 읽거나 쓰고, 관찰 가능한 부수 효과" "가 있을 수 있다고 가정합니다. 하지만 많은 경우 컴파일러가 더 나은 최적화를 수" "행할 수 있도록 어셈블리 코드가 실제로 무엇을 하는지에 대한 더 많은 정보를 제" "공하는 것이 바람직합니다." #: src/unsafe/asm.md:462 msgid "Let's take our previous example of an `add` instruction:" msgstr "이전의 `add` 명령어 예제를 다시 살펴봅시다:" #: src/unsafe/asm.md:481 msgid "" "Options can be provided as an optional final argument to the `asm!` macro. " "We specified three options here:" msgstr "" "옵션은 `asm!` 매크로의 선택적인 마지막 인자로 제공될 수 있습니다. 여기서는 " "세 가지 옵션을 지정했습니다:" #: src/unsafe/asm.md:483 msgid "" "`pure` means that the asm code has no observable side effects and that its " "output depends only on its inputs. This allows the compiler optimizer to " "call the inline asm fewer times or even eliminate it entirely." msgstr "" "`pure`는 어셈블리 코드가 관찰 가능한 부수 효과가 없으며 출력이 입력에만 의존" "함을 의미합니다. 이를 통해 컴파일러 최적화 프로그램은 인라인 어셈블리를 더 적" "게 호출하거나 아예 제거할 수 있습니다." #: src/unsafe/asm.md:484 msgid "" "`nomem` means that the asm code does not read or write to memory. By default " "the compiler will assume that inline assembly can read or write any memory " "address that is accessible to it (e.g. through a pointer passed as an " "operand, or a global)." msgstr "" "`nomem`은 어셈블리 코드가 메모리를 읽거나 쓰지 않음을 의미합니다. 기본적으로 " "컴파일러는 인라인 어셈블리가 접근 가능한 모든 메모리 주소(예: 피연산자로 전달" "된 포인터나 전역 변수를 통해)를 읽거나 쓸 수 있다고 가정합니다." #: src/unsafe/asm.md:485 msgid "" "`nostack` means that the asm code does not push any data onto the stack. " "This allows the compiler to use optimizations such as the stack red zone on " "x86-64 to avoid stack pointer adjustments." msgstr "" "`nostack`은 어셈블리 코드가 스택에 어떤 데이터도 푸시하지 않음을 의미합니다. " "이를 통해 컴파일러는 x86-64의 스택 레드 존(stack red zone)과 같은 최적화를 사" "용하여 스택 포인터 조정을 피할 수 있습니다." #: src/unsafe/asm.md:487 msgid "" "These allow the compiler to better optimize code using `asm!`, for example " "by eliminating pure `asm!` blocks whose outputs are not needed." msgstr "" "이러한 옵션들은 컴파일러가 `asm!`을 사용하는 코드를 더 잘 최적화할 수 있게 해" "줍니다. 예를 들어 출력이 필요하지 않은 순수(pure) `asm!` 블록을 제거할 수 있" "습니다." #: src/unsafe/asm.md:489 msgid "" "See the [reference](https://doc.rust-lang.org/stable/reference/inline-" "assembly.html) for the full list of available options and their effects." msgstr "" "사용 가능한 전체 옵션 목록과 그 효과에 대해서는 [레퍼런스](https://doc.rust-" "lang.org/stable/reference/inline-assembly.html)를 참조하세요." #: src/compatibility.md:3 msgid "" "The Rust language is evolving rapidly, and because of this certain " "compatibility issues can arise, despite efforts to ensure forwards-" "compatibility wherever possible." msgstr "" "Rust 언어는 빠르게 진화하고 있으며, 이로 인해 가능한 한 전방 호환성을 보장하" "려는 노력에도 불구하고 특정 호환성 문제가 발생할 수 있습니다." #: src/compatibility.md:7 msgid "[Raw identifiers](compatibility/raw_identifiers.md)" msgstr "[Raw 식별자](compatibility/raw_identifiers.md)" #: src/compatibility/raw_identifiers.md:3 msgid "" "Rust, like many programming languages, has the concept of \"keywords\". " "These identifiers mean something to the language, and so you cannot use them " "in places like variable names, function names, and other places. Raw " "identifiers let you use keywords where they would not normally be allowed. " "This is particularly useful when Rust introduces new keywords, and a library " "using an older edition of Rust has a variable or function with the same name " "as a keyword introduced in a newer edition." msgstr "" "Rust는 많은 프로그래밍 언어와 마찬가지로 \"키워드\"라는 개념이 있습니다. 이러" "한 식별자들은 언어에 의미가 있으므로 변수 이름, 함수 이름 등에서 사용할 수 없" "습니다. Raw 식별자를 사용하면 일반적으로 허용되지 않는 위치에서 키워드를 사용" "할 수 있습니다. 이는 특히 Rust가 새로운 키워드를 도입하고, 이전 에디션의 Rust" "를 사용하는 라이브러리에 최신 에디션에서 도입된 키워드와 동일한 이름의 변수" "나 함수가 있을 때 유용합니다." #: src/compatibility/raw_identifiers.md:11 msgid "" "For example, consider a crate `foo` compiled with the 2015 edition of Rust " "that exports a function named `try`. This keyword is reserved for a new " "feature in the 2018 edition, so without raw identifiers, we would have no " "way to name the function." msgstr "" "예를 들어, 2015 에디션 Rust로 컴파일된 `foo` 크레이트가 `try`라는 이름의 함수" "를 내보낸다고 가정해 봅시다. 이 키워드는 2018 에디션의 새로운 기능을 위해 예" "약되어 있으므로, Raw 식별자가 없다면 함수 이름을 지을 방법이 없을 것입니다." #: src/compatibility/raw_identifiers.md:24 msgid "You'll get this error:" msgstr "다음과 같은 오류가 발생합니다:" #: src/compatibility/raw_identifiers.md:34 msgid "You can write this with a raw identifier:" msgstr "Raw 식별자를 사용하여 다음과 같이 작성할 수 있습니다:" #: src/meta.md:3 msgid "" "Some topics aren't exactly relevant to how you program runs but provide you " "tooling or infrastructure support which just makes things better for " "everyone. These topics include:" msgstr "" "일부 주제는 프로그램의 실행 방식과 직접적인 관련은 없지만, 모든 사람에게 도움" "이 되는 도구 또는 인프라 지원을 제공합니다. 이러한 주제는 다음과 같습니다." #: src/meta.md:7 msgid "" "[Documentation](meta/doc.md): Generate library documentation for users via " "the included `rustdoc`." msgstr "" "[문서화](meta/doc.md): 포함된 `rustdoc`을 통해 사용자를 위한 라이브러리 문서" "를 생성합니다." #: src/meta.md:9 msgid "" "[Playground](meta/playground.md): Integrate the Rust Playground in your " "documentation." msgstr "" "[플레이그라운드](meta/playground.md): 문서에 Rust 플레이그라운드를 통합합니" "다." #: src/meta/doc.md:3 msgid "" "Use `cargo doc` to build documentation in `target/doc`, `cargo doc --open` " "will automatically open it in your web browser." msgstr "" "`target/doc`에 문서를 빌드하려면 `cargo doc`을 사용하세요. `cargo doc --open`" "은 웹 브라우저에서 문서를 자동으로 엽니다." #: src/meta/doc.md:6 msgid "" "Use `cargo test` to run all tests (including documentation tests), and " "`cargo test --doc` to only run documentation tests." msgstr "" "모든 테스트(문서 테스트 포함)를 실행하려면 `cargo test`를, 문서 테스트만 실행" "하려면 `cargo test --doc`을 사용하세요." #: src/meta/doc.md:9 msgid "" "These commands will appropriately invoke `rustdoc` (and `rustc`) as required." msgstr "" "이러한 명령어들은 필요에 따라 `rustdoc`(및 `rustc`)을 적절히 호출합니다." #: src/meta/doc.md:11 msgid "Doc comments" msgstr "문서 주석" #: src/meta/doc.md:13 msgid "" "Doc comments are very useful for big projects that require documentation. " "When running `rustdoc`, these are the comments that get compiled into " "documentation. They are denoted by a `///`, and support [Markdown](https://" "en.wikipedia.org/wiki/Markdown)." msgstr "" "문서 주석은 문서화가 필요한 큰 프로젝트에 매우 유용합니다. `rustdoc`을 실행" "할 때, 이 주석들이 문서로 컴파일됩니다. 이들은 `///`로 표시되며 [Markdown]" "(https://en.wikipedia.org/wiki/Markdown)을 지원합니다." #: src/meta/doc.md:18 msgid "\"doc\"" msgstr "\"doc\"" #: src/meta/doc.md:19 msgid "/// A human being is represented here\n" msgstr "/// 여기에 사람(human being)이 표현됩니다.\n" #: src/meta/doc.md:22 msgid "/// A person must have a name, no matter how much Juliet may hate it\n" msgstr "/// 줄리엣이 아무리 싫어하더라도 사람은 이름을 가져야 합니다.\n" #: src/meta/doc.md:27 msgid "" "/// Creates a person with the given name.\n" " ///\n" " /// # Examples\n" " ///\n" " /// ```\n" " /// // You can have rust code between fences inside the comments\n" " /// // If you pass --test to `rustdoc`, it will even test it for you!\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" msgstr "" "/// 주어진 이름으로 사람을 생성합니다.\n" " ///\n" " /// # Examples\n" " ///\n" " /// ```\n" " /// // 주석 내부의 울타리(fence) 사이에 Rust 코드를 넣을 수 있습니다.\n" " /// // `rustdoc`에 --test를 전달하면, 코드 테스트까지 해줍니다!\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" #: src/meta/doc.md:43 msgid "" "/// Gives a friendly hello!\n" " ///\n" " /// Says \"Hello, [name](Person::name)\" to the `Person` it is called " "on.\n" msgstr "" "/// 친절하게 인사합니다!\n" " ///\n" " /// 호출된 `Person`의 이름을 사용하여 \"안녕, [name](Person::name)\"이라" "고 말합니다.\n" #: src/meta/doc.md:47 msgid "\"Hello, {}!\"" msgstr "\"안녕, {}!\"" #: src/meta/doc.md:52 msgid "\"John\"" msgstr "\"존\"" #: src/meta/doc.md:58 msgid "" "To run the tests, first build the code as a library, then tell `rustdoc` " "where to find the library so it can link it into each doctest program:" msgstr "" "테스트를 실행하려면 먼저 코드를 라이브러리로 빌드한 다음, `rustdoc`이 각 문" "서 테스트 프로그램에 링크할 수 있도록 라이브러리 위치를 알려주어야 합니다." #: src/meta/doc.md:61 msgid "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" msgstr "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" #: src/meta/doc.md:66 msgid "Doc attributes" msgstr "문서 속성" #: src/meta/doc.md:68 msgid "" "Below are a few examples of the most common `#[doc]` attributes used with " "`rustdoc`." msgstr "" "다음은 `rustdoc`과 함께 사용되는 가장 일반적인 `#[doc]` 속성의 몇 가지 예입니" "다." #: src/meta/doc.md:71 msgid "`inline`" msgstr "`inline`" #: src/meta/doc.md:73 msgid "Used to inline docs, instead of linking out to separate page." msgstr "" "별도의 페이지로 링크하는 대신 문서를 인라인으로 표시하는 데 사용됩니다." #: src/meta/doc.md:78 msgid "/// bar docs\n" msgstr "/// bar 문서\n" #: src/meta/doc.md:81 msgid "/// the docs for Bar\n" msgstr "/// Bar에 대한 문서\n" #: src/meta/doc.md:86 msgid "`no_inline`" msgstr "`no_inline`" #: src/meta/doc.md:88 msgid "Used to prevent linking out to separate page or anywhere." msgstr "별도의 페이지나 다른 곳으로 링크되는 것을 방지하는 데 사용됩니다." #: src/meta/doc.md:91 msgid "// Example from libcore/prelude\n" msgstr "// libcore/prelude에서 가져온 예시\n" #: src/meta/doc.md:96 msgid "`hidden`" msgstr "`hidden`" #: src/meta/doc.md:98 msgid "Using this tells `rustdoc` not to include this in documentation:" msgstr "이를 사용하면 `rustdoc`이 해당 항목을 문서에 포함하지 않도록 합니다." #: src/meta/doc.md:101 msgid "// Example from the futures-rs library\n" msgstr "// futures-rs 라이브러리에서 가져온 예시\n" #: src/meta/doc.md:106 msgid "" "For documentation, `rustdoc` is widely used by the community. It's what is " "used to generate the [std library docs](https://doc.rust-lang.org/std/)." msgstr "" "문서화를 위해 커뮤니티에서는 `rustdoc`이 널리 사용됩니다. [표준 라이브러리 문" "서](https://doc.rust-lang.org/std/)를 생성하는 데 사용되는 도구이기도 합니다." #: src/meta/doc.md:111 msgid "" "[The Rust Book: Making Useful Documentation Comments](https://doc.rust-" "lang.org/book/ch14-02-publishing-to-crates-io.html#making-useful-" "documentation-comments)" msgstr "" "[The Rust Book: 유용한 문서 주석 만들기](https://doc.rust-lang.org/book/" "ch14-02-publishing-to-crates-io.html#making-useful-documentation-comments)" #: src/meta/doc.md:112 msgid "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/index.html)" msgstr "[rustdoc 책](https://doc.rust-lang.org/rustdoc/index.html)" #: src/meta/doc.md:113 msgid "" "[The Reference: Doc comments](https://doc.rust-lang.org/stable/reference/" "comments.html#doc-comments)" msgstr "" "[The Reference: 문서 주석](https://doc.rust-lang.org/stable/reference/" "comments.html#doc-comments)" #: src/meta/doc.md:114 msgid "" "[RFC 1574: API Documentation Conventions](https://rust-lang.github.io/rfcs/" "1574-more-api-documentation-conventions.html#appendix-a-full-conventions-" "text)" msgstr "" "[RFC 1574: API 문서 관례](https://rust-lang.github.io/rfcs/1574-more-api-" "documentation-conventions.html#appendix-a-full-conventions-text)" #: src/meta/doc.md:115 msgid "" "[RFC 1946: Relative links to other items from doc comments (intra-rustdoc " "links)](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)" msgstr "" "[RFC 1946: 문서 주석에서 다른 아이템으로의 상대 링크 (intra-rustdoc links)]" "(https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)" #: src/meta/doc.md:116 msgid "" "[Is there any documentation style guide for comments? (reddit)](https://" "www.reddit.com/r/rust/comments/ahb50s/" "is_there_any_documentation_style_guide_for/)" msgstr "" "[주석에 대한 문서화 스타일 가이드가 있나요? (reddit)](https://www.reddit.com/" "r/rust/comments/ahb50s/is_there_any_documentation_style_guide_for/)" #: src/meta/playground.md:3 msgid "" "The [Rust Playground](https://play.rust-lang.org/) is a way to experiment " "with Rust code through a web interface." msgstr "" "[Rust 플레이그라운드](https://play.rust-lang.org/)는 웹 인터페이스를 통해 " "Rust 코드를 실험해 볼 수 있는 방법입니다." #: src/meta/playground.md:6 msgid "Using it with `mdbook`" msgstr "`mdbook`에서 사용하기" #: src/meta/playground.md:8 msgid "" "In [`mdbook`](https://github.com/rust-lang/mdBook), you can make code " "examples playable and editable." msgstr "" "[`mdbook`](https://github.com/rust-lang/mdBook)에서는 코드 예제를 실행 가능하" "고 수정 가능하게 만들 수 있습니다." #: src/meta/playground.md:16 msgid "" "This allows the reader to both run your code sample, but also modify and " "tweak it. The key here is the adding of the word `editable` to your " "codefence block separated by a comma." msgstr "" "이를 통해 독자는 코드 샘플을 실행할 뿐만 아니라 수정하고 조정해 볼 수도 있습" "니다. 여기서 핵심은 코드 펜스(codefence) 블록에 콤마로 구분하여 `editable`이" "라는 단어를 추가하는 것입니다." #: src/meta/playground.md:26 msgid "" "Additionally, you can add `ignore` if you want `mdbook` to skip your code " "when it builds and tests." msgstr "빌드 및 테스트 시에." #: src/meta/playground.md:35 msgid "Using it with docs" msgstr "문서에서 사용하기" #: src/meta/playground.md:37 msgid "" "You may have noticed in some of the [official Rust docs](https://doc.rust-" "lang.org/core/) a button that says \"Run\", which opens the code sample up " "in a new tab in Rust Playground. This feature is enabled if you use the " "`#[doc]` attribute called [`html_playground_url`](https://doc.rust-lang.org/" "rustdoc/write-documentation/the-doc-attribute.html#html_playground_url)." msgstr "" "[공식 Rust 문서](https://doc.rust-lang.org/core/) 중 일부에서 \"Run\"이라고 " "적힌 버튼을 본 적이 있을 것입니다. 이 버튼을 누르면 Rust 플레이그라운드의 새 " "탭에서 코드 샘플이 열립니다. 이 기능은 [`html_playground_url`](https://" "doc.rust-lang.org/rustdoc/write-documentation/the-doc-" "attribute.html#html_playground_url)이라는 `#[doc]` 속성을 사용하면 활성화됩니" "다." #: src/meta/playground.md:42 msgid "" "````text\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" msgstr "" "````text\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" #: src/meta/playground.md:51 msgid "[The Rust Playground](https://play.rust-lang.org/)" msgstr "[Rust 플레이그라운드](https://play.rust-lang.org/)" #: src/meta/playground.md:52 msgid "" "[The Rust Playground On Github](https://github.com/integer32llc/rust-" "playground/)" msgstr "" "[GitHub의 Rust 플레이그라운드](https://github.com/integer32llc/rust-" "playground/)" #: src/meta/playground.md:53 msgid "" "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)" msgstr "" "[rustdoc 책](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)" #~ msgid "" #~ "While the former enables conditional compilation, the latter " #~ "conditionally evaluates to `true` or `false` literals, allowing for " #~ "checks at run-time. Both utilize identical argument syntax." #~ msgstr "" #~ "전자는 조건부 컴파일을 가능하게 하는 반면, 후자는 조건부로 `true` 또는 " #~ "`false` 리터럴로 평가되어 런타임에 검사를 가능하게 합니다. 둘 다 동일한 인" #~ "자 문법을 사용합니다." #~ msgid "// Compile-time Error! Type mismatch so these cannot be compared:\n" #~ msgstr "// 컴파일 타임 에러! 타입 불일치로 인해 비교할 수 없습니다:\n" #~ msgid "" #~ "// This function takes ownership of the heap allocated memory from `b`\n" #~ " //destroy_box(b);\n" #~ msgstr "// 이 함수는 `b`로부터 힙 할당 메모리의 소유권을 가져갑니다\n" ================================================ FILE: po/zh.po ================================================ msgid "" msgstr "" "Project-Id-Version: Rust By Example\n" "POT-Creation-Date: 2025-08-08T08:55:44+08:00\n" "PO-Revision-Date: 2024-08-17 22:13+0800\n" "Last-Translator: Binlogo \n" "Language-Team: Chinese\n" "Language: zh\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" #: src/SUMMARY.md:1 msgid "Summary" msgstr "Summary" #: src/SUMMARY.md:3 msgid "Introduction" msgstr "介绍" #: src/SUMMARY.md:5 src/hello.md:1 msgid "Hello World" msgstr "Hello World" #: src/SUMMARY.md:6 src/hello/comment.md:1 msgid "Comments" msgstr "注释" #: src/SUMMARY.md:7 src/hello/print.md:1 msgid "Formatted print" msgstr "格式化打印" #: src/SUMMARY.md:8 src/hello/print/print_debug.md:1 msgid "Debug" msgstr "调试 Debug" #: src/SUMMARY.md:9 src/hello/print/print_display.md:1 msgid "Display" msgstr "显示 Display" #: src/SUMMARY.md:10 src/hello/print/print_display/testcase_list.md:1 msgid "Testcase: List" msgstr "测试实例：列表" #: src/SUMMARY.md:11 src/hello/print/fmt.md:1 msgid "Formatting" msgstr "格式化" #: src/SUMMARY.md:13 src/primitives.md:1 msgid "Primitives" msgstr "原生类型" #: src/SUMMARY.md:14 src/primitives/literals.md:1 msgid "Literals and operators" msgstr "字面量和运算符" #: src/SUMMARY.md:15 src/primitives/tuples.md:1 msgid "Tuples" msgstr "元组" #: src/SUMMARY.md:16 src/primitives/array.md:1 msgid "Arrays and Slices" msgstr "数组和切片" #: src/SUMMARY.md:18 src/custom_types.md:1 msgid "Custom Types" msgstr "自定义类型" #: src/SUMMARY.md:19 src/custom_types/structs.md:1 msgid "Structures" msgstr "结构体" #: src/SUMMARY.md:20 src/custom_types/enum.md:1 msgid "Enums" msgstr "枚举" #: src/SUMMARY.md:21 src/custom_types/enum/enum_use.md:1 msgid "use" msgstr "use" #: src/SUMMARY.md:22 src/custom_types/enum/c_like.md:1 msgid "C-like" msgstr "C 风格用法" #: src/SUMMARY.md:23 src/custom_types/enum/testcase_linked_list.md:1 msgid "Testcase: linked-list" msgstr "测试实例：链表" #: src/SUMMARY.md:24 src/custom_types/constants.md:1 msgid "constants" msgstr "常量" #: src/SUMMARY.md:26 src/variable_bindings.md:1 msgid "Variable Bindings" msgstr "变量绑定" #: src/SUMMARY.md:27 src/SUMMARY.md:120 src/SUMMARY.md:123 #: src/variable_bindings/mut.md:1 src/scope/move/mut.md:1 #: src/scope/borrow/mut.md:1 msgid "Mutability" msgstr "可变性" #: src/SUMMARY.md:28 src/variable_bindings/scope.md:1 msgid "Scope and Shadowing" msgstr "作用域和遮蔽" #: src/SUMMARY.md:29 src/variable_bindings/declare.md:1 msgid "Declare first" msgstr "先声明" #: src/SUMMARY.md:30 src/variable_bindings/freeze.md:1 msgid "Freezing" msgstr "冻结" #: src/SUMMARY.md:32 src/types.md:1 msgid "Types" msgstr "类型" #: src/SUMMARY.md:33 src/types/cast.md:1 msgid "Casting" msgstr "类型转换" #: src/SUMMARY.md:34 src/types/literals.md:1 msgid "Literals" msgstr "字面量" #: src/SUMMARY.md:35 src/types/inference.md:1 msgid "Inference" msgstr "类型推断" #: src/SUMMARY.md:36 src/SUMMARY.md:124 src/types/alias.md:1 #: src/scope/borrow/alias.md:1 msgid "Aliasing" msgstr "别名" #: src/SUMMARY.md:38 src/conversion.md:1 msgid "Conversion" msgstr "转换" #: src/SUMMARY.md:39 src/conversion/from_into.md:1 msgid "`From` and `Into`" msgstr "`From` 和 `Into`" #: src/SUMMARY.md:40 src/conversion/try_from_try_into.md:1 msgid "`TryFrom` and `TryInto`" msgstr "`TryFrom` 和 `TryInto`" #: src/SUMMARY.md:41 msgid "To and from `String`s" msgstr "`String` 类型转换" #: src/SUMMARY.md:43 src/expression.md:1 msgid "Expressions" msgstr "表达式" #: src/SUMMARY.md:45 src/flow_control.md:1 msgid "Flow of Control" msgstr "控制流" #: src/SUMMARY.md:46 src/flow_control/if_else.md:1 msgid "if/else" msgstr "if/else" #: src/SUMMARY.md:47 src/flow_control/loop.md:1 msgid "loop" msgstr "loop" #: src/SUMMARY.md:48 src/flow_control/loop/nested.md:1 msgid "Nesting and labels" msgstr "嵌套和标签" #: src/SUMMARY.md:49 src/flow_control/loop/return.md:1 msgid "Returning from loops" msgstr "在 loop 中返回值" #: src/SUMMARY.md:50 src/flow_control/while.md:1 msgid "while" msgstr "while" #: src/SUMMARY.md:51 src/flow_control/for.md:3 msgid "for and range" msgstr "for 和 range" #: src/SUMMARY.md:52 src/flow_control/match.md:1 msgid "match" msgstr "match" #: src/SUMMARY.md:53 src/flow_control/match/destructuring.md:1 msgid "Destructuring" msgstr "解构" #: src/SUMMARY.md:54 #: src/flow_control/match/destructuring/destructure_tuple.md:1 msgid "tuples" msgstr "元组" #: src/SUMMARY.md:55 #: src/flow_control/match/destructuring/destructure_slice.md:1 msgid "arrays/slices" msgstr "数组/切片" #: src/SUMMARY.md:56 src/flow_control/match/destructuring/destructure_enum.md:1 msgid "enums" msgstr "枚举" #: src/SUMMARY.md:57 #: src/flow_control/match/destructuring/destructure_pointers.md:1 msgid "pointers/ref" msgstr "指针/引用" #: src/SUMMARY.md:58 #: src/flow_control/match/destructuring/destructure_structures.md:1 msgid "structs" msgstr "结构体" #: src/SUMMARY.md:59 src/flow_control/match/guard.md:1 msgid "Guards" msgstr "守卫" #: src/SUMMARY.md:60 src/flow_control/match/binding.md:1 msgid "Binding" msgstr "绑定" #: src/SUMMARY.md:61 src/flow_control/if_let.md:1 msgid "if let" msgstr "if let" #: src/SUMMARY.md:62 src/flow_control/let_else.md:1 msgid "let-else" msgstr "let-else" #: src/SUMMARY.md:63 src/flow_control/while_let.md:1 msgid "while let" msgstr "while let" #: src/SUMMARY.md:65 src/SUMMARY.md:103 src/SUMMARY.md:128 src/fn.md:1 #: src/generics/gen_fn.md:1 src/scope/lifetime/fn.md:1 msgid "Functions" msgstr "函数" #: src/SUMMARY.md:66 src/SUMMARY.md:129 src/scope/lifetime/methods.md:1 msgid "Methods" msgstr "方法" #: src/SUMMARY.md:67 src/fn/closures.md:1 msgid "Closures" msgstr "闭包" #: src/SUMMARY.md:68 src/fn/closures/capture.md:1 msgid "Capturing" msgstr "捕获" #: src/SUMMARY.md:69 src/fn/closures/input_parameters.md:1 msgid "As input parameters" msgstr "作为输入参数" #: src/SUMMARY.md:70 src/fn/closures/anonymity.md:1 msgid "Type anonymity" msgstr "类型匿名" #: src/SUMMARY.md:71 src/fn/closures/input_functions.md:1 msgid "Input functions" msgstr "输入函数" #: src/SUMMARY.md:72 src/fn/closures/output_parameters.md:1 msgid "As output parameters" msgstr "作为输出参数" #: src/SUMMARY.md:73 src/fn/closures/closure_examples.md:1 msgid "Examples in `std`" msgstr "`std` 中的例子" #: src/SUMMARY.md:74 src/fn/closures/closure_examples/iter_any.md:1 msgid "Iterator::any" msgstr "Iterator::any" #: src/SUMMARY.md:75 src/fn/closures/closure_examples/iter_find.md:1 msgid "Searching through iterators" msgstr "通过迭代器搜索" #: src/SUMMARY.md:76 src/fn/hof.md:1 msgid "Higher Order Functions" msgstr "高阶函数" #: src/SUMMARY.md:77 src/fn/diverging.md:1 msgid "Diverging functions" msgstr "发散函数" #: src/SUMMARY.md:79 src/mod.md:1 msgid "Modules" msgstr "模块" #: src/SUMMARY.md:80 src/mod/visibility.md:1 msgid "Visibility" msgstr "可见性" #: src/SUMMARY.md:81 src/mod/struct_visibility.md:1 msgid "Struct visibility" msgstr "结构体可见性" #: src/SUMMARY.md:82 src/mod/use.md:1 msgid "The `use` declaration" msgstr "`use` 声明" #: src/SUMMARY.md:83 src/mod/super.md:1 msgid "`super` and `self`" msgstr "`super` 和 `self`" #: src/SUMMARY.md:84 src/mod/split.md:1 msgid "File hierarchy" msgstr "文件分层" #: src/SUMMARY.md:86 src/SUMMARY.md:98 src/crates.md:1 src/attribute/crate.md:1 #: src/std_misc/arg.md:30 msgid "Crates" msgstr "Crates" #: src/SUMMARY.md:87 src/crates/lib.md:1 msgid "Creating a Library" msgstr "创建库" #: src/SUMMARY.md:88 src/crates/using_lib.md:1 msgid "Using a Library" msgstr "使用库" #: src/SUMMARY.md:90 src/cargo.md:1 msgid "Cargo" msgstr "Cargo" #: src/SUMMARY.md:91 src/cargo/deps.md:1 msgid "Dependencies" msgstr "依赖" #: src/SUMMARY.md:92 src/cargo/conventions.md:1 msgid "Conventions" msgstr "约定" #: src/SUMMARY.md:93 msgid "Tests" msgstr "测试" #: src/SUMMARY.md:94 src/cargo/build_scripts.md:1 msgid "Build Scripts" msgstr "构建脚本" #: src/SUMMARY.md:96 src/attribute.md:1 msgid "Attributes" msgstr "属性" #: src/SUMMARY.md:97 src/attribute/unused.md:1 msgid "`dead_code`" msgstr "`dead_code`" #: src/SUMMARY.md:99 src/attribute/cfg.md:1 msgid "`cfg`" msgstr "`cfg`" #: src/SUMMARY.md:100 src/attribute/cfg/custom.md:1 msgid "Custom" msgstr "自定义" #: src/SUMMARY.md:102 src/generics.md:1 msgid "Generics" msgstr "泛型" #: src/SUMMARY.md:104 src/generics/impl.md:1 msgid "Implementation" msgstr "实现" #: src/SUMMARY.md:105 src/SUMMARY.md:131 src/SUMMARY.md:137 #: src/generics/gen_trait.md:1 src/scope/lifetime/trait.md:1 src/trait.md:1 msgid "Traits" msgstr "特质" #: src/SUMMARY.md:106 src/SUMMARY.md:132 src/generics/bounds.md:1 #: src/scope/lifetime/lifetime_bounds.md:1 msgid "Bounds" msgstr "约束" #: src/SUMMARY.md:107 src/generics/bounds/testcase_empty.md:1 msgid "Testcase: empty bounds" msgstr "测试实例：空约束" #: src/SUMMARY.md:108 src/generics/multi_bounds.md:1 msgid "Multiple bounds" msgstr "多重约束" #: src/SUMMARY.md:109 src/generics/where.md:1 msgid "Where clauses" msgstr "Where 分句" #: src/SUMMARY.md:110 src/generics/new_types.md:1 msgid "New Type Idiom" msgstr "新类型惯用法" #: src/SUMMARY.md:111 src/generics/assoc_items.md:1 msgid "Associated items" msgstr "关联项" #: src/SUMMARY.md:112 src/generics/assoc_items/the_problem.md:1 msgid "The Problem" msgstr "问题" #: src/SUMMARY.md:113 src/generics/assoc_items/types.md:1 msgid "Associated types" msgstr "关联类型" #: src/SUMMARY.md:114 src/generics/phantom.md:1 msgid "Phantom type parameters" msgstr "虚类型参数" #: src/SUMMARY.md:115 src/generics/phantom/testcase_units.md:1 msgid "Testcase: unit clarification" msgstr "测试实例：单位澄清" #: src/SUMMARY.md:117 src/scope.md:1 msgid "Scoping rules" msgstr "作用域规则" #: src/SUMMARY.md:118 src/scope/raii.md:1 msgid "RAII" msgstr "RAII" #: src/SUMMARY.md:119 src/scope/move.md:1 msgid "Ownership and moves" msgstr "所有权和移动" #: src/SUMMARY.md:121 src/scope/move/partial_move.md:1 msgid "Partial moves" msgstr "部分移动" #: src/SUMMARY.md:122 src/scope/borrow.md:1 msgid "Borrowing" msgstr "借用" #: src/SUMMARY.md:125 src/scope/borrow/ref.md:1 msgid "The ref pattern" msgstr "ref 模式" #: src/SUMMARY.md:126 src/scope/lifetime.md:1 msgid "Lifetimes" msgstr "生命周期" #: src/SUMMARY.md:127 src/scope/lifetime/explicit.md:1 msgid "Explicit annotation" msgstr "显式注解" #: src/SUMMARY.md:130 src/scope/lifetime/struct.md:1 msgid "Structs" msgstr "结构体" #: src/SUMMARY.md:133 src/scope/lifetime/lifetime_coercion.md:1 msgid "Coercion" msgstr "强制转换" #: src/SUMMARY.md:134 src/scope/lifetime/static_lifetime.md:1 msgid "Static" msgstr "静态" #: src/SUMMARY.md:135 src/scope/lifetime/elision.md:1 msgid "Elision" msgstr "省略" #: src/SUMMARY.md:138 src/trait/derive.md:1 msgid "Derive" msgstr "派生" #: src/SUMMARY.md:139 src/trait/dyn.md:1 msgid "Returning Traits with `dyn`" msgstr "使用 `dyn` 返回 trait" #: src/SUMMARY.md:140 src/trait/ops.md:1 msgid "Operator Overloading" msgstr "运算符重载" #: src/SUMMARY.md:141 src/trait/drop.md:1 msgid "Drop" msgstr "Drop" #: src/SUMMARY.md:142 src/trait/iter.md:1 msgid "Iterators" msgstr "迭代器" #: src/SUMMARY.md:143 src/trait/impl_trait.md:1 msgid "`impl Trait`" msgstr "`impl Trait`" #: src/SUMMARY.md:144 src/trait/clone.md:1 msgid "Clone" msgstr "克隆" #: src/SUMMARY.md:145 src/trait/supertraits.md:1 msgid "Supertraits" msgstr "父特质" #: src/SUMMARY.md:146 src/trait/disambiguating.md:1 msgid "Disambiguating overlapping traits" msgstr "消除重叠特质的歧义" #: src/SUMMARY.md:148 msgid "macro_rules!" msgstr "macro_rules!" #: src/SUMMARY.md:149 src/macros/syntax.md:1 msgid "Syntax" msgstr "语法" #: src/SUMMARY.md:150 src/macros/designators.md:1 msgid "Designators" msgstr "指示符" #: src/SUMMARY.md:151 src/macros/overload.md:1 msgid "Overload" msgstr "重载" #: src/SUMMARY.md:152 src/macros/repeat.md:1 msgid "Repeat" msgstr "重复" #: src/SUMMARY.md:153 src/macros/dry.md:1 msgid "DRY (Don't Repeat Yourself)" msgstr "DRY(不要重复自己)" #: src/SUMMARY.md:154 msgid "DSL (Domain Specific Languages)" msgstr "DSL(领域特定语言)" #: src/SUMMARY.md:155 msgid "Variadics" msgstr "可变参数" #: src/SUMMARY.md:157 src/error.md:1 msgid "Error handling" msgstr "错误处理" #: src/SUMMARY.md:158 src/error/panic.md:1 msgid "`panic`" msgstr "`panic`" #: src/SUMMARY.md:159 msgid "`abort` & `unwind`" msgstr "`abort` 和 `unwind`" #: src/SUMMARY.md:160 src/error/option_unwrap.md:1 msgid "`Option` & `unwrap`" msgstr "`Option` 和 `unwrap`" #: src/SUMMARY.md:161 src/error/option_unwrap/question_mark.md:1 msgid "Unpacking options with `?`" msgstr "使用 `?` 解包 Option" #: src/SUMMARY.md:162 src/error/option_unwrap/map.md:1 msgid "Combinators: `map`" msgstr "组合器：`map`" #: src/SUMMARY.md:163 src/error/option_unwrap/and_then.md:1 msgid "Combinators: `and_then`" msgstr "组合器：`and_then`" #: src/SUMMARY.md:164 msgid "Defaults: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`" msgstr "默认值：`or`、`or_else`、`get_or_insert`、`get_or_insert_with`" #: src/SUMMARY.md:165 src/SUMMARY.md:183 src/error/result.md:1 #: src/std/result.md:1 msgid "`Result`" msgstr "`Result`" #: src/SUMMARY.md:166 src/error/result/result_map.md:1 msgid "`map` for `Result`" msgstr "`Result` 的 `map`" #: src/SUMMARY.md:167 src/error/result/result_alias.md:1 msgid "aliases for `Result`" msgstr "`Result` 的别名" #: src/SUMMARY.md:168 src/error/result/early_returns.md:1 msgid "Early returns" msgstr "提前返回" #: src/SUMMARY.md:169 src/error/result/enter_question_mark.md:1 msgid "Introducing `?`" msgstr "引入 `?`" #: src/SUMMARY.md:170 src/error/multiple_error_types.md:1 msgid "Multiple error types" msgstr "多种错误类型" #: src/SUMMARY.md:171 src/error/multiple_error_types/option_result.md:1 msgid "Pulling `Result`s out of `Option`s" msgstr "从 `Option` 中提取 `Result`" #: src/SUMMARY.md:172 src/error/multiple_error_types/define_error_type.md:1 msgid "Defining an error type" msgstr "定义错误类型" #: src/SUMMARY.md:173 src/error/multiple_error_types/boxing_errors.md:1 msgid "`Box`ing errors" msgstr "使用 `Box` 将错误装箱" #: src/SUMMARY.md:174 src/error/multiple_error_types/reenter_question_mark.md:1 msgid "Other uses of `?`" msgstr "`?` 的其他用途" #: src/SUMMARY.md:175 src/error/multiple_error_types/wrap_error.md:1 msgid "Wrapping errors" msgstr "包装错误" #: src/SUMMARY.md:176 src/error/iter_result.md:1 msgid "Iterating over `Result`s" msgstr "遍历 `Result`" #: src/SUMMARY.md:178 src/std.md:1 msgid "Std library types" msgstr "标准库类型" #: src/SUMMARY.md:179 src/std/box.md:1 msgid "Box, stack and heap" msgstr "Box、栈和堆" #: src/SUMMARY.md:180 src/std/vec.md:1 msgid "Vectors" msgstr "Vectors" #: src/SUMMARY.md:181 src/std/str.md:1 msgid "Strings" msgstr "字符串" #: src/SUMMARY.md:182 src/std/option.md:1 msgid "`Option`" msgstr "`Option`" #: src/SUMMARY.md:184 src/std/result/question_mark.md:1 msgid "`?`" msgstr "`?`" #: src/SUMMARY.md:185 src/std/panic.md:1 msgid "`panic!`" msgstr "`panic!`" #: src/SUMMARY.md:186 src/std/hash.md:1 msgid "HashMap" msgstr "HashMap" #: src/SUMMARY.md:187 src/std/hash/alt_key_types.md:1 msgid "Alternate/custom key types" msgstr "更改或自定义键类型" #: src/SUMMARY.md:188 src/std/hash/hashset.md:1 msgid "HashSet" msgstr "HashSet" #: src/SUMMARY.md:189 src/std/rc.md:1 msgid "`Rc`" msgstr "`Rc`" #: src/SUMMARY.md:190 msgid "`Arc`" msgstr "`Arc`" #: src/SUMMARY.md:192 src/std_misc.md:1 msgid "Std misc" msgstr "标准库中的其他内容" #: src/SUMMARY.md:193 src/std_misc.md:6 src/std_misc/threads.md:1 msgid "Threads" msgstr "线程" #: src/SUMMARY.md:194 src/std_misc/threads/testcase_mapreduce.md:1 msgid "Testcase: map-reduce" msgstr "测试实例：map-reduce" #: src/SUMMARY.md:195 src/std_misc.md:7 src/std_misc/channels.md:1 msgid "Channels" msgstr "信道" #: src/SUMMARY.md:196 src/std_misc/path.md:1 msgid "Path" msgstr "路径" #: src/SUMMARY.md:197 src/std_misc.md:8 src/std_misc/file.md:1 msgid "File I/O" msgstr "文件 I/O" #: src/SUMMARY.md:198 src/std_misc/file/open.md:1 msgid "`open`" msgstr "`open`" #: src/SUMMARY.md:199 src/std_misc/file/create.md:1 msgid "`create`" msgstr "`create`" #: src/SUMMARY.md:200 src/std_misc/file/read_lines.md:1 msgid "`read_lines`" msgstr "`read_lines`" #: src/SUMMARY.md:201 src/std_misc/process.md:1 msgid "Child processes" msgstr "子进程" #: src/SUMMARY.md:202 src/std_misc/process/pipe.md:1 msgid "Pipes" msgstr "管道" #: src/SUMMARY.md:203 src/std_misc/process/wait.md:1 msgid "Wait" msgstr "等待" #: src/SUMMARY.md:204 src/std_misc/fs.md:1 msgid "Filesystem Operations" msgstr "文件系统操作" #: src/SUMMARY.md:205 src/std_misc/arg.md:1 msgid "Program arguments" msgstr "程序参数" #: src/SUMMARY.md:206 src/std_misc/arg/matching.md:1 msgid "Argument parsing" msgstr "参数解析" #: src/SUMMARY.md:207 src/std_misc/ffi.md:1 msgid "Foreign Function Interface" msgstr "外部函数接口" #: src/SUMMARY.md:209 src/cargo/test.md:1 src/testing.md:1 msgid "Testing" msgstr "测试" #: src/SUMMARY.md:210 src/testing/unit_testing.md:1 msgid "Unit testing" msgstr "单元测试" #: src/SUMMARY.md:211 src/testing/doc_testing.md:1 msgid "Documentation testing" msgstr "文档测试" #: src/SUMMARY.md:212 src/testing/integration_testing.md:1 msgid "Integration testing" msgstr "集成测试" #: src/SUMMARY.md:213 msgid "Dev-dependencies" msgstr "开发依赖" #: src/SUMMARY.md:215 src/unsafe.md:1 msgid "Unsafe Operations" msgstr "不安全操作" #: src/SUMMARY.md:216 src/unsafe/asm.md:1 msgid "Inline assembly" msgstr "内联汇编" #: src/SUMMARY.md:218 src/compatibility.md:1 msgid "Compatibility" msgstr "兼容性" #: src/SUMMARY.md:219 src/compatibility/raw_identifiers.md:1 msgid "Raw identifiers" msgstr "原始标识符" #: src/SUMMARY.md:221 src/meta.md:1 msgid "Meta" msgstr "补充" #: src/SUMMARY.md:222 src/meta/doc.md:1 msgid "Documentation" msgstr "文档" #: src/SUMMARY.md:223 src/meta/playground.md:1 msgid "Playground" msgstr "Playground" #: src/index.md:1 msgid "Rust by Example" msgstr "Rust by Example" #: src/index.md:3 msgid "" "[Rust](https://www.rust-lang.org/) is a modern systems programming language " "focusing on safety, speed, and concurrency. It accomplishes these goals by " "being memory safe without using garbage collection." msgstr "" "[Rust](https://www.rust-lang.org/) 是一门现代系统编程语言，专注于安全性、速度" "和并发性。通过内存安全而不使用垃圾回收来实现这些目标。" #: src/index.md:7 msgid "" "Rust by Example (RBE) is a collection of runnable examples that illustrate " "various Rust concepts and standard libraries. To get even more out of these " "examples, don't forget to [install Rust locally](https://www.rust-lang.org/" "tools/install) and check out the [official docs](https://doc.rust-lang.org/" "std/). Additionally for the curious, you can also [check out the source code " "for this site](https://github.com/rust-lang/rust-by-example)." msgstr "" "《通过例子学 Rust》（Rust By Example, RBE）是一系列可运行的示例，它们展示了各" "种 Rust 概念和标准库。为了更好地利用这些示例，请不要忘记[本地安装 Rust]" "(https://www.rust-lang.org/tools/install)并查看[官方文档](https://doc.rust-" "lang.org/)。此外，好奇的话，你也可以[查看这个网站的源代码](https://" "github.com/rust-lang/rust-by-example)。" #: src/index.md:12 msgid "Now let's begin!" msgstr "现在让我们开始吧！" #: src/index.md:14 msgid "[Hello World](hello.md) - Start with a traditional Hello World program." msgstr "[Hello World](hello.md) - 从一个经典的 Hello World 程序开始。" #: src/index.md:16 msgid "" "[Primitives](primitives.md) - Learn about signed integers, unsigned integers " "and other primitives." msgstr "" "[Primitives](primitives.md) - 学习有符号整数、无符号整数和其他原生类型。" #: src/index.md:18 msgid "[Custom Types](custom_types.md) - `struct` and `enum`." msgstr "[自定义类型](custom_types.md) - 结构体 `struct` 和枚举 `enum`。" #: src/index.md:20 msgid "" "[Variable Bindings](variable_bindings.md) - mutable bindings, scope, " "shadowing." msgstr "[变量绑定](variable_bindings.md) - 可变绑定、作用域、遮蔽。" #: src/index.md:22 msgid "[Types](types.md) - Learn about changing and defining types." msgstr "[类型](types.md) - 学习如何改变和定义类型。" #: src/index.md:24 msgid "" "[Conversion](conversion.md) - Convert between different types, such as " "strings, integers, and floats." msgstr "" "[转换](conversion.md) - 在不同类型的数据之间进行转换，如字符串、整数和浮点" "数。" #: src/index.md:26 msgid "" "[Expressions](expression.md) - Learn about Expressions & how to use them." msgstr "[表达式](expression.md) - 学习表达式及其使用方法。" #: src/index.md:28 msgid "[Flow of Control](flow_control.md) - `if`/`else`, `for`, and others." msgstr "[控制流](flow_control.md) - `if`/`else`、`for` 等。" #: src/index.md:30 msgid "" "[Functions](fn.md) - Learn about Methods, Closures and Higher Order " "Functions." msgstr "[函数](fn.md) - 学习方法、闭包和高阶函数。" #: src/index.md:32 msgid "[Modules](mod.md) - Organize code using modules" msgstr "[模块](mod.md) - 使用模块组织代码" #: src/index.md:34 msgid "" "[Crates](crates.md) - A crate is a compilation unit in Rust. Learn to create " "a library." msgstr "[Crates](crates.md) - Crate 是 Rust 中的编译单元。学习如何创建库。" #: src/index.md:36 msgid "" "[Cargo](cargo.md) - Go through some basic features of the official Rust " "package management tool." msgstr "[Cargo](cargo.md) - 了解官方 Rust 包管理工具的一些基本功能。" #: src/index.md:38 msgid "" "[Attributes](attribute.md) - An attribute is metadata applied to some " "module, crate or item." msgstr "[属性](attribute.md) - 属性是应用于某些模块、crate 或项的元数据。" #: src/index.md:40 msgid "" "[Generics](generics.md) - Learn about writing a function or data type which " "can work for multiple types of arguments." msgstr "[泛型](generics.md) - 学习编写可以适用于多种类型参数的函数或数据类型。" #: src/index.md:42 msgid "" "[Scoping rules](scope.md) - Scopes play an important part in ownership, " "borrowing, and lifetimes." msgstr "" "[作用域规则](scope.md) - 作用域在所有权（ownership）、借用（borrowing）和生命" "周期（lifetime）中扮演重要角色。" #: src/index.md:44 msgid "" "[Traits](trait.md) - A trait is a collection of methods defined for an " "unknown type: `Self`" msgstr "[特质](trait.md) - 特质（trait）是为未知类型 `Self` 定义的一组方法。" #: src/index.md:46 msgid "" "[Macros](macros.md) - Macros are a way of writing code that writes other " "code, which is known as metaprogramming." msgstr "" "[宏](macros.md) - 宏是一种编写代码以生成其他代码的方式，也被称为元编程。" #: src/index.md:48 msgid "[Error handling](error.md) - Learn Rust way of handling failures." msgstr "[错误处理](error.md) - 学习 Rust 处理失败的方式。" #: src/index.md:50 msgid "" "[Std library types](std.md) - Learn about some custom types provided by " "`std` library." msgstr "[标准库类型](std.md) - 学习 `std` 标准库提供的一些自定义类型。" #: src/index.md:52 msgid "[Std misc](std_misc.md) - More custom types for file handling, threads." msgstr "" "[标准库中的其他内容](std_misc.md) - 更多关于文件处理、线程的自定义类型。" #: src/index.md:54 msgid "[Testing](testing.md) - All sorts of testing in Rust." msgstr "[测试](testing.md) - Rust 中的各种测试方法。" #: src/index.md:56 msgid "" "[Unsafe Operations](unsafe.md) - Learn about entering a block of unsafe " "operations." msgstr "[不安全操作](unsafe.md) - 学习如何编写和使用不安全代码块。" #: src/index.md:58 msgid "" "[Compatibility](compatibility.md) - Handling Rust's evolution and potential " "compatibility issues." msgstr "" "[兼容性](compatibility.md) - 应对 Rust 语言的演进及可能出现的兼容性问题。" #: src/index.md:60 msgid "[Meta](meta.md) - Documentation, Benchmarking." msgstr "[补充](meta.md) - 文档，基准测试。" #: src/hello.md:3 msgid "This is the source code of the traditional Hello World program." msgstr "这是经典的 Hello World 程序的源代码。" #: src/hello.md:6 msgid "" "// This is a comment, and is ignored by the compiler.\n" "// You can test this code by clicking the \"Run\" button over there ->\n" "// or if you prefer to use your keyboard, you can use the \"Ctrl + Enter\"\n" "// shortcut.\n" msgstr "" "// 这是一行注释，编译器会忽略它。\n" "// 你可以点击右侧的 \"Run\" 按钮来测试这段代码 ->\n" "// 如果你更习惯使用键盘，也可以使用\"Ctrl + Enter\"快捷键来运行。\n" #: src/hello.md:10 msgid "" "// This code is editable, feel free to hack it!\n" "// You can always return to the original code by clicking the \"Reset\" " "button ->\n" msgstr "" "// 这段代码是可以编辑的，请随意修改！\n" "// 你可以随时点击 \"Reset\" 按钮恢复到初始代码 ->\n" #: src/hello.md:13 msgid "// This is the main function.\n" msgstr "// 这是主函数。\n" #: src/hello.md:16 msgid "// Statements here are executed when the compiled binary is called.\n" msgstr "// 当运行编译后的程序时，这里的语句会被执行。\n" #: src/hello.md:18 msgid "// Print text to the console.\n" msgstr "// 在控制台打印文本。\n" #: src/hello.md:19 src/error/result.md:55 src/meta/playground.md:12 msgid "\"Hello World!\"" msgstr "\"Hello World!\"" #: src/hello.md:23 msgid "`println!` is a [_macro_](macros.md) that prints text to the console." msgstr "`println!` 是一个用于在控制台打印文本的[宏](macros.md)。" #: src/hello.md:26 msgid "A binary can be generated using the Rust compiler: `rustc`." msgstr "可以使用 Rust 编译器 `rustc` 来生成可执行文件。" #: src/hello.md:32 msgid "`rustc` will produce a `hello` binary that can be executed." msgstr "`rustc` 将生成一个名为 `hello` 的可执行文件。" #: src/hello.md:39 src/hello/print/print_display.md:107 #: src/hello/print/print_display/testcase_list.md:53 src/hello/print/fmt.md:70 #: src/primitives/tuples.md:64 src/custom_types/structs.md:89 msgid "Activity" msgstr "练习" #: src/hello.md:41 msgid "" "Click 'Run' above to see the expected output. Next, add a new line with a " "second `println!` macro so that the output shows:" msgstr "" "点击上方的\"运行\"按钮查看预期输出。接下来，添加一行新代码，再次使用 " "`println!` 宏，输出显示如下内容：" #: src/hello/comment.md:3 msgid "" "Any program requires comments, and Rust supports a few different varieties:" msgstr "每个程序都需要注释，Rust 支持几种不同类型的注释：" #: src/hello/comment.md:6 msgid "_Regular comments_ which are ignored by the compiler:" msgstr "**普通注释**：编译器会忽略这些注释" #: src/hello/comment.md:7 msgid "`// Line comments which go to the end of the line.`" msgstr "`// 行注释，从双斜杠开始到行尾。`" #: src/hello/comment.md:8 msgid "`/* Block comments which go to the closing delimiter. */`" msgstr "`/* 块注释，从开始符号到结束符号。 */`" #: src/hello/comment.md:9 msgid "" "_Doc comments_ which are parsed into HTML library [documentation](../meta/" "doc.md):" msgstr "**文档注释**：这些注释会被解析成 HTML 格式的[库文档](../meta/doc.md)" #: src/hello/comment.md:10 msgid "`/// Generate library docs for the following item.`" msgstr "`/// 为接下来的项生成库文档。`" #: src/hello/comment.md:11 msgid "`//! Generate library docs for the enclosing item.`" msgstr "`//! 为当前项（如 crate、模块或函数）生成库文档。`" #: src/hello/comment.md:15 msgid "" "// This is an example of a line comment.\n" " // There are two slashes at the beginning of the line.\n" " // And nothing written after these will be read by the compiler.\n" msgstr "" "// 这是行注释的一个例子。\n" " // 在行首有两个斜杠。\n" " // 斜杠后面的内容编译器不会读取。\n" #: src/hello/comment.md:19 msgid "// println!(\"Hello, world!\");\n" msgstr "// println!(\"Hello, world!\");\n" #: src/hello/comment.md:21 msgid "// Run it. See? Now try deleting the two slashes, and run it again.\n" msgstr "// 运行看看。明白了吗？现在试着删除这两个斜杠，再运行一次。\n" #: src/hello/comment.md:23 msgid "" "/*\n" " * This is another type of comment, a block comment. In general,\n" " * line comments are the recommended comment style. But block comments\n" " * are extremely useful for temporarily disabling chunks of code.\n" " * /* Block comments can be /* nested, */ */ so it takes only a few\n" " * keystrokes to comment out everything in this main() function.\n" " * /*/*/* Try it yourself! */*/*/\n" " */" msgstr "" "/*\n" " * 这是另一种类型的注释，称为块注释。一般来说，推荐使用行注释。\n" " * 但是块注释在临时禁用大段代码时非常有用。\n" " * /* 块注释可以 /* 嵌套， */ */ 因此只需几次按键就能\n" " * 注释掉 main() 函数中的所有内容。\n" " * /*/*/* 你可以自己试试！ */*/*/\n" " */" #: src/hello/comment.md:32 msgid "" "/*\n" " Note: The previous column of `*` was entirely for style. There's\n" " no actual need for it.\n" " */" msgstr "" "/*\n" " 注意：前面的 `*` 列纯粹是为了样式美观。实际上并不需要。\n" " */" #: src/hello/comment.md:37 msgid "" "// Here's another powerful use of block comments: you can uncomment\n" " // and comment a whole block by simply adding or removing a single\n" " // '/' character:\n" msgstr "" "// 这里展示块注释的另一个强大用途：你可以通过添加或删除单个\n" " // '/' 字符来取消注释或注释整个代码块：\n" #: src/hello/comment.md:41 msgid "" "/* <- add another '/' before the 1st one to uncomment the whole block\n" "\n" " println!(\"Now\");\n" " println!(\"everything\");\n" " println!(\"executes!\");\n" " // line comments inside are not affected by either state\n" "\n" " // */" msgstr "" "/* <- 在第一个字符前再添加一个 '/' 来取消注释整个代码块\n" "\n" " println!(\"Now\");\n" " println!(\"everything\");\n" " println!(\"executes!\");\n" " // 内部的行注释不受任何状态影响\n" "\n" " // */" #: src/hello/comment.md:50 msgid "" "// You can manipulate expressions more easily with block comments\n" " // than with line comments. Try deleting the comment delimiters\n" " // to change the result:\n" msgstr "" "// 块注释比行注释更方便地操作表达式\n" " // 试试删除注释符号，看看结果会有什么变化：\n" #: src/hello/comment.md:53 msgid "/* 90 + */" msgstr "/* 90 + */" #: src/hello/comment.md:54 msgid "\"Is `x` 10 or 100? x = {}\"" msgstr "\"`x` 是 10 还是 100？x = {}\"" #: src/hello/comment.md:58 src/hello/print.md:103 #: src/hello/print/print_debug.md:75 src/hello/print/print_display.md:128 #: src/hello/print/print_display/testcase_list.md:62 src/hello/print/fmt.md:89 #: src/primitives.md:64 src/custom_types/enum.md:100 #: src/custom_types/enum/enum_use.md:45 src/custom_types/enum/c_like.md:33 #: src/custom_types/enum/testcase_linked_list.md:78 #: src/custom_types/constants.md:35 src/types/alias.md:30 #: src/flow_control/for.md:121 #: src/flow_control/match/destructuring/destructure_tuple.md:25 #: src/flow_control/match/destructuring/destructure_slice.md:46 #: src/flow_control/match/destructuring/destructure_enum.md:48 #: src/flow_control/match/destructuring/destructure_pointers.md:63 #: src/flow_control/match/destructuring/destructure_structures.md:45 #: src/flow_control/match/guard.md:43 src/flow_control/match/binding.md:61 #: src/flow_control/if_let.md:118 src/flow_control/let_else.md:55 #: src/flow_control/while_let.md:56 src/fn/closures/capture.md:110 #: src/fn/closures/input_parameters.md:84 src/fn/closures/anonymity.md:47 #: src/fn/closures/input_functions.md:32 #: src/fn/closures/output_parameters.md:49 #: src/fn/closures/closure_examples/iter_any.md:50 #: src/fn/closures/closure_examples/iter_find.md:68 #: src/mod/struct_visibility.md:53 src/attribute/cfg.md:39 src/generics.md:59 #: src/generics/gen_fn.md:54 src/generics/impl.md:48 #: src/generics/gen_trait.md:39 src/generics/bounds.md:73 #: src/generics/bounds/testcase_empty.md:37 src/generics/multi_bounds.md:32 #: src/generics/where.md:49 src/generics/new_types.md:54 #: src/generics/assoc_items.md:10 src/generics/assoc_items/the_problem.md:62 #: src/generics/phantom.md:56 src/generics/phantom/testcase_units.md:75 #: src/scope/raii.md:92 src/scope/move/partial_move.md:57 #: src/scope/borrow/mut.md:56 src/scope/lifetime/explicit.md:68 #: src/scope/lifetime/fn.md:58 src/scope/lifetime/methods.md:24 #: src/scope/lifetime/struct.md:41 src/scope/lifetime/trait.md:28 #: src/scope/lifetime/lifetime_bounds.md:46 #: src/scope/lifetime/static_lifetime.md:133 src/scope/lifetime/elision.md:39 #: src/trait/derive.md:65 src/trait/supertraits.md:40 #: src/trait/disambiguating.md:60 src/error/option_unwrap/map.md:79 #: src/error/option_unwrap/and_then.md:73 #: src/error/option_unwrap/defaults.md:115 src/error/result/result_alias.md:41 #: src/error/multiple_error_types/boxing_errors.md:57 #: src/error/multiple_error_types/reenter_question_mark.md:74 #: src/error/multiple_error_types/wrap_error.md:91 src/std.md:12 #: src/std/rc.md:55 src/std_misc.md:12 #: src/std_misc/threads/testcase_mapreduce.md:127 src/std_misc/path.md:53 #: src/std_misc/fs.md:149 src/meta/doc.md:109 src/meta/playground.md:49 msgid "See also:" msgstr "另请参阅：" #: src/hello/comment.md:60 msgid "[Library documentation](../meta/doc.md)" msgstr "[库文档](../meta/doc.md)" #: src/hello/print.md:3 msgid "" "Printing is handled by a series of [`macros`](../macros.md) defined in " "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) some of which are:" msgstr "" "打印功能由 [`std::fmt`](https://doc.rust-lang.org/std/fmt/) 中定义的一系列[`" "宏`](../macros.md)处理，其中包括：" #: src/hello/print.md:6 msgid "`format!`: write formatted text to [`String`](../std/str.md)" msgstr "`format!`：将格式化文本写入 [`String`](../std/str.md)" #: src/hello/print.md:7 msgid "" "`print!`: same as `format!` but the text is printed to the console " "(io::stdout)." msgstr "`print!`：与 `format!` 类似，但文本会打印到控制台（io::stdout）" #: src/hello/print.md:9 msgid "`println!`: same as `print!` but a newline is appended." msgstr "`println!`：与 `print!` 类似，但会在末尾添加换行符" #: src/hello/print.md:10 msgid "" "`eprint!`: same as `print!` but the text is printed to the standard error " "(io::stderr)." msgstr "`eprint!`：与 `print!` 类似，但文本会打印到标准错误输出（io::stderr）" #: src/hello/print.md:12 msgid "`eprintln!`: same as `eprint!` but a newline is appended." msgstr "`eprintln!`：与 `eprint!` 类似，但会在末尾添加换行符" #: src/hello/print.md:14 msgid "" "All parse text in the same fashion. As a plus, Rust checks formatting " "correctness at compile time." msgstr "" "所有这些宏都以相同的方式解析文本。此外，Rust 会在编译时检查格式化的正确性。" #: src/hello/print.md:19 msgid "" "// In general, the `{}` will be automatically replaced with any\n" " // arguments. These will be stringified.\n" msgstr "" "// 通常，`{}` 会被自动替换为任何参数。\n" " // 这些参数会被转换为字符串。\n" #: src/hello/print.md:21 msgid "\"{} days\"" msgstr "\"{} 天\"" #: src/hello/print.md:23 msgid "" "// Positional arguments can be used. Specifying an integer inside `{}`\n" " // determines which additional argument will be replaced. Arguments " "start\n" " // at 0 immediately after the format string.\n" msgstr "" "// 可以使用位置参数。在 `{}` 中指定一个整数\n" " // 来决定替换哪个额外的参数。参数编号\n" " // 从格式字符串后立即开始，从 0 开始。\n" #: src/hello/print.md:26 msgid "\"{0}, this is {1}. {1}, this is {0}\"" msgstr "\"{0}，这是 {1}。{1}，这是 {0}\"" #: src/hello/print.md:26 src/scope/move/partial_move.md:31 msgid "\"Alice\"" msgstr "\"Alice\"" #: src/hello/print.md:26 src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Bob\"" msgstr "\"Bob\"" #: src/hello/print.md:28 msgid "// As can named arguments.\n" msgstr "// 还可以使用命名参数。\n" #: src/hello/print.md:29 msgid "\"{subject} {verb} {object}\"" msgstr "\"{subject} {verb} {object}\"" #: src/hello/print.md:30 msgid "\"the lazy dog\"" msgstr "\"那只懒惰的狗\"" #: src/hello/print.md:31 msgid "\"the quick brown fox\"" msgstr "\"那只敏捷的棕色狐狸\"" #: src/hello/print.md:32 msgid "\"jumps over\"" msgstr "\"跳过\"" #: src/hello/print.md:34 msgid "" "// Different formatting can be invoked by specifying the format character\n" " // after a `:`.\n" msgstr "" "// 在 `:` 后指定格式字符，\n" " // 可以调用不同的格式化方式。\n" #: src/hello/print.md:36 msgid "\"Base 10: {}\"" msgstr "\"十进制： {}\"" #: src/hello/print.md:36 msgid "// 69420\n" msgstr "// 69420\n" #: src/hello/print.md:37 msgid "\"Base 2 (binary): {:b}\"" msgstr "\"二进制： {:b}\"" #: src/hello/print.md:37 msgid "// 10000111100101100\n" msgstr "// 10000111100101100\n" #: src/hello/print.md:38 msgid "\"Base 8 (octal): {:o}\"" msgstr "\"八进制： {:o}\"" #: src/hello/print.md:38 msgid "// 207454\n" msgstr "// 207454\n" #: src/hello/print.md:39 msgid "\"Base 16 (hexadecimal): {:x}\"" msgstr "\"十六进制： {:x}\"" #: src/hello/print.md:39 msgid "// 10f2c\n" msgstr "// 10f2c\n" #: src/hello/print.md:41 msgid "" "// You can right-justify text with a specified width. This will\n" " // output \" 1\". (Four white spaces and a \"1\", for a total width " "of 5.)\n" msgstr "" "// 可以指定宽度来右对齐文本。这将输出\n" " // \" 1\"。（四个空格和一个 \"1\"，总宽度为 5。）\n" #: src/hello/print.md:43 msgid "\"{number:>5}\"" msgstr "\"{number:>5}\"" #: src/hello/print.md:45 msgid "// You can pad numbers with extra zeroes,\n" msgstr "// 可以用额外的零来填充数字，\n" #: src/hello/print.md:46 msgid "\"{number:0>5}\"" msgstr "\"{number:0>5}\"" #: src/hello/print.md:46 msgid "" "// 00001\n" " // and left-adjust by flipping the sign. This will output \"10000\".\n" msgstr "" "// 00001\n" " // 通过翻转符号来左对齐。这将输出 \"10000\"。\n" #: src/hello/print.md:48 msgid "\"{number:0<5}\"" msgstr "\"{number:0<5}\"" #: src/hello/print.md:48 msgid "// 10000\n" msgstr "// 10000\n" #: src/hello/print.md:50 msgid "" "// You can use named arguments in the format specifier by appending a `$`.\n" msgstr "// 在格式说明符后添加 `$` 可以使用命名参数。\n" #: src/hello/print.md:51 msgid "\"{number:0>width$}\"" msgstr "\"{number:0>width$}\"" #: src/hello/print.md:53 msgid "" "// Rust even checks to make sure the correct number of arguments are used.\n" msgstr "// Rust 甚至会检查使用的参数数量是否正确。\n" #: src/hello/print.md:54 msgid "\"My name is {0}, {1} {0}\"" msgstr "\"我的名字是 {0}，{1} {0}\"" #: src/hello/print.md:54 msgid "\"Bond\"" msgstr "\"Bond\"" #: src/hello/print.md:55 msgid "// FIXME ^ Add the missing argument: \"James\"\n" msgstr "// FIXME ^ 添加缺失的参数：\"James\"\n" #: src/hello/print.md:57 msgid "" "// Only types that implement fmt::Display can be formatted with `{}`. User-\n" " // defined types do not implement fmt::Display by default.\n" msgstr "" "// 只有实现了 fmt::Display 的类型才能用 `{}` 格式化。\n" " // 用户定义的类型默认不实现 fmt::Display。\n" #: src/hello/print.md:60 msgid "// disable `dead_code` which warn against unused module\n" msgstr "// 禁用 `dead_code`，它会警告未使用的模块\n" #: src/hello/print.md:63 msgid "" "// This will not compile because `Structure` does not implement\n" " // fmt::Display.\n" " // println!(\"This struct `{}` won't print...\", Structure(3));\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 这无法编译，因为 `Structure` 没有实现 fmt::Display。\n" " // println!(\"这个结构体 `{}` 无法打印...\", Structure(3));\n" " // TODO ^ 尝试取消注释这一行\n" #: src/hello/print.md:68 msgid "" "// For Rust 1.58 and above, you can directly capture the argument from a\n" " // surrounding variable. Just like the above, this will output\n" " // \" 1\", 4 white spaces and a \"1\".\n" msgstr "" "// 在 Rust 1.58 及以上版本，你可以直接从周围的变量捕获参数。\n" " // 就像上面一样，这将输出 \" 1\"，4 个空格和一个 \"1\"。\n" #: src/hello/print.md:73 msgid "\"{number:>width$}\"" msgstr "\"{number:>width$}\"" #: src/hello/print.md:77 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) contains many [`traits`]" "(https://doc.rust-lang.org/std/fmt/#formatting-traits) which govern the " "display of text. The base form of two important ones are listed below:" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) 包含许多控制文本显示的 " "[`traits`](https://doc.rust-lang.org/std/fmt/#formatting-traits)。下面列出了" "两个重要的基本形式：" #: src/hello/print.md:80 msgid "" "`fmt::Debug`: Uses the `{:?}` marker. Format text for debugging purposes." msgstr "`fmt::Debug`: 使用 `{:?}` 标记。用于调试目的的文本格式化。" #: src/hello/print.md:81 msgid "" "`fmt::Display`: Uses the `{}` marker. Format text in a more elegant, user " "friendly fashion." msgstr "`fmt::Display`: 使用 `{}` 标记。以更优雅、用户友好的方式格式化文本。" #: src/hello/print.md:84 msgid "" "Here, we used `fmt::Display` because the std library provides " "implementations for these types. To print text for custom types, more steps " "are required." msgstr "" "这里我们使用 `fmt::Display`，因为标准库为这些类型提供了实现。要打印自定义类型" "的文本，需要额外的步骤。" #: src/hello/print.md:87 msgid "" "Implementing the `fmt::Display` trait automatically implements the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "which allows us to [convert](../conversion/string.md) the type to [`String`]" "(../std/str.md)." msgstr "" "实现 `fmt::Display` 特性会自动实现 [`ToString`](https://doc.rust-lang.org/" "std/string/trait.ToString.html) 特性，这允许我们将该类型[转换](../conversion/" "string.md)为[`String`](../std/str.md)。" #: src/hello/print.md:90 msgid "" "In _line 43_, `#[allow(dead_code)]` is an [attribute](../attribute.md) which " "only applies to the module after it." msgstr "" "在 _43 行_，`#[allow(dead_code)]`是一个 [属性(attribute)](../attribute.md)，" "它只适用于它之后的模块。" #: src/hello/print.md:92 msgid "Activities" msgstr "练习" #: src/hello/print.md:94 msgid "" "Fix the issue in the above code (see FIXME) so that it runs without error." msgstr "修复上述代码中的问题（参见 FIXME 注释），使其能够正常运行。" #: src/hello/print.md:96 msgid "" "Try uncommenting the line that attempts to format the `Structure` struct " "(see TODO)" msgstr "尝试取消注释那行尝试格式化 `Structure` 结构体的代码（参见 TODO 注释）" #: src/hello/print.md:98 msgid "" "Add a `println!` macro call that prints: `Pi is roughly 3.142` by " "controlling the number of decimal places shown. For the purposes of this " "exercise, use `let pi = 3.141592` as an estimate for pi. (Hint: you may need " "to check the [`std::fmt`](https://doc.rust-lang.org/std/fmt/) documentation " "for setting the number of decimals to display)" msgstr "" "添加一个 `println!` 宏调用，打印：`Pi 约等于 3.142`，通过控制显示的小数位数来" "实现。\n" "在本练习中，使用 `let pi = 3.141592` 作为 pi 的近似值。（提示：你可能需要查" "阅\n" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/) 文档来了解如何设置显示的小数" "位数）" #: src/hello/print.md:105 msgid "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`macros`](../macros.md), " "[`struct`](../custom_types/structs.md), [`traits`](https://doc.rust-lang.org/" "std/fmt/#formatting-traits), and [`dead_code`](../attribute/unused.md)" msgstr "" "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)、[`macros`](../" "macros.md)、\n" "[`struct`](../custom_types/structs.md)、[`traits`](https://doc.rust-lang.org/" "std/fmt/#formatting-traits) 和 [`dead_code`](../attribute/unused.md)" #: src/hello/print/print_debug.md:3 msgid "" "All types which want to use `std::fmt` formatting `traits` require an " "implementation to be printable. Automatic implementations are only provided " "for types such as in the `std` library. All others _must_ be manually " "implemented somehow." msgstr "" "所有想要使用 `std::fmt` 格式化 `traits` 的类型都需要实现才能打印。\n" "自动实现仅为 `std` 库中的类型提供。所有其他类型都**必须**以某种方式手动实现。" #: src/hello/print/print_debug.md:8 msgid "" "The `fmt::Debug` `trait` makes this very straightforward. _All_ types can " "`derive` (automatically create) the `fmt::Debug` implementation. This is not " "true for `fmt::Display` which must be manually implemented." msgstr "" "`fmt::Debug` trait 使这变得非常简单。**所有**类型都可以 `derive`（自动创" "建）\n" "`fmt::Debug` 实现。但这对 `fmt::Display` 不适用，后者必须手动实现。" #: src/hello/print/print_debug.md:13 msgid "" "// This structure cannot be printed either with `fmt::Display` or\n" "// with `fmt::Debug`.\n" msgstr "// 这个结构体无法通过 `fmt::Display` 或 `fmt::Debug` 打印。\n" #: src/hello/print/print_debug.md:16 msgid "" "// The `derive` attribute automatically creates the implementation\n" "// required to make this `struct` printable with `fmt::Debug`.\n" msgstr "" "// `derive` 属性自动创建使这个 `struct` 可以用 `fmt::Debug` 打印的实现。\n" #: src/hello/print/print_debug.md:23 msgid "All `std` library types are automatically printable with `{:?}` too:" msgstr "所有 `std` 库类型也可以自动使用 `{:?}` 打印：" #: src/hello/print/print_debug.md:26 msgid "" "// Derive the `fmt::Debug` implementation for `Structure`. `Structure`\n" "// is a structure which contains a single `i32`.\n" msgstr "" "// 为 `Structure` 派生 `fmt::Debug` 实现。`Structure` 是一个包含单个 `i32` 的" "结构体。\n" #: src/hello/print/print_debug.md:30 msgid "" "// Put a `Structure` inside of the structure `Deep`. Make it printable\n" "// also.\n" msgstr "// 在 `Deep` 结构体中放入一个 `Structure`。使其也可打印。\n" #: src/hello/print/print_debug.md:37 msgid "// Printing with `{:?}` is similar to with `{}`.\n" msgstr "// 使用 `{:?}` 打印类似于使用 `{}`。\n" #: src/hello/print/print_debug.md:38 msgid "\"{:?} months in a year.\"" msgstr "\"{:?} 个月在一年中。\"" #: src/hello/print/print_debug.md:39 msgid "\"{1:?} {0:?} is the {actor:?} name.\"" msgstr "\"{1:?} {0:?} 是这个 {actor:?} 的名字。\"" #: src/hello/print/print_debug.md:40 msgid "\"Slater\"" msgstr "\"Slater\"" #: src/hello/print/print_debug.md:41 msgid "\"Christian\"" msgstr "\"Christian\"" #: src/hello/print/print_debug.md:42 msgid "\"actor's\"" msgstr "\"演员\"" #: src/hello/print/print_debug.md:44 msgid "// `Structure` is printable!\n" msgstr "// `Structure` 现在可以打印了！\n" #: src/hello/print/print_debug.md:45 src/hello/print/print_debug.md:49 msgid "\"Now {:?} will print!\"" msgstr "\"现在 {:?} 将会打印！\"" #: src/hello/print/print_debug.md:47 msgid "" "// The problem with `derive` is there is no control over how\n" " // the results look. What if I want this to just show a `7`?\n" msgstr "" "// `derive` 的问题是无法控制输出的样式。\n" " // 如果我只想显示一个 `7` 怎么办？\n" #: src/hello/print/print_debug.md:53 msgid "" "So `fmt::Debug` definitely makes this printable but sacrifices some " "elegance. Rust also provides \"pretty printing\" with `{:#?}`." msgstr "" "所以 `fmt::Debug` 确实使其可打印，但牺牲了一些优雅。\n" "Rust 还提供了使用 `{:#?}` 进行\"美化打印\"的功能。" #: src/hello/print/print_debug.md:64 src/custom_types/structs.md:42 msgid "\"Peter\"" msgstr "\"Peter\"" #: src/hello/print/print_debug.md:68 msgid "// Pretty print\n" msgstr "// 美化打印\n" #: src/hello/print/print_debug.md:69 msgid "\"{:#?}\"" msgstr "\"{:#?}\"" #: src/hello/print/print_debug.md:73 msgid "One can manually implement `fmt::Display` to control the display." msgstr "可以手动实现 `fmt::Display` 来控制显示方式。" #: src/hello/print/print_debug.md:77 msgid "" "[`attributes`](https://doc.rust-lang.org/reference/attributes.html), " "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), and [`struct`](../../custom_types/structs.md)" msgstr "" "[`attributes`](https://doc.rust-lang.org/reference/attributes.html)、\n" "[`derive`](../../trait/derive.md)、[`std::fmt`](https://doc.rust-lang.org/" "std/fmt/) \n" "和 [`struct`](../../custom_types/structs.md)" #: src/hello/print/print_display.md:3 msgid "" "`fmt::Debug` hardly looks compact and clean, so it is often advantageous to " "customize the output appearance. This is done by manually implementing " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/), which uses the `{}` " "print marker. Implementing it looks like this:" msgstr "" "`fmt::Debug` 的输出往往不够简洁清晰，因此自定义输出外观通常更有优势。\n" "这可以通过手动实现 [`fmt::Display`](https://doc.rust-lang.org/std/fmt/) 来完" "成，\n" "它使用 `{}` 打印标记。实现方式如下：" #: src/hello/print/print_display.md:9 msgid "// Import (via `use`) the `fmt` module to make it available.\n" msgstr "// 通过 `use` 导入 `fmt` 模块使其可用。\n" #: src/hello/print/print_display.md:11 msgid "" "// Define a structure for which `fmt::Display` will be implemented. This is\n" "// a tuple struct named `Structure` that contains an `i32`.\n" msgstr "" "// 定义一个结构体，我们将为其实现 `fmt::Display`。\n" "// 这是一个名为 `Structure` 的元组结构体，包含一个 `i32`。\n" #: src/hello/print/print_display.md:15 msgid "" "// To use the `{}` marker, the trait `fmt::Display` must be implemented\n" "// manually for the type.\n" msgstr "// 要使用 `{}` 标记，必须为该类型手动实现 `fmt::Display` trait。\n" #: src/hello/print/print_display.md:19 msgid "// This trait requires `fmt` with this exact signature.\n" msgstr "// 这个 trait 要求 `fmt` 方法具有确切的签名。\n" #: src/hello/print/print_display.md:21 msgid "" "// Write strictly the first element into the supplied output\n" " // stream: `f`. Returns `fmt::Result` which indicates whether the\n" " // operation succeeded or failed. Note that `write!` uses syntax " "which\n" " // is very similar to `println!`.\n" msgstr "" "// 将第一个元素严格写入提供的输出流 `f`。\n" " // 返回 `fmt::Result`，表示操作是否成功。\n" " // 注意 `write!` 的语法与 `println!` 非常相似。\n" #: src/hello/print/print_display.md:25 #: src/hello/print/print_display/testcase_list.md:13 #: src/hello/print/print_display/testcase_list.md:39 #: src/hello/print/print_display/testcase_list.md:49 src/hello/print/fmt.md:53 #: src/custom_types/enum/testcase_linked_list.md:74 src/conversion/string.md:25 #: src/flow_control/loop.md:26 src/flow_control/while.md:21 #: src/flow_control/for.md:23 src/flow_control/for.md:43 src/fn.md:40 #: src/fn/closures/capture.md:96 src/fn/closures/capture.md:97 #: src/fn/closures/anonymity.md:41 src/generics/bounds.md:12 #: src/macros/repeat.md:24 src/macros/repeat.md:25 src/macros/repeat.md:26 #: src/error/result.md:73 src/std/str.md:92 src/std/str.md:102 #: src/std/str.md:106 src/std/str.md:111 src/std/result.md:72 #: src/std/result/question_mark.md:57 src/std/result/question_mark.md:65 #: src/std_misc/file/read_lines.md:60 src/std_misc/arg/matching.md:9 #: src/std_misc/arg/matching.md:13 msgid "\"{}\"" msgstr "\"{}\"" #: src/hello/print/print_display.md:30 msgid "" "`fmt::Display` may be cleaner than `fmt::Debug` but this presents a problem " "for the `std` library. How should ambiguous types be displayed? For example, " "if the `std` library implemented a single style for all `Vec`, what style " "should it be? Would it be either of these two?" msgstr "" "`fmt::Display` 可能比 `fmt::Debug` 更简洁，但这给 `std` 库带来了一个问题：如" "何显示歧义类型？例如，如果 `std` 库为所有 `Vec` 实现统一的样式，应该采用哪" "种样式？是以下两种之一吗？" #: src/hello/print/print_display.md:35 msgid "`Vec`: `/:/etc:/home/username:/bin` (split on `:`)" msgstr "`Vec`：`/:/etc:/home/username:/bin`（以 `:` 分隔）" #: src/hello/print/print_display.md:36 msgid "`Vec`: `1,2,3` (split on `,`)" msgstr "`Vec`：`1,2,3`（以 `,` 分隔）" #: src/hello/print/print_display.md:38 msgid "" "No, because there is no ideal style for all types and the `std` library " "doesn't presume to dictate one. `fmt::Display` is not implemented for " "`Vec` or for any other generic containers. `fmt::Debug` must then be used " "for these generic cases." msgstr "" "答案是否定的。因为不存在适用于所有类型的理想样式，`std` 库也不应擅自规定一" "种。因此，`fmt::Display` 并未为 `Vec` 或其他泛型容器实现。在这些泛型情况" "下，必须使用 `fmt::Debug`。" #: src/hello/print/print_display.md:43 msgid "" "This is not a problem though because for any new _container_ type which is " "_not_ generic, `fmt::Display` can be implemented." msgstr "" "不过，这不是问题。对于任何新的非泛型容器类型，都可以实现 `fmt::Display`。" #: src/hello/print/print_display.md:47 msgid "// Import `fmt`\n" msgstr "// 导入 `fmt`\n" #: src/hello/print/print_display.md:48 msgid "" "// A structure holding two numbers. `Debug` will be derived so the results " "can\n" "// be contrasted with `Display`.\n" msgstr "" "// 定义一个包含两个数字的结构体。派生 `Debug` 特性，\n" "// 以便与 `Display` 的结果进行对比。\n" #: src/hello/print/print_display.md:53 msgid "// Implement `Display` for `MinMax`.\n" msgstr "// 为 `MinMax` 实现 `Display` 特性。\n" #: src/hello/print/print_display.md:57 msgid "// Use `self.number` to refer to each positional data point.\n" msgstr "// 使用 `self.number` 引用每个位置的数据点。\n" #: src/hello/print/print_display.md:58 msgid "\"({}, {})\"" msgstr "\"({}, {})\"" #: src/hello/print/print_display.md:61 msgid "// Define a structure where the fields are nameable for comparison.\n" msgstr "// 定义一个结构体，其字段可命名以便比较。\n" #: src/hello/print/print_display.md:68 msgid "// Similarly, implement `Display` for `Point2D`.\n" msgstr "// 同样，为 `Point2D` 实现 `Display` 特性。\n" #: src/hello/print/print_display.md:72 msgid "// Customize so only `x` and `y` are denoted.\n" msgstr "// 自定义实现，只显示 `x` 和 `y`。\n" #: src/hello/print/print_display.md:73 msgid "\"x: {}, y: {}\"" msgstr "\"x: {}, y: {}\"" #: src/hello/print/print_display.md:80 msgid "\"Compare structures:\"" msgstr "\"比较结构体：\"" #: src/hello/print/print_display.md:81 src/hello/print/print_display.md:94 msgid "\"Display: {}\"" msgstr "\"Display：{}\"" #: src/hello/print/print_display.md:82 src/hello/print/print_display.md:95 msgid "\"Debug: {:?}\"" msgstr "\"Debug：{:?}\"" #: src/hello/print/print_display.md:87 msgid "\"The big range is {big} and the small is {small}\"" msgstr "\"大范围是 {big}，小范围是 {small}\"" #: src/hello/print/print_display.md:93 msgid "\"Compare points:\"" msgstr "\"比较点：\"" #: src/hello/print/print_display.md:97 msgid "" "// Error. Both `Debug` and `Display` were implemented, but `{:b}`\n" " // requires `fmt::Binary` to be implemented. This will not work.\n" " // println!(\"What does Point2D look like in binary: {:b}?\", point);\n" msgstr "" "// 错误。虽然实现了 `Debug` 和 `Display`，但 `{:b}` 需要\n" " // 实现 `fmt::Binary`。这行代码无法工作。\n" " // println!(\"Point2D 的二进制表示是什么：{:b}？\", point);\n" #: src/hello/print/print_display.md:103 msgid "" "So, `fmt::Display` has been implemented but `fmt::Binary` has not, and " "therefore cannot be used. `std::fmt` has many such [`traits`](https://" "doc.rust-lang.org/std/fmt/#formatting-traits) and each requires its own " "implementation. This is detailed further in [`std::fmt`](https://doc.rust-" "lang.org/std/fmt/)." msgstr "" "因此，虽然实现了 `fmt::Display`，但未实现 `fmt::Binary`，所以无法使用。" "`std::fmt` 包含许多这样的[`traits`](https://doc.rust-lang.org/std/fmt/" "#formatting-traits)，每个都需要单独实现。更多详情请参阅 [`std::fmt`](https://" "doc.rust-lang.org/std/fmt/)。" #: src/hello/print/print_display.md:109 msgid "" "After checking the output of the above example, use the `Point2D` struct as " "a guide to add a `Complex` struct to the example. When printed in the same " "way, the output should be:" msgstr "" "查看上述示例的输出后，参考 `Point2D` 结构体，向示例中添加一个 `Complex` 结构" "体。以相同方式打印时，输出应为：" #: src/hello/print/print_display.md:121 msgid "Bonus: Add a space before the `+`/`-` signs." msgstr "额外练习：在 `+`/`-` 符号前添加一个空格。" #: src/hello/print/print_display.md:123 msgid "Hints in case you get stuck:" msgstr "如果你遇到困难，这里有三个提示：" #: src/hello/print/print_display.md:125 msgid "" "Check the documentation for [`Sign/#/0`](https://doc.rust-lang.org/std/fmt/" "#sign0) in `std::fmt`." msgstr "" "你可以使用 `:0>2` [用零填充到宽度为 2](https://doc.rust-lang.org/std/fmt/" "#width)。" #: src/hello/print/print_display.md:126 msgid "" "Bonus: Check [`if`\\-`else`](../../flow_control/if_else.md) branching and " "the [`abs`](https://doc.rust-lang.org/std/primitive.f64.html#method.abs) " "function." msgstr "" "额外练习：查看 [`if`\\-`else`](../../flow_control/if_else.md) 分支语句以及 " "[`abs`](https://doc.rust-lang.org/std/primitive.f64.html#method.abs) 函数。" #: src/hello/print/print_display.md:130 msgid "" "[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/" "std/fmt/), [`macros`](../../macros.md), [`struct`](../../custom_types/" "structs.md), [`trait`](https://doc.rust-lang.org/std/fmt/#formatting-" "traits), and [`use`](../../mod/use.md)" msgstr "" "[`derive`](../../trait/derive.md)、[`std::fmt`](https://doc.rust-lang.org/" "std/fmt/)、[`macros`](../../macros.md)、[`struct`](../../custom_types/" "structs.md)、[`trait`](https://doc.rust-lang.org/std/fmt/#formatting-traits) " "和 [`use`](../../mod/use.md)" #: src/hello/print/print_display/testcase_list.md:3 msgid "" "Implementing `fmt::Display` for a structure where the elements must each be " "handled sequentially is tricky. The problem is that each `write!` generates " "a `fmt::Result`. Proper handling of this requires dealing with _all_ the " "results. Rust provides the `?` operator for exactly this purpose." msgstr "" "为一个需要顺序处理元素的结构体实现 `fmt::Display` 是棘手的。问题在于每个 " "`write!` 都会生成一个 `fmt::Result`。正确处理这种情况需要处理所有的结果。" "Rust 提供了 `?` 运算符专门用于此目的。" #: src/hello/print/print_display/testcase_list.md:8 msgid "Using `?` on `write!` looks like this:" msgstr "在 `write!` 上使用 `?` 的示例如下：" #: src/hello/print/print_display/testcase_list.md:11 msgid "" "// Try `write!` to see if it errors. If it errors, return\n" "// the error. Otherwise continue.\n" msgstr "" "// 尝试执行 `write!`，检查是否出错。如果出错，返回错误。\n" "// 否则继续执行。\n" #: src/hello/print/print_display/testcase_list.md:16 msgid "" "With `?` available, implementing `fmt::Display` for a `Vec` is " "straightforward:" msgstr "有了 `?` 运算符，为 `Vec` 实现 `fmt::Display` 就变得简单明了：" #: src/hello/print/print_display/testcase_list.md:20 msgid "// Import the `fmt` module.\n" msgstr "// 导入 `fmt` 模块。\n" #: src/hello/print/print_display/testcase_list.md:21 msgid "// Define a structure named `List` containing a `Vec`.\n" msgstr "// 定义一个名为 `List` 的结构体，包含一个 `Vec`。\n" #: src/hello/print/print_display/testcase_list.md:27 msgid "" "// Extract the value using tuple indexing,\n" " // and create a reference to `vec`.\n" msgstr "" "// 使用元组索引提取值，\n" " // 并创建一个指向 `vec` 的引用。\n" #: src/hello/print/print_display/testcase_list.md:31 msgid "\"[\"" msgstr "\"[\"" #: src/hello/print/print_display/testcase_list.md:33 msgid "" "// Iterate over `v` in `vec` while enumerating the iteration\n" " // index in `index`.\n" msgstr "// 遍历 `vec` 中的 `v`，同时用 `index` 枚举迭代索引。\n" #: src/hello/print/print_display/testcase_list.md:36 msgid "" "// For every element except the first, add a comma.\n" " // Use the ? operator to return on errors.\n" msgstr "" "// 除第一个元素外，为每个元素添加逗号。\n" " // 使用 ? 运算符在出错时返回。\n" #: src/hello/print/print_display/testcase_list.md:38 src/std/str.md:36 msgid "\", \"" msgstr "\", \"" #: src/hello/print/print_display/testcase_list.md:42 msgid "// Close the opened bracket and return a fmt::Result value.\n" msgstr "// 闭合左括号并返回 fmt::Result 值\n" #: src/hello/print/print_display/testcase_list.md:43 msgid "\"]\"" msgstr "\"]\"" #: src/hello/print/print_display/testcase_list.md:55 msgid "" "Try changing the program so that the index of each element in the vector is " "also printed. The new output should look like this:" msgstr "" "尝试修改程序，使向量中每个元素的索引也被打印出来。新的输出应该如下所示：" #: src/hello/print/print_display/testcase_list.md:64 msgid "" "[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/" "ref.md), [`Result`](../../../std/result.md), [`struct`](../../../" "custom_types/structs.md), [`?`](../../../std/result/question_mark.md), and " "[`vec!`](../../../std/vec.md)" msgstr "" "[`for`](../../../flow_control/for.md)、[`ref`](../../../scope/borrow/" "ref.md)、[`Result`](../../../std/result.md)、[`struct`](../../../" "custom_types/structs.md)、[`?`](../../../std/result/question_mark.md) 和 " "[`vec!`](../../../std/vec.md)" #: src/hello/print/fmt.md:3 msgid "We've seen that formatting is specified via a _format string_:" msgstr "我们已经看到，格式化是通过一个_格式字符串_来指定的：" #: src/hello/print/fmt.md:5 msgid "`format!(\"{}\", foo)` -> `\"3735928559\"`" msgstr "`format!(\"{}\", foo)` -> `\"3735928559\"`" #: src/hello/print/fmt.md:6 msgid "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" msgstr "" "`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/" "wiki/Deadbeef#Magic_debug_values)" #: src/hello/print/fmt.md:7 msgid "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" msgstr "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`" #: src/hello/print/fmt.md:9 msgid "" "The same variable (`foo`) can be formatted differently depending on which " "_argument type_ is used: `X` vs `o` vs _unspecified_." msgstr "" "同一个变量（`foo`）可以根据使用的**参数类型**而有不同的格式化方式：`X`、`o` " "或**未指定**。" #: src/hello/print/fmt.md:12 msgid "" "This formatting functionality is implemented via traits, and there is one " "trait for each argument type. The most common formatting trait is `Display`, " "which handles cases where the argument type is left unspecified: `{}` for " "instance." msgstr "" "这种格式化功能是通过 trait 实现的，每种参数类型都对应一个 trait。最常用的格式" "化 trait 是 `Display`，它处理参数类型未指定的情况，例如 `{}`。" #: src/hello/print/fmt.md:21 msgid "// Latitude\n" msgstr "// 纬度\n" #: src/hello/print/fmt.md:23 msgid "// Longitude\n" msgstr "// 经度\n" #: src/hello/print/fmt.md:28 msgid "" "// `f` is a buffer, and this method must write the formatted string into " "it.\n" msgstr "// `f` 是一个缓冲区，此方法必须将格式化的字符串写入其中。\n" #: src/hello/print/fmt.md:30 msgid "'N'" msgstr "'N'" #: src/hello/print/fmt.md:30 msgid "'S'" msgstr "'S'" #: src/hello/print/fmt.md:31 msgid "'E'" msgstr "'E'" #: src/hello/print/fmt.md:31 msgid "'W'" msgstr "'W'" #: src/hello/print/fmt.md:33 msgid "" "// `write!` is like `format!`, but it will write the formatted string\n" " // into a buffer (the first argument).\n" msgstr "" "// `write!` 类似于 `format!`，但它会将格式化后的字符串\n" " // 写入一个缓冲区（第一个参数）。\n" #: src/hello/print/fmt.md:35 msgid "\"{}: {:.3}°{} {:.3}°{}\"" msgstr "\"{}: {:.3}°{} {:.3}°{}\"" #: src/hello/print/fmt.md:49 msgid "\"Dublin\"" msgstr "\"Dublin\"" #: src/hello/print/fmt.md:50 msgid "\"Oslo\"" msgstr "\"Oslo\"" #: src/hello/print/fmt.md:51 msgid "\"Vancouver\"" msgstr "\"Vancouver\"" #: src/hello/print/fmt.md:60 msgid "" "// Switch this to use {} once you've added an implementation\n" " // for fmt::Display.\n" msgstr "// 一旦你为 fmt::Display 添加了实现，就把这里改成使用 {}。\n" #: src/hello/print/fmt.md:62 src/primitives/tuples.md:60 #: src/custom_types/structs.md:47 src/types/inference.md:23 #: src/conversion/string.md:76 src/generics/bounds.md:49 #: src/generics/where.md:38 src/std/str.md:137 src/std/result.md:59 #: src/std/result.md:61 src/std/result.md:63 src/std/arc.md:26 #: src/std_misc/channels.md:53 msgid "\"{:?}\"" msgstr "\"{:?}\"" #: src/hello/print/fmt.md:67 msgid "" "You can view a [full list of formatting traits](https://doc.rust-lang.org/" "std/fmt/#formatting-traits) and their argument types in the [`std::fmt`]" "(https://doc.rust-lang.org/std/fmt/) documentation." msgstr "" "你可以在 [`std::fmt`](https://doc.rust-lang.org/std/fmt/) 文档中查看[格式化 " "trait 的完整列表](https://doc.rust-lang.org/std/fmt/#formatting-traits)及其参" "数类型。" #: src/hello/print/fmt.md:72 msgid "" "Add an implementation of the `fmt::Display` trait for the `Color` struct " "above so that the output displays as:" msgstr "为上面的 `Color` 结构体实现 `fmt::Display` trait，使输出显示如下：" #: src/hello/print/fmt.md:81 msgid "Three hints if you get stuck:" msgstr "如果你遇到困难，这里有三个提示：" #: src/hello/print/fmt.md:83 msgid "" "The formula for calculating a color in the RGB color space is: `RGB = " "(R*65536)+(G*256)+B , (when R is RED, G is GREEN and B is BLUE)`. For more " "see [RGB color format & calculation](https://www.rapidtables.com/web/color/" "RGB_Color.html#rgb-format)." msgstr "" "RGB 颜色空间中颜色的计算公式是：`RGB = (R*65536)+(G*256)+B，（其中 R 是红色，" "G 是绿色，B 是蓝色）`。更多信息请参见 [RGB 颜色格式和计算](https://" "www.rapidtables.com/web/color/RGB_Color.html#rgb-format)。" #: src/hello/print/fmt.md:86 msgid "" "You [may need to list each color more than once](https://doc.rust-lang.org/" "std/fmt/#named-parameters)." msgstr "" "你[可能需要多次列出每种颜色](https://doc.rust-lang.org/std/fmt/#named-" "parameters)。" #: src/hello/print/fmt.md:87 msgid "" "You can [pad with zeros to a width of 2](https://doc.rust-lang.org/std/fmt/" "#width) with `:0>2`." msgstr "" "你可以使用 `:0>2` [用零填充到宽度为 2](https://doc.rust-lang.org/std/fmt/" "#width)。" #: src/hello/print/fmt.md:91 msgid "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" msgstr "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)" #: src/primitives.md:3 msgid "" "Rust provides access to a wide variety of `primitives`. A sample includes:" msgstr "Rust 提供了多种`原生类型`。以下是一些示例：" #: src/primitives.md:5 msgid "Scalar Types" msgstr "标量类型" #: src/primitives.md:7 msgid "" "Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size)" msgstr "有符号整数：`i8`、`i16`、`i32`、`i64`、`i128` 和 `isize`（指针大小）" #: src/primitives.md:8 msgid "" "Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer " "size)" msgstr "无符号整数：`u8`、`u16`、`u32`、`u64`、`u128` 和 `usize`（指针大小）" #: src/primitives.md:10 msgid "Floating point: `f32`, `f64`" msgstr "浮点数：`f32`、`f64`" #: src/primitives.md:11 msgid "`char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each)" msgstr "`char` Unicode 标量值，如 `'a'`、`'α'` 和 `'∞'`（每个都是 4 字节）" #: src/primitives.md:12 msgid "`bool` either `true` or `false`" msgstr "`bool` 值为 `true` 或 `false`" #: src/primitives.md:13 msgid "The unit type `()`, whose only possible value is an empty tuple: `()`" msgstr "单元类型 `()`，其唯一可能的值是空元组：`()`" #: src/primitives.md:15 msgid "" "Despite the value of a unit type being a tuple, it is not considered a " "compound type because it does not contain multiple values." msgstr "尽管单元类型的值是一个元组，但它不被视为复合类型，因为它不包含多个值。" #: src/primitives.md:18 msgid "Compound Types" msgstr "复合类型" #: src/primitives.md:20 msgid "Arrays like `[1, 2, 3]`" msgstr "数组，如 `[1, 2, 3]`" #: src/primitives.md:21 msgid "Tuples like `(1, true)`" msgstr "元组，如 `(1, true)`" #: src/primitives.md:23 msgid "" "Variables can always be _type annotated_. Numbers may additionally be " "annotated via a _suffix_ or _by default_. Integers default to `i32` and " "floats to `f64`. Note that Rust can also infer types from context." msgstr "" "变量总是可以进行**类型标注**。数字还可以通过**后缀**或**默认方式**来标注。整" "数默认为 `i32` 类型，浮点数默认为 `f64` 类型。请注意，Rust 也可以从上下文中推" "断类型。" #: src/primitives.md:29 msgid "// Variables can be type annotated.\n" msgstr "// 变量可以被类型标注。\n" #: src/primitives.md:32 msgid "// Regular annotation\n" msgstr "// 常规标注\n" #: src/primitives.md:33 msgid "// Suffix annotation\n" msgstr "// 后缀标注\n" #: src/primitives.md:35 msgid "// Or a default will be used.\n" msgstr "// 或者使用默认类型。\n" #: src/primitives.md:36 msgid "// `f64`\n" msgstr "// `f64`\n" #: src/primitives.md:37 msgid "// `i32`\n" msgstr "// `i32`\n" #: src/primitives.md:39 msgid "// A type can also be inferred from context.\n" msgstr "// 类型也可以从上下文中推断。\n" #: src/primitives.md:40 msgid "// Type i64 is inferred from another line.\n" msgstr "// 从另一行推断出类型为 i64。\n" #: src/primitives.md:43 msgid "// A mutable variable's value can be changed.\n" msgstr "// 可变变量的值可以改变。\n" #: src/primitives.md:44 msgid "// Mutable `i32`\n" msgstr "// 可变的 `i32`\n" #: src/primitives.md:47 msgid "// Error! The type of a variable can't be changed.\n" msgstr "// 报错！变量的类型不能改变。\n" #: src/primitives.md:50 msgid "// Variables can be overwritten with shadowing.\n" msgstr "// 变量可以通过遮蔽（shadowing）来覆盖。\n" #: src/primitives.md:53 msgid "/* Compound types - Array and Tuple */" msgstr "/* 复合类型 - 数组和元组 */" #: src/primitives.md:55 msgid "// Array signature consists of Type T and length as [T; length].\n" msgstr "// 数组的签名由类型 T 和长度组成，表示为 [T; length]。\n" #: src/primitives.md:58 msgid "" "// Tuple is a collection of values of different types\n" " // and is constructed using parentheses ().\n" msgstr "" "// 元组是不同类型值的集合，\n" " // 使用圆括号 () 构造。\n" #: src/primitives.md:66 msgid "" "[the `std` library](https://doc.rust-lang.org/std/), [`mut`]" "(variable_bindings/mut.md), [`inference`](types/inference.md), and " "[`shadowing`](variable_bindings/scope.md)" msgstr "" "[`std` 库](https://doc.rust-lang.org/std/)、[`mut`](variable_bindings/" "mut.md)、[`inference`](types/inference.md) 和 [`shadowing`]" "(variable_bindings/scope.md)" #: src/primitives/literals.md:3 msgid "" "Integers `1`, floats `1.2`, characters `'a'`, strings `\"abc\"`, booleans " "`true` and the unit type `()` can be expressed using literals." msgstr "" "整数 `1`、浮点数 `1.2`、字符 `'a'`、字符串 `\"abc\"`、布尔值 `true` 和单元类" "型 `()` 可以用字面值表示。" #: src/primitives/literals.md:6 msgid "" "Integers can, alternatively, be expressed using hexadecimal, octal or binary " "notation using these prefixes respectively: `0x`, `0o` or `0b`." msgstr "" "整数也可以使用十六进制、八进制或二进制表示法，分别使用这些前缀：`0x`、`0o` " "或 `0b`。" #: src/primitives/literals.md:9 msgid "" "Underscores can be inserted in numeric literals to improve readability, e.g. " "`1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`." msgstr "" "可以在数字字面值中插入下划线以提高可读性，例如 `1_000` 与 `1000` 相同，" "`0.000_001` 与 `0.000001` 相同。" #: src/primitives/literals.md:12 msgid "" "Rust also supports scientific [E-notation](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. The associated type " "is `f64`." msgstr "" "Rust 还支持科学计数法 [E-notation](https://en.wikipedia.org/wiki/" "Scientific_notation#E_notation)，例如 `1e6`、`7.6e-4`。相关类型是 `f64`。" #: src/primitives/literals.md:15 msgid "" "We need to tell the compiler the type of the literals we use. For now, we'll " "use the `u32` suffix to indicate that the literal is an unsigned 32-bit " "integer, and the `i32` suffix to indicate that it's a signed 32-bit integer." msgstr "" "我们需要告诉编译器我们使用的字面值的类型。现在，我们将使用 `u32` 后缀来表示该" "字面值是一个无符号 32 位整数，使用 `i32` 后缀来表示它是一个有符号 32 位整数。" #: src/primitives/literals.md:19 msgid "" "The operators available and their precedence [in Rust](https://doc.rust-" "lang.org/reference/expressions.html#expression-precedence) are similar to " "other [C-like languages](https://en.wikipedia.org/wiki/" "Operator_precedence#Programming_languages)." msgstr "" "[Rust 中](https://doc.rust-lang.org/reference/expressions.html#expression-" "precedence)可用的运算符及其优先级与其他 [类 C 语言](https://en.wikipedia.org/" "wiki/Operator_precedence#Programming_languages) 类似。" #: src/primitives/literals.md:24 msgid "// Integer addition\n" msgstr "// 整数加法\n" #: src/primitives/literals.md:25 msgid "\"1 + 2 = {}\"" msgstr "\"1 + 2 = {}\"" #: src/primitives/literals.md:27 msgid "// Integer subtraction\n" msgstr "// 整数减法\n" #: src/primitives/literals.md:28 msgid "\"1 - 2 = {}\"" msgstr "\"1 - 2 = {}\"" #: src/primitives/literals.md:29 msgid "" "// TODO ^ Try changing `1i32` to `1u32` to see why the type is important\n" msgstr "// TODO ^ 尝试将 `1i32` 改为 `1u32`，看看为什么类型很重要\n" #: src/primitives/literals.md:31 msgid "// Scientific notation\n" msgstr "// 科学记数法\n" #: src/primitives/literals.md:32 msgid "\"1e4 is {}, -2.5e-3 is {}\"" msgstr "\"1e4 is {}, -2.5e-3 is {}\"" #: src/primitives/literals.md:34 msgid "// Short-circuiting boolean logic\n" msgstr "// 短路布尔逻辑\n" #: src/primitives/literals.md:35 msgid "\"true AND false is {}\"" msgstr "\"true AND false is {}\"" #: src/primitives/literals.md:36 msgid "\"true OR false is {}\"" msgstr "\"true OR false is {}\"" #: src/primitives/literals.md:37 msgid "\"NOT true is {}\"" msgstr "\"NOT true is {}\"" #: src/primitives/literals.md:39 msgid "// Bitwise operations\n" msgstr "// 位运算\n" #: src/primitives/literals.md:40 msgid "\"0011 AND 0101 is {:04b}\"" msgstr "\"0011 AND 0101 is {:04b}\"" #: src/primitives/literals.md:41 msgid "\"0011 OR 0101 is {:04b}\"" msgstr "\"0011 OR 0101 is {:04b}\"" #: src/primitives/literals.md:42 msgid "\"0011 XOR 0101 is {:04b}\"" msgstr "\"0011 XOR 0101 is {:04b}\"" #: src/primitives/literals.md:43 msgid "\"1 << 5 is {}\"" msgstr "\"1 << 5 is {}\"" #: src/primitives/literals.md:44 msgid "\"0x80 >> 2 is 0x{:x}\"" msgstr "\"0x80 >> 2 is 0x{:x}\"" #: src/primitives/literals.md:46 msgid "// Use underscores to improve readability!\n" msgstr "// 使用下划线来提高可读性！\n" #: src/primitives/literals.md:47 msgid "\"One million is written as {}\"" msgstr "\"One million is written as {}\"" #: src/primitives/tuples.md:3 msgid "" "A tuple is a collection of values of different types. Tuples are constructed " "using parentheses `()`, and each tuple itself is a value with type signature " "`(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions " "can use tuples to return multiple values, as tuples can hold any number of " "values." msgstr "" "元组是一个可以包含各种类型的值的集合。元组使用圆括号 `()` 来构造，而且每个元" "组本身是一个类型标记为 `(T1, T2, ...)` 的值，其中 `T1`、`T2` 是其成员的类型。" "函数可以使用元组来返回多个值，因为元组可以存储任意数量的值。" #: src/primitives/tuples.md:9 msgid "// Tuples can be used as function arguments and as return values.\n" msgstr "// 元组可以用作函数参数和返回值。\n" #: src/primitives/tuples.md:11 msgid "// `let` can be used to bind the members of a tuple to variables.\n" msgstr "// `let` 可以用来把元组的成员绑定到变量。\n" #: src/primitives/tuples.md:16 msgid "// The following struct is for the activity.\n" msgstr "// 以下结构体将用于后续练习。\n" #: src/primitives/tuples.md:22 msgid "// A tuple with a bunch of different types.\n" msgstr "// 一个包含多种不同类型的元组。\n" #: src/primitives/tuples.md:26 src/generics.md:50 src/generics.md:55 #: src/generics/gen_fn.md:47 msgid "'a'" msgstr "'a'" #: src/primitives/tuples.md:28 msgid "// Values can be extracted from the tuple using tuple indexing.\n" msgstr "// 可以使用元组索引来提取元组中的值。\n" #: src/primitives/tuples.md:29 msgid "\"Long tuple first value: {}\"" msgstr "\"长元组的第一个值：{}\"" #: src/primitives/tuples.md:30 msgid "\"Long tuple second value: {}\"" msgstr "\"长元组的第二个值：{}\"" #: src/primitives/tuples.md:32 msgid "// Tuples can be tuple members.\n" msgstr "// 元组可以作为元组的成员。\n" #: src/primitives/tuples.md:35 msgid "// Tuples are printable.\n" msgstr "// 元组是可打印的。\n" #: src/primitives/tuples.md:36 msgid "\"tuple of tuples: {:?}\"" msgstr "\"元组的元组：{:?}\"" #: src/primitives/tuples.md:38 msgid "" "// But long Tuples (more than 12 elements) cannot be printed.\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"Too long tuple: {:?}\", too_long_tuple);\n" " // TODO ^ Uncomment the above 2 lines to see the compiler error\n" msgstr "" "// 但长元组（超过 12 个元素）无法打印。\n" " //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n" " //println!(\"过长的元组：{:?}\", too_long_tuple);\n" " // TODO ^ 取消上面两行的注释以查看编译器错误\n" #: src/primitives/tuples.md:44 msgid "\"Pair is {:?}\"" msgstr "\"对组是 {:?}\"" #: src/primitives/tuples.md:46 msgid "\"The reversed pair is {:?}\"" msgstr "\"反转后的对组是 {:?}\"" #: src/primitives/tuples.md:48 msgid "" "// To create one element tuples, the comma is required to tell them apart\n" " // from a literal surrounded by parentheses.\n" msgstr "" "// 创建单元素元组时，需要使用逗号来区分它们\n" " // 与被括号包围的字面量。\n" #: src/primitives/tuples.md:50 msgid "\"One element tuple: {:?}\"" msgstr "\"单元素元组：{:?}\"" #: src/primitives/tuples.md:51 msgid "\"Just an integer: {:?}\"" msgstr "\"仅是一个整数：{:?}\"" #: src/primitives/tuples.md:53 msgid "// Tuples can be destructured to create bindings.\n" msgstr "// 可以通过解构元组来创建绑定。\n" #: src/primitives/tuples.md:54 src/conversion/from_into.md:17 #: src/fn/closures/input_parameters.md:52 src/std_misc/fs.md:51 msgid "\"hello\"" msgstr "\"hello\"" #: src/primitives/tuples.md:57 msgid "\"{:?}, {:?}, {:?}, {:?}\"" msgstr "\"{:?}、{:?}、{:?}、{:?}\"" #: src/primitives/tuples.md:66 msgid "" "_Recap_: Add the `fmt::Display` trait to the `Matrix` struct in the above " "example, so that if you switch from printing the debug format `{:?}` to the " "display format `{}`, you see the following output:" msgstr "" "**复习**：为上面示例中的 `Matrix` 结构体添加 `fmt::Display` trait，\n" "这样当你从打印调试格式 `{:?}` 切换到显示格式 `{}` 时，\n" "你会看到以下输出：" #: src/primitives/tuples.md:75 msgid "" "You may want to refer back to the example for [print display](../hello/print/" "print_display.md)." msgstr "" "你可能需要回顾一下 [打印显示](../hello/print/print_display.md) 的示例。" #: src/primitives/tuples.md:76 msgid "" "Add a `transpose` function using the `reverse` function as a template, which " "accepts a matrix as an argument, and returns a matrix in which two elements " "have been swapped. For example:" msgstr "" "参考 `reverse` 函数的模板，添加一个 `transpose` 函数。\n" "该函数接受一个矩阵作为参数，并返回一个交换了两个元素的矩阵。例如：" #: src/primitives/tuples.md:81 msgid "\"Matrix:\\n{}\"" msgstr "\"矩阵：\\n{}\"" #: src/primitives/tuples.md:82 msgid "\"Transpose:\\n{}\"" msgstr "\"转置：\\n{}\"" #: src/primitives/tuples.md:85 msgid "Results in the output:" msgstr "输出结果为：" #: src/primitives/array.md:3 msgid "" "An array is a collection of objects of the same type `T`, stored in " "contiguous memory. Arrays are created using brackets `[]`, and their length, " "which is known at compile time, is part of their type signature `[T; " "length]`." msgstr "" "数组是一种存储在连续内存中的相同类型 `T` 的对象集合。\n" "数组使用方括号 `[]` 创建，其长度在编译时已知，\n" "是其类型签名 `[T; length]` 的一部分。" #: src/primitives/array.md:7 msgid "" "Slices are similar to arrays, but their length is not known at compile time. " "Instead, a slice is a two-word object; the first word is a pointer to the " "data, the second word is the length of the slice. The word size is the same " "as usize, determined by the processor architecture, e.g. 64 bits on an " "x86-64. Slices can be used to borrow a section of an array and have the type " "signature `&[T]`." msgstr "" "切片类似于数组，但其长度在编译时未知。切片是一个双字对象：\n" "第一个字是指向数据的指针，第二个字是切片的长度。字的大小与 usize 相同，\n" "由处理器架构决定，例如在 x86-64 上是 64 位。切片可用于借用数组的一部分，\n" "其类型签名为 `&[T]`。" #: src/primitives/array.md:15 msgid "// This function borrows a slice.\n" msgstr "// 此函数借用一个切片。\n" #: src/primitives/array.md:18 msgid "\"First element of the slice: {}\"" msgstr "\"切片的第一个元素：{}\"" #: src/primitives/array.md:19 msgid "\"The slice has {} elements\"" msgstr "\"切片有 {} 个元素\"" #: src/primitives/array.md:23 msgid "// Fixed-size array (type signature is superfluous).\n" msgstr "// 固定大小的数组（类型签名是多余的）。\n" #: src/primitives/array.md:26 msgid "// All elements can be initialized to the same value.\n" msgstr "// 所有元素可以初始化为相同的值。\n" #: src/primitives/array.md:29 msgid "// Indexing starts at 0.\n" msgstr "// 索引从 0 开始。\n" #: src/primitives/array.md:30 msgid "\"First element of the array: {}\"" msgstr "\"数组的第一个元素：{}\"" #: src/primitives/array.md:31 msgid "\"Second element of the array: {}\"" msgstr "\"数组的第二个元素：{}\"" #: src/primitives/array.md:33 msgid "// `len` returns the count of elements in the array.\n" msgstr "// `len` 返回数组中元素的数量。\n" #: src/primitives/array.md:34 msgid "\"Number of elements in array: {}\"" msgstr "\"数组中的元素数量：{}\"" #: src/primitives/array.md:36 msgid "// Arrays are stack allocated.\n" msgstr "// 数组是栈分配的。\n" #: src/primitives/array.md:37 msgid "\"Array occupies {} bytes\"" msgstr "\"数组占用 {} 字节\"" #: src/primitives/array.md:39 msgid "// Arrays can be automatically borrowed as slices.\n" msgstr "// 数组可以自动借用为切片。\n" #: src/primitives/array.md:40 msgid "\"Borrow the whole array as a slice.\"" msgstr "\"将整个数组借用为切片。\"" #: src/primitives/array.md:43 msgid "" "// Slices can point to a section of an array.\n" " // They are of the form [starting_index..ending_index].\n" " // `starting_index` is the first position in the slice.\n" " // `ending_index` is one more than the last position in the slice.\n" msgstr "" "// 切片可以指向数组的一部分。\n" " // 它们的形式是 [起始索引..结束索引]。\n" " // `起始索引` 是切片中的第一个位置。\n" " // `结束索引` 是切片中最后一个位置的后一个位置。\n" #: src/primitives/array.md:47 msgid "\"Borrow a section of the array as a slice.\"" msgstr "\"借用数组的一部分作为切片。\"" #: src/primitives/array.md:50 msgid "// Example of empty slice `&[]`:\n" msgstr "// 空切片 `&[]` 的示例：\n" #: src/primitives/array.md:53 msgid "// Same but more verbose\n" msgstr "// 同样的操作，但更详细\n" #: src/primitives/array.md:55 msgid "" "// Arrays can be safely accessed using `.get`, which returns an\n" " // `Option`. This can be matched as shown below, or used with\n" " // `.expect()` if you would like the program to exit with a nice\n" " // message instead of happily continue.\n" msgstr "" "// 可以使用 `.get` 安全地访问数组，它返回一个 `Option`。\n" " // 可以像下面这样对其进行匹配，或者使用 `.expect()`。\n" " // 如果你希望程序在访问越界时优雅地退出而不是继续执行，\n" " // 可以使用 `.expect()`。\n" #: src/primitives/array.md:59 msgid "// Oops, one element too far!\n" msgstr "// 糟糕，访问超出了数组范围！\n" #: src/primitives/array.md:61 msgid "\"{}: {}\"" msgstr "\"{}: {}\"" #: src/primitives/array.md:62 msgid "\"Slow down! {} is too far!\"" msgstr "\"慢着！{} 超出范围了！\"" #: src/primitives/array.md:66 msgid "" "// Out of bound indexing on array with constant value causes compile time " "error.\n" " //println!(\"{}\", xs[5]);\n" " // Out of bound indexing on slice causes runtime error.\n" " //println!(\"{}\", xs[..][5]);\n" msgstr "" "// 使用常量值对数组的越界索引会导致编译时错误。\n" " //println!(\"{}\", xs[5]);\n" " // 对切片的越界索引会导致运行时错误。\n" " //println!(\"{}\", xs[..][5]);\n" #: src/custom_types.md:3 msgid "Rust custom data types are formed mainly through the two keywords:" msgstr "Rust 的自定义数据类型主要通过以下两个关键字来创建：" #: src/custom_types.md:5 msgid "`struct`: define a structure" msgstr "`struct`：定义结构体" #: src/custom_types.md:6 msgid "`enum`: define an enumeration" msgstr "`enum`：定义枚举" #: src/custom_types.md:8 msgid "Constants can also be created via the `const` and `static` keywords." msgstr "常量也可以通过 `const` 和 `static` 关键字来创建。" #: src/custom_types/structs.md:3 msgid "" "There are three types of structures (\"structs\") that can be created using " "the `struct` keyword:" msgstr "使用 `struct` 关键字可以创建三种类型的结构体（\"structs\"）：" #: src/custom_types/structs.md:6 msgid "Tuple structs, which are, basically, named tuples." msgstr "元组结构体：本质上是具名元组。" #: src/custom_types/structs.md:7 msgid "" "The classic [C structs](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" msgstr "" "经典的 [C 语言风格结构体](https://en.wikipedia.org/wiki/" "Struct_(C_programming_language))" #: src/custom_types/structs.md:8 msgid "Unit structs, which are field-less, are useful for generics." msgstr "单元结构体：没有字段，在泛型中很有用。" #: src/custom_types/structs.md:11 src/custom_types/enum/enum_use.md:6 #: src/custom_types/enum/c_like.md:6 msgid "// An attribute to hide warnings for unused code.\n" msgstr "// 这个属性用于隐藏未使用代码的警告。\n" #: src/custom_types/structs.md:19 msgid "// A unit struct\n" msgstr "// 单元结构体\n" #: src/custom_types/structs.md:22 msgid "// A tuple struct\n" msgstr "// 元组结构体\n" #: src/custom_types/structs.md:25 msgid "// A struct with two fields\n" msgstr "// 带有两个字段的结构体\n" #: src/custom_types/structs.md:31 msgid "// Structs can be reused as fields of another struct\n" msgstr "// 结构体可以作为另一个结构体的字段\n" #: src/custom_types/structs.md:34 msgid "" "// A rectangle can be specified by where the top left and bottom right\n" " // corners are in space.\n" msgstr "" "// 可以通过指定左上角和右下角的位置\n" " // 来定义一个矩形。\n" #: src/custom_types/structs.md:41 msgid "// Create struct with field init shorthand\n" msgstr "// 使用字段初始化简写语法创建结构体\n" #: src/custom_types/structs.md:46 msgid "// Print debug struct\n" msgstr "// 打印结构体的调试信息\n" #: src/custom_types/structs.md:49 msgid "// Instantiate a `Point`\n" msgstr "// 实例化一个 `Point`\n" #: src/custom_types/structs.md:53 msgid "// Access the fields of the point\n" msgstr "// 访问点的字段\n" #: src/custom_types/structs.md:54 msgid "\"point coordinates: ({}, {})\"" msgstr "\"点的坐标：({}, {})\"" #: src/custom_types/structs.md:56 msgid "" "// Make a new point by using struct update syntax to use the fields of our\n" " // other one\n" msgstr "" "// 使用结构体更新语法创建新的点，\n" " // 复用之前创建的点的字段\n" #: src/custom_types/structs.md:60 msgid "" "// `bottom_right.y` will be the same as `another_point.y` because we used " "that field\n" " // from `another_point`\n" msgstr "" "// `bottom_right.y` 与 `another_point.y` 相同，\n" " // 因为我们使用了 `another_point` 的该字段\n" #: src/custom_types/structs.md:62 msgid "\"second point: ({}, {})\"" msgstr "\"第二个点：({}, {})\"" #: src/custom_types/structs.md:64 msgid "// Destructure the point using a `let` binding\n" msgstr "// 使用 `let` 绑定解构点\n" #: src/custom_types/structs.md:68 msgid "// struct instantiation is an expression too\n" msgstr "// 结构体实例化也是一个表达式\n" #: src/custom_types/structs.md:73 msgid "// Instantiate a unit struct\n" msgstr "// 实例化一个单元结构体\n" #: src/custom_types/structs.md:76 msgid "// Instantiate a tuple struct\n" msgstr "// 实例化一个元组结构体\n" #: src/custom_types/structs.md:79 msgid "// Access the fields of a tuple struct\n" msgstr "// 访问元组结构体的字段\n" #: src/custom_types/structs.md:80 src/custom_types/structs.md:85 msgid "\"pair contains {:?} and {:?}\"" msgstr "\"pair 包含 {:?} 和 {:?}\"" #: src/custom_types/structs.md:82 msgid "// Destructure a tuple struct\n" msgstr "// 解构一个元组结构体\n" #: src/custom_types/structs.md:91 msgid "" "Add a function `rect_area` which calculates the area of a `Rectangle` (try " "using nested destructuring)." msgstr "" "添加一个 `rect_area` 函数来计算 `Rectangle` 的面积（尝试使用嵌套解构）。" #: src/custom_types/structs.md:93 msgid "" "Add a function `square` which takes a `Point` and a `f32` as arguments, and " "returns a `Rectangle` with its top left corner on the point, and a width and " "height corresponding to the `f32`." msgstr "" "添加一个 `square` 函数，它接受一个 `Point` 和一个 `f32` 作为参数，返回一个 " "`Rectangle`，其左上角在该点上，宽度和高度都等于 `f32` 参数。" #: src/custom_types/structs.md:97 msgid "See also" msgstr "另请参阅" #: src/custom_types/structs.md:99 msgid "" "[`attributes`](../attribute.md), [raw identifiers](../compatibility/" "raw_identifiers.md) and [destructuring](../flow_control/match/" "destructuring.md)" msgstr "" "[`属性`](../attribute.md)、[原始标识符](../compatibility/raw_identifiers.md)" "和[解构](../flow_control/match/destructuring.md)" #: src/custom_types/enum.md:3 msgid "" "The `enum` keyword allows the creation of a type which may be one of a few " "different variants. Any variant which is valid as a `struct` is also valid " "in an `enum`." msgstr "" "`enum` 关键字允许创建一个可能是几种不同变体之一的类型。任何作为 `struct` 有效" "的变体在 `enum` 中也是有效的。" #: src/custom_types/enum.md:8 msgid "" "// Create an `enum` to classify a web event. Note how both\n" "// names and type information together specify the variant:\n" "// `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.\n" "// Each is different and independent.\n" msgstr "" "// 创建一个 `enum` 来分类网页事件。注意名称和类型信息如何共同指定变体：\n" "// `PageLoad != PageUnload` 且 `KeyPress(char) != Paste(String)`。\n" "// 每个变体都是不同且独立的。\n" #: src/custom_types/enum.md:13 msgid "// An `enum` variant may either be `unit-like`,\n" msgstr "// `enum` 变体可以类似单元结构体（`unit-like`），\n" #: src/custom_types/enum.md:16 msgid "// like tuple structs,\n" msgstr "// 类似元组结构体，\n" #: src/custom_types/enum.md:19 msgid "// or c-like structures.\n" msgstr "// 或类似 C 语言的结构体。\n" #: src/custom_types/enum.md:22 msgid "" "// A function which takes a `WebEvent` enum as an argument and\n" "// returns nothing.\n" msgstr "// 一个接受 `WebEvent` 枚举作为参数且不返回任何值的函数。\n" #: src/custom_types/enum.md:27 msgid "\"page loaded\"" msgstr "\"页面已加载\"" #: src/custom_types/enum.md:28 msgid "\"page unloaded\"" msgstr "\"页面已卸载\"" #: src/custom_types/enum.md:29 msgid "// Destructure `c` from inside the `enum` variant.\n" msgstr "// 从 `enum` 变体内部解构 `c`。\n" #: src/custom_types/enum.md:30 msgid "\"pressed '{}'.\"" msgstr "\"按下了'{}'键。\"" #: src/custom_types/enum.md:31 msgid "\"pasted \\\"{}\\\".\"" msgstr "\"粘贴了\\\"{}\\\"。\"" #: src/custom_types/enum.md:32 msgid "// Destructure `Click` into `x` and `y`.\n" msgstr "// 将 `Click` 解构为 `x` 和 `y`。\n" #: src/custom_types/enum.md:34 msgid "\"clicked at x={}, y={}.\"" msgstr "\"点击坐标：x={}, y={}。\"" #: src/custom_types/enum.md:40 msgid "'x'" msgstr "'x'" #: src/custom_types/enum.md:41 msgid "// `to_owned()` creates an owned `String` from a string slice.\n" msgstr "// `to_owned()` 从字符串切片创建一个拥有所有权的 `String`。\n" #: src/custom_types/enum.md:42 msgid "\"my text\"" msgstr "\"我的文本\"" #: src/custom_types/enum.md:56 msgid "Type aliases" msgstr "类型别名" #: src/custom_types/enum.md:58 msgid "" "If you use a type alias, you can refer to each enum variant via its alias. " "This might be useful if the enum's name is too long or too generic, and you " "want to rename it." msgstr "" "使用类型别名可以通过别名引用每个枚举变体。当枚举名称过长或过于泛化，而你想重" "命名它时，这会很有用。" #: src/custom_types/enum.md:67 msgid "// Creates a type alias\n" msgstr "// 创建类型别名\n" #: src/custom_types/enum.md:72 msgid "" "// We can refer to each variant via its alias, not its long and " "inconvenient\n" " // name.\n" msgstr "// 我们可以通过别名引用每个变体，而不是使用又长又不便的名称。\n" #: src/custom_types/enum.md:78 msgid "" "The most common place you'll see this is in `impl` blocks using the `Self` " "alias." msgstr "你最常见到这种用法的地方是在使用 `Self` 别名的 `impl` 块中。" #: src/custom_types/enum.md:96 msgid "" "To learn more about enums and type aliases, you can read the [stabilization " "report](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847) from when this feature was stabilized into Rust." msgstr "" "要了解更多关于枚举和类型别名的信息，你可以阅读这个特性被稳定到 Rust 时的[稳定" "化报告](https://github.com/rust-lang/rust/pull/61682/" "#issuecomment-502472847)。" #: src/custom_types/enum.md:102 msgid "" "[`match`](../flow_control/match.md), [`fn`](../fn.md), and [`String`](../std/" "str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/rfcs/" "2338-type-alias-enum-variants.html)" msgstr "" "[`match`](../flow_control/match.md)、[`fn`](../fn.md)、[`String`](../std/" "str.md) 和 [\"类型别名枚举变体\" RFC](https://rust-lang.github.io/rfcs/2338-" "type-alias-enum-variants.html)" #: src/custom_types/enum/enum_use.md:3 msgid "The `use` declaration can be used so manual scoping isn't needed:" msgstr "`use` 声明可以用来避免手动作用域限定：" #: src/custom_types/enum/enum_use.md:20 msgid "" "// Explicitly `use` each name so they are available without\n" " // manual scoping.\n" msgstr "" "// 显式 `use` 每个名称，使它们可以不需要\n" " // 手动作用域限定就能使用。\n" #: src/custom_types/enum/enum_use.md:23 msgid "// Automatically `use` each name inside `Role`.\n" msgstr "// 自动 `use` `Role` 内的每个名称。\n" #: src/custom_types/enum/enum_use.md:26 msgid "// Equivalent to `Stage::Beginner`.\n" msgstr "// 等同于 `Stage::Beginner`。\n" #: src/custom_types/enum/enum_use.md:28 msgid "// Equivalent to `Role::Student`.\n" msgstr "// 等同于 `Role::Student`。\n" #: src/custom_types/enum/enum_use.md:32 msgid "// Note the lack of scoping because of the explicit `use` above.\n" msgstr "// 注意由于上面的显式 `use`，这里不需要作用域限定。\n" #: src/custom_types/enum/enum_use.md:33 msgid "\"Beginners are starting their learning journey!\"" msgstr "\"初学者正在开始他们的学习之旅！\"" #: src/custom_types/enum/enum_use.md:34 msgid "\"Advanced learners are mastering their subjects...\"" msgstr "\"高级学习者正在掌握他们的科目...\"" #: src/custom_types/enum/enum_use.md:38 msgid "// Note again the lack of scoping.\n" msgstr "// 再次注意这里不需要作用域限定。\n" #: src/custom_types/enum/enum_use.md:39 msgid "\"Students are acquiring knowledge!\"" msgstr "\"学生正在获取知识！\"" #: src/custom_types/enum/enum_use.md:40 msgid "\"Teachers are spreading knowledge!\"" msgstr "\"教师正在传播知识！\"" #: src/custom_types/enum/enum_use.md:47 msgid "[`match`](../../flow_control/match.md) and [`use`](../../mod/use.md)" msgstr "[`match`](../../flow_control/match.md) 和 [`use`](../../mod/use.md)" #: src/custom_types/enum/c_like.md:3 msgid "`enum` can also be used as C-like enums." msgstr "`enum` 也可以像 C 语言那样使用。" #: src/custom_types/enum/c_like.md:8 msgid "// enum with implicit discriminator (starts at 0)\n" msgstr "// 带隐式判别值的枚举（从 0 开始）\n" #: src/custom_types/enum/c_like.md:15 msgid "// enum with explicit discriminator\n" msgstr "// 带显式判别值的枚举\n" #: src/custom_types/enum/c_like.md:24 msgid "// `enums` can be cast as integers.\n" msgstr "// `enum` 可以转换为整数。\n" #: src/custom_types/enum/c_like.md:25 msgid "\"zero is {}\"" msgstr "\"zero 的值是 {}\"" #: src/custom_types/enum/c_like.md:26 msgid "\"one is {}\"" msgstr "\"one 的值是 {}\"" #: src/custom_types/enum/c_like.md:28 msgid "\"roses are #{:06x}\"" msgstr "\"玫瑰的颜色是 #{:06x}\"" #: src/custom_types/enum/c_like.md:29 msgid "\"violets are #{:06x}\"" msgstr "\"紫罗兰的颜色是 #{:06x}\"" #: src/custom_types/enum/c_like.md:35 msgid "[casting](../../types/cast.md)" msgstr "[类型转换](../../types/cast.md)" #: src/custom_types/enum/testcase_linked_list.md:3 msgid "A common way to implement a linked-list is via `enums`:" msgstr "使用 `enum` 是实现链表的常见方法：" #: src/custom_types/enum/testcase_linked_list.md:9 msgid "" "// Cons: Tuple struct that wraps an element and a pointer to the next node\n" msgstr "// Cons：包含一个元素和指向下一节点指针的元组结构体\n" #: src/custom_types/enum/testcase_linked_list.md:11 msgid "// Nil: A node that signifies the end of the linked list\n" msgstr "// Nil：表示链表末尾的节点\n" #: src/custom_types/enum/testcase_linked_list.md:14 msgid "// Methods can be attached to an enum\n" msgstr "// 可以为枚举实现方法\n" #: src/custom_types/enum/testcase_linked_list.md:17 msgid "// Create an empty list\n" msgstr "// 创建空链表\n" #: src/custom_types/enum/testcase_linked_list.md:19 msgid "// `Nil` has type `List`\n" msgstr "// `Nil` 的类型是 `List`\n" #: src/custom_types/enum/testcase_linked_list.md:23 msgid "" "// Consume a list, and return the same list with a new element at its front\n" msgstr "// 消耗一个链表，并返回在其头部添加新元素后的链表\n" #: src/custom_types/enum/testcase_linked_list.md:25 msgid "// `Cons` also has type List\n" msgstr "// `Cons` 的类型也是 List\n" #: src/custom_types/enum/testcase_linked_list.md:29 msgid "// Return the length of the list\n" msgstr "// 返回链表长度\n" #: src/custom_types/enum/testcase_linked_list.md:31 msgid "" "// `self` has to be matched, because the behavior of this method\n" " // depends on the variant of `self`\n" " // `self` has type `&List`, and `*self` has type `List`, matching on " "a\n" " // concrete type `T` is preferred over a match on a reference `&T`\n" " // after Rust 2018 you can use self here and tail (with no ref) " "below as well,\n" " // rust will infer &s and ref tail.\n" " // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" msgstr "" "// 需要对 `self` 进行匹配，因为方法的行为取决于 `self` 的变体\n" " // `self` 的类型是 `&List`，而 `*self` 的类型是 `List`\n" " // 匹配具体类型 `T` 优于匹配引用 `&T`\n" " // 在 Rust 2018 版本后，这里可以直接使用 self，下面可以使用 tail（无" "需 ref）\n" " // Rust 会自动推断为 &s 和 ref tail\n" " // 参见 https://doc.rust-lang.org/edition-guide/rust-2018/ownership-" "and-lifetimes/default-match-bindings.html\n" #: src/custom_types/enum/testcase_linked_list.md:39 msgid "" "// Can't take ownership of the tail, because `self` is borrowed;\n" " // instead take a reference to the tail\n" " // And it'a a non-tail recursive call which may cause stack " "overflow for long lists.\n" msgstr "" "// 无法获取 tail 的所有权，因为 `self` 是借用的；\n" " // 所以取 tail 的引用\n" " // 这是一个非尾递归调用，对于长列表可能导致栈溢出。\n" #: src/custom_types/enum/testcase_linked_list.md:43 msgid "// Base Case: An empty list has zero length\n" msgstr "// 基本情况：空链表长度为零\n" #: src/custom_types/enum/testcase_linked_list.md:48 msgid "// Return representation of the list as a (heap allocated) string\n" msgstr "// 返回链表的字符串表示（堆分配）\n" #: src/custom_types/enum/testcase_linked_list.md:52 msgid "" "// `format!` is similar to `print!`, but returns a heap\n" " // allocated string instead of printing to the console\n" msgstr "" "// `format!` 类似于 `print!`，但返回堆分配的字符串，\n" " // 而不是打印到控制台\n" #: src/custom_types/enum/testcase_linked_list.md:54 src/generics/impl.md:44 msgid "\"{}, {}\"" msgstr "\"{}, {}\"" #: src/custom_types/enum/testcase_linked_list.md:57 msgid "\"Nil\"" msgstr "\"Nil\"" #: src/custom_types/enum/testcase_linked_list.md:64 msgid "// Create an empty linked list\n" msgstr "// 创建空链表\n" #: src/custom_types/enum/testcase_linked_list.md:67 msgid "// Prepend some elements\n" msgstr "// 在头部添加一些元素\n" #: src/custom_types/enum/testcase_linked_list.md:72 msgid "// Show the final state of the list\n" msgstr "// 显示链表的最终状态\n" #: src/custom_types/enum/testcase_linked_list.md:73 msgid "\"linked list has length: {}\"" msgstr "\"链表长度为：{}\"" #: src/custom_types/enum/testcase_linked_list.md:80 msgid "[`Box`](../../std/box.md) and [methods](../../fn/methods.md)" msgstr "[`Box`](../../std/box.md) 和[方法](../../fn/methods.md)" #: src/custom_types/constants.md:3 msgid "" "Rust has two different types of constants which can be declared in any scope " "including global. Both require explicit type annotation:" msgstr "" "Rust 有两种常量类型，可以在任何作用域（包括全局作用域）中声明。两者都需要显式" "类型标注：" #: src/custom_types/constants.md:6 msgid "`const`: An unchangeable value (the common case)." msgstr "`const`：不可变值（常见用法）。" #: src/custom_types/constants.md:7 msgid "" "`static`: A possibly mutable variable with [`'static`](../scope/lifetime/" "static_lifetime.md) lifetime. The static lifetime is inferred and does not " "have to be specified. Accessing or modifying a mutable static variable is " "[`unsafe`](../unsafe.md)." msgstr "" "`static`：具有 [`'static`](../scope/lifetime/static_lifetime.md) 生命周期的可" "能可变变量。静态生命周期会被自动推断，无需明确指定。访问或修改可变静态变量是 " "[`unsafe`](../unsafe.md) 的。" #: src/custom_types/constants.md:12 msgid "// Globals are declared outside all other scopes.\n" msgstr "// 全局变量在所有其他作用域之外声明。\n" #: src/custom_types/constants.md:13 msgid "\"Rust\"" msgstr "\"Rust\"" #: src/custom_types/constants.md:17 msgid "// Access constant in some function\n" msgstr "// 在函数中访问常量\n" #: src/custom_types/constants.md:24 msgid "// Access constant in the main thread\n" msgstr "// 在主线程中访问常量\n" #: src/custom_types/constants.md:25 msgid "\"This is {}\"" msgstr "\"这是 {}\"" #: src/custom_types/constants.md:26 msgid "\"The threshold is {}\"" msgstr "\"阈值为 {}\"" #: src/custom_types/constants.md:27 msgid "\"{} is {}\"" msgstr "\"{} 是 {}\"" #: src/custom_types/constants.md:27 msgid "\"big\"" msgstr "\"大的\"" #: src/custom_types/constants.md:27 msgid "\"small\"" msgstr "\"小的\"" #: src/custom_types/constants.md:29 msgid "// Error! Cannot modify a `const`.\n" msgstr "// 错误！不能修改 `const`。\n" #: src/custom_types/constants.md:31 src/variable_bindings/scope.md:22 #: src/variable_bindings/declare.md:27 src/variable_bindings/freeze.md:16 #: src/types/cast.md:19 src/types/cast.md:28 src/flow_control/for.md:95 #: src/scope/borrow.md:41 src/scope/borrow/mut.md:52 src/std/vec.md:32 #: src/std/vec.md:45 src/std/hash/hashset.md:48 msgid "// FIXME ^ Comment out this line\n" msgstr "// 修复：^ 注释掉此行\n" #: src/custom_types/constants.md:37 msgid "" "[The `const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/" "text/0246-const-vs-static.md), [`'static` lifetime](../scope/lifetime/" "static_lifetime.md)" msgstr "" "[`const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/text/" "0246-const-vs-static.md)，[`'static` 生命周期](../scope/lifetime/" "static_lifetime.md)" #: src/variable_bindings.md:3 msgid "" "Rust provides type safety via static typing. Variable bindings can be type " "annotated when declared. However, in most cases, the compiler will be able " "to infer the type of the variable from the context, heavily reducing the " "annotation burden." msgstr "" "Rust 通过静态类型提供类型安全。变量绑定在声明时可以添加类型注解。然而，在大多" "数情况下，编译器能够从上下文推断出变量类型，大大减少了类型注解的负担。" #: src/variable_bindings.md:8 msgid "" "Values (like literals) can be bound to variables, using the `let` binding." msgstr "可以使用 `let` 关键字将值（如字面量）绑定到变量。" #: src/variable_bindings.md:16 msgid "// copy `an_integer` into `copied_integer`\n" msgstr "// 将 `an_integer` 复制到 `copied_integer`\n" #: src/variable_bindings.md:19 msgid "\"An integer: {:?}\"" msgstr "\"整数：{:?}\"" #: src/variable_bindings.md:20 msgid "\"A boolean: {:?}\"" msgstr "\"布尔值：{:?}\"" #: src/variable_bindings.md:21 msgid "\"Meet the unit value: {:?}\"" msgstr "\"单元值：{:?}\"" #: src/variable_bindings.md:23 msgid "" "// The compiler warns about unused variable bindings; these warnings can\n" " // be silenced by prefixing the variable name with an underscore\n" msgstr "" "// 编译器会对未使用的变量绑定发出警告\n" " // 可以通过在变量名前加下划线来消除这些警告\n" #: src/variable_bindings.md:28 msgid "" "// FIXME ^ Prefix with an underscore to suppress the warning\n" " // Please note that warnings may not be shown in a browser\n" msgstr "" "// 修复：^ 在变量名前加下划线以消除警告\n" " // 注意：在浏览器中可能不会显示警告\n" #: src/variable_bindings/mut.md:3 msgid "" "Variable bindings are immutable by default, but this can be overridden using " "the `mut` modifier." msgstr "变量绑定默认是不可变的，但可以使用 `mut` 修饰符来改变这一行为。" #: src/variable_bindings/mut.md:11 msgid "\"Before mutation: {}\"" msgstr "\"修改前：{}\"" #: src/variable_bindings/mut.md:13 msgid "// Ok\n" msgstr "// 正确\n" #: src/variable_bindings/mut.md:16 msgid "\"After mutation: {}\"" msgstr "\"修改后：{}\"" #: src/variable_bindings/mut.md:18 msgid "// Error! Cannot assign a new value to an immutable variable\n" msgstr "// 错误！不能给不可变变量赋新值\n" #: src/variable_bindings/mut.md:23 msgid "The compiler will throw a detailed diagnostic about mutability errors." msgstr "编译器会对可变性错误给出详细的诊断信息。" #: src/variable_bindings/scope.md:3 msgid "" "Variable bindings have a scope, and are constrained to live in a _block_. A " "block is a collection of statements enclosed by braces `{}`." msgstr "" "变量绑定有作用域，它们被限制在一个**代码块**中生存。代码块是由花括号 `{}` 包" "围的一系列语句。" #: src/variable_bindings/scope.md:8 msgid "// This binding lives in the main function\n" msgstr "// 这个绑定存在于 main 函数中\n" #: src/variable_bindings/scope.md:11 msgid "// This is a block, and has a smaller scope than the main function\n" msgstr "// 这是一个代码块，它的作用域比 main 函数小\n" #: src/variable_bindings/scope.md:13 msgid "// This binding only exists in this block\n" msgstr "// 这个绑定只存在于此代码块中\n" #: src/variable_bindings/scope.md:16 msgid "\"inner short: {}\"" msgstr "\"内部 short：{}\"" #: src/variable_bindings/scope.md:18 msgid "// End of the block\n" msgstr "// 代码块结束\n" #: src/variable_bindings/scope.md:20 msgid "// Error! `short_lived_binding` doesn't exist in this scope\n" msgstr "// 错误！`short_lived_binding` 在此作用域中不存在\n" #: src/variable_bindings/scope.md:21 msgid "\"outer short: {}\"" msgstr "\"外部 short：{}\"" #: src/variable_bindings/scope.md:24 msgid "\"outer long: {}\"" msgstr "\"外部 long：{}\"" #: src/variable_bindings/scope.md:28 msgid "" "Also, [variable shadowing](https://en.wikipedia.org/wiki/Variable_shadowing) " "is allowed." msgstr "" "此外，Rust 允许[变量遮蔽](https://en.wikipedia.org/wiki/Variable_shadowing)。" #: src/variable_bindings/scope.md:35 msgid "\"before being shadowed: {}\"" msgstr "\"被遮蔽前：{}\"" #: src/variable_bindings/scope.md:37 msgid "// This binding *shadows* the outer one\n" msgstr "// 这个绑定*遮蔽*了外部的绑定\n" #: src/variable_bindings/scope.md:38 msgid "\"abc\"" msgstr "\"abc\"" #: src/variable_bindings/scope.md:40 msgid "\"shadowed in inner block: {}\"" msgstr "\"内部代码块中被遮蔽：{}\"" #: src/variable_bindings/scope.md:42 msgid "\"outside inner block: {}\"" msgstr "\"内部代码块外：{}\"" #: src/variable_bindings/scope.md:44 msgid "// This binding *shadows* the previous binding\n" msgstr "// 这个绑定*遮蔽*了之前的绑定\n" #: src/variable_bindings/scope.md:46 msgid "\"shadowed in outer block: {}\"" msgstr "\"外部代码块中被遮蔽：{}\"" #: src/variable_bindings/declare.md:3 msgid "" "It is possible to declare variable bindings first and initialize them later, " "but all variable bindings must be initialized before they are used: the " "compiler forbids use of uninitialized variable bindings, as it would lead to " "undefined behavior." msgstr "" "可以先声明变量绑定然后再初始化，但所有变量绑定在使用前必须先初始化：编译器禁" "止使用未初始化的变量绑定，因为这会导致未定义行为。" #: src/variable_bindings/declare.md:5 msgid "" "It is not common to declare a variable binding and initialize it later in " "the function. It is more difficult for a reader to find the initialization " "when initialization is separated from declaration. It is common to declare " "and initialize a variable binding near where the variable will be used." msgstr "" "在函数中先声明变量绑定而稍后再初始化的做法并不常见。当初始化与声明分离时，读" "者更难找到初始化的位置。更常见的做法是在变量即将使用的地方附近声明并初始化变" "量绑定。" #: src/variable_bindings/declare.md:11 msgid "// Declare a variable binding\n" msgstr "// 声明一个变量绑定\n" #: src/variable_bindings/declare.md:17 msgid "// Initialize the binding\n" msgstr "// 初始化绑定\n" #: src/variable_bindings/declare.md:21 msgid "\"a binding: {}\"" msgstr "\"绑定：{}\"" #: src/variable_bindings/declare.md:25 msgid "// Error! Use of uninitialized binding\n" msgstr "// 错误！使用未初始化的绑定\n" #: src/variable_bindings/declare.md:26 src/variable_bindings/declare.md:31 msgid "\"another binding: {}\"" msgstr "\"另一个绑定：{}\"" #: src/variable_bindings/freeze.md:3 msgid "" "When data is bound by the same name immutably, it also _freezes_. _Frozen_ " "data can't be modified until the immutable binding goes out of scope:" msgstr "" "当数据以相同名称被不可变地绑定时，它也会**冻结**。被冻结的数据在不可变绑定离" "开作用域之前不能被修改：" #: src/variable_bindings/freeze.md:11 msgid "// Shadowing by immutable `_mutable_integer`\n" msgstr "// 通过不可变的 `_mutable_integer` 进行遮蔽\n" #: src/variable_bindings/freeze.md:14 msgid "// Error! `_mutable_integer` is frozen in this scope\n" msgstr "// 错误！`_mutable_integer` 在此作用域中被冻结\n" #: src/variable_bindings/freeze.md:18 msgid "// `_mutable_integer` goes out of scope\n" msgstr "// `_mutable_integer` 离开作用域\n" #: src/variable_bindings/freeze.md:21 msgid "// Ok! `_mutable_integer` is not frozen in this scope\n" msgstr "// 正确！`_mutable_integer` 在此作用域中未被冻结\n" #: src/types.md:3 msgid "" "Rust provides several mechanisms to change or define the type of primitive " "and user defined types. The following sections cover:" msgstr "" "Rust 提供了几种机制来更改或定义原生类型和用户定义类型。以下部分将介绍：" #: src/types.md:6 msgid "[Casting](types/cast.md) between primitive types" msgstr "原生类型之间的[类型转换](types/cast.md)" #: src/types.md:7 msgid "Specifying the desired type of [literals](types/literals.md)" msgstr "指定[字面量](types/literals.md)的类型" #: src/types.md:8 msgid "Using [type inference](types/inference.md)" msgstr "使用[类型推断](types/inference.md)" #: src/types.md:9 msgid "[Aliasing](types/alias.md) types" msgstr "类型[别名](types/alias.md)" #: src/types/cast.md:3 msgid "" "Rust provides no implicit type conversion (coercion) between primitive " "types. But, explicit type conversion (casting) can be performed using the " "`as` keyword." msgstr "" "Rust 不支持原始类型之间的隐式类型转换（强制转换）。但可以使用 `as` 关键字进行" "显式类型转换（转型）。" #: src/types/cast.md:6 msgid "" "Rules for converting between integral types follow C conventions generally, " "except in cases where C has undefined behavior. The behavior of all casts " "between integral types is well defined in Rust." msgstr "" "整数类型之间的转换规则通常遵循 C 语言惯例，但 C 中存在未定义行为的情况除外。" "在 Rust 中，所有整数类型之间的转换行为都有明确定义。" #: src/types/cast.md:11 msgid "// Suppress all warnings from casts which overflow.\n" msgstr "// 抑制所有由溢出转换引起的警告。\n" #: src/types/cast.md:17 msgid "// Error! No implicit conversion\n" msgstr "// 错误！不允许隐式转换\n" #: src/types/cast.md:21 msgid "// Explicit conversion\n" msgstr "// 显式转换\n" #: src/types/cast.md:25 msgid "" "// Error! There are limitations in conversion rules.\n" " // A float cannot be directly converted to a char.\n" msgstr "" "// 错误！转换规则有限制。\n" " // 浮点数不能直接转换为字符。\n" #: src/types/cast.md:30 msgid "\"Casting: {} -> {} -> {}\"" msgstr "\"类型转换：{} -> {} -> {}\"" #: src/types/cast.md:32 msgid "" "// when casting any value to an unsigned type, T,\n" " // T::MAX + 1 is added or subtracted until the value\n" " // fits into the new type\n" msgstr "" "// 当将任何值转换为无符号类型 T 时，\n" " // 会反复加上或减去 T::MAX + 1，直到该值\n" " // 适合新类型\n" #: src/types/cast.md:36 msgid "// 1000 already fits in a u16\n" msgstr "// 1000 已经适合 u16\n" #: src/types/cast.md:37 msgid "\"1000 as a u16 is: {}\"" msgstr "\"1000 转换为 u16 是：{}\"" #: src/types/cast.md:39 msgid "" "// 1000 - 256 - 256 - 256 = 232\n" " // Under the hood, the first 8 least significant bits (LSB) are kept,\n" " // while the rest towards the most significant bit (MSB) get truncated.\n" msgstr "" "// 1000 - 256 - 256 - 256 = 232\n" " // 实际上，保留了最低有效位（LSB）的前 8 位，\n" " // 而朝最高有效位（MSB）方向的其余位被截断。\n" #: src/types/cast.md:42 src/types/cast.md:61 msgid "\"1000 as a u8 is : {}\"" msgstr "\"1000 转换为 u8 是：{}\"" #: src/types/cast.md:43 msgid "// -1 + 256 = 255\n" msgstr "// -1 + 256 = 255\n" #: src/types/cast.md:44 msgid "\" -1 as a u8 is : {}\"" msgstr "\" -1 转换为 u8 是：{}\"" #: src/types/cast.md:46 msgid "// For positive numbers, this is the same as the modulus\n" msgstr "// 对于正数，这等同于取模运算\n" #: src/types/cast.md:47 msgid "\"1000 mod 256 is : {}\"" msgstr "\"1000 对 256 取模是：{}\"" #: src/types/cast.md:49 msgid "" "// When casting to a signed type, the (bitwise) result is the same as\n" " // first casting to the corresponding unsigned type. If the most " "significant\n" " // bit of that value is 1, then the value is negative.\n" msgstr "" "// 当转换为有符号类型时，（按位）结果等同于\n" " // 先转换为对应的无符号类型。如果该值的最高有效位\n" " // 为 1，则该值为负数。\n" #: src/types/cast.md:53 msgid "// Unless it already fits, of course.\n" msgstr "// 当然，如果已经适合的话就不需要转换。\n" #: src/types/cast.md:54 msgid "\" 128 as a i16 is: {}\"" msgstr "\" 128 转换为 i16 是：{}\"" #: src/types/cast.md:56 msgid "" "// In boundary case 128 value in 8-bit two's complement representation is " "-128\n" msgstr "// 边界情况：128 在 8 位二进制补码表示中为 -128\n" #: src/types/cast.md:57 msgid "\" 128 as a i8 is : {}\"" msgstr "\" 128 转换为 i8 是：{}\"" #: src/types/cast.md:59 msgid "" "// repeating the example above\n" " // 1000 as u8 -> 232\n" msgstr "" "// 重复上面的例子\n" " // 1000 转换为 u8 -> 232\n" #: src/types/cast.md:62 msgid "" "// and the value of 232 in 8-bit two's complement representation is -24\n" msgstr "// 而 232 在 8 位二进制补码表示中为 -24\n" #: src/types/cast.md:63 msgid "\" 232 as a i8 is : {}\"" msgstr "\" 232 转换为 i8 是：{}\"" #: src/types/cast.md:65 msgid "" "// Since Rust 1.45, the `as` keyword performs a *saturating cast*\n" " // when casting from float to int. If the floating point value exceeds\n" " // the upper bound or is less than the lower bound, the returned value\n" " // will be equal to the bound crossed.\n" msgstr "" "// 从 Rust 1.45 开始，`as` 关键字在浮点数转整数时执行*饱和转换*\n" " // 如果浮点值超出上界或低于下界，返回值\n" " // 将等于所越过的边界值。\n" #: src/types/cast.md:70 msgid "// 300.0 as u8 is 255\n" msgstr "// 300.0 转换为 u8 是 255\n" #: src/types/cast.md:71 src/types/cast.md:82 msgid "\" 300.0 as u8 is : {}\"" msgstr "\" 300.0 转换为 u8 是：{}\"" #: src/types/cast.md:72 msgid "// -100.0 as u8 is 0\n" msgstr "// -100.0 转换为 u8 是 0\n" #: src/types/cast.md:73 src/types/cast.md:84 msgid "\"-100.0 as u8 is : {}\"" msgstr "\"-100.0 转换为 u8 是：{}\"" #: src/types/cast.md:74 src/types/cast.md:85 msgid "// nan as u8 is 0\n" msgstr "// NaN 转换为 u8 是 0\n" #: src/types/cast.md:75 src/types/cast.md:86 msgid "\" nan as u8 is : {}\"" msgstr "\" NaN 转换为 u8 是：{}\"" #: src/types/cast.md:77 msgid "" "// This behavior incurs a small runtime cost and can be avoided\n" " // with unsafe methods, however the results might overflow and\n" " // return **unsound values**. Use these methods wisely:\n" msgstr "" "// 这种行为会产生少量运行时开销，可以通过不安全方法避免，\n" " // 但结果可能溢出并返回**不可靠的值**。请谨慎使用这些方法：\n" #: src/types/cast.md:81 msgid "// 300.0 as u8 is 44\n" msgstr "// 300.0 转换为 u8 是 44\n" #: src/types/cast.md:83 msgid "// -100.0 as u8 is 156\n" msgstr "// -100.0 转换为 u8 是 156\n" #: src/types/literals.md:3 msgid "" "Numeric literals can be type annotated by adding the type as a suffix. As an " "example, to specify that the literal `42` should have the type `i32`, write " "`42i32`." msgstr "" "数字字面值可以通过添加类型后缀进行类型标注。例如，要指定字面值 `42` 的类型为 " "`i32`，可以写成 `42i32`。" #: src/types/literals.md:6 msgid "" "The type of unsuffixed numeric literals will depend on how they are used. If " "no constraint exists, the compiler will use `i32` for integers, and `f64` " "for floating-point numbers." msgstr "" "无后缀数字字面值的类型取决于其使用方式。如果没有约束，编译器将对整数使用 " "`i32`，对浮点数使用 `f64`。" #: src/types/literals.md:12 msgid "// Suffixed literals, their types are known at initialization\n" msgstr "// 带后缀的字面值，其类型在初始化时确定\n" #: src/types/literals.md:17 msgid "// Unsuffixed literals, their types depend on how they are used\n" msgstr "// 无后缀的字面值，其类型取决于使用方式\n" #: src/types/literals.md:21 msgid "// `size_of_val` returns the size of a variable in bytes\n" msgstr "// `size_of_val` 返回变量的字节大小\n" #: src/types/literals.md:22 msgid "\"size of `x` in bytes: {}\"" msgstr "\"`x` 的字节大小：{}\"" #: src/types/literals.md:23 msgid "\"size of `y` in bytes: {}\"" msgstr "\"`y` 的字节大小：{}\"" #: src/types/literals.md:24 msgid "\"size of `z` in bytes: {}\"" msgstr "\"`z` 的字节大小：{}\"" #: src/types/literals.md:25 msgid "\"size of `i` in bytes: {}\"" msgstr "\"`i` 的字节大小：{}\"" #: src/types/literals.md:26 msgid "\"size of `f` in bytes: {}\"" msgstr "\"`f` 的字节大小：{}\"" #: src/types/literals.md:30 msgid "" "There are some concepts used in the previous code that haven't been " "explained yet, here's a brief explanation for the impatient readers:" msgstr "" "前面的代码中使用了一些尚未解释的概念。为了满足迫不及待的读者，这里简要说明如" "下：" #: src/types/literals.md:33 msgid "" "`std::mem::size_of_val` is a function, but called with its _full path_. Code " "can be split in logical units called _modules_. In this case, the " "`size_of_val` function is defined in the `mem` module, and the `mem` module " "is defined in the `std` _crate_. For more details, see [modules](../mod.md) " "and [crates](../crates.md)." msgstr "" "`std::mem::size_of_val` 是一个函数，这里使用了它的\"完整路径\"来调用。代码可" "以被划分为称为\"模块\"的逻辑单元。在这个例子中，`size_of_val` 函数定义在 " "`mem` 模块中，而 `mem` 模块则定义在 `std` crate 中。更多详情请参阅[模块](../" "mod.md)和[crate](../crates.md)。" #: src/types/inference.md:3 msgid "" "The type inference engine is pretty smart. It does more than looking at the " "type of the value expression during an initialization. It also looks at how " "the variable is used afterwards to infer its type. Here's an advanced " "example of type inference:" msgstr "" "类型推断引擎相当智能。它不仅在初始化时分析值表达式的类型，还会根据变量后续的" "使用方式来推断其类型。下面是一个类型推断的高级示例：" #: src/types/inference.md:10 msgid "" "// Because of the annotation, the compiler knows that `elem` has type u8.\n" msgstr "// 通过类型注解，编译器得知 `elem` 的类型为 u8 \n" #: src/types/inference.md:13 msgid "// Create an empty vector (a growable array).\n" msgstr "// 创建一个空向量（可增长的数组）\n" #: src/types/inference.md:15 msgid "" "// At this point the compiler doesn't know the exact type of `vec`, it\n" " // just knows that it's a vector of something (`Vec<_>`).\n" msgstr "" "// 此时编译器还不知道 `vec` 的具体类型，\n" " // 只知道它是某种类型的向量（`Vec<_>`）。\n" #: src/types/inference.md:18 msgid "// Insert `elem` in the vector.\n" msgstr "// 将 `elem` 插入向量中\n" #: src/types/inference.md:20 msgid "" "// Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec`)\n" " // TODO ^ Try commenting out the `vec.push(elem)` line\n" msgstr "" "// 啊哈！现在编译器知道 `vec` 是 `u8` 类型的向量（`Vec`）\n" " // TODO ^ 尝试注释掉 `vec.push(elem)` 这一行\n" #: src/types/inference.md:27 msgid "" "No type annotation of variables was needed, the compiler is happy and so is " "the programmer!" msgstr "无需为变量添加类型注解，编译器和程序员都很满意！" #: src/types/alias.md:3 msgid "" "The `type` statement can be used to give a new name to an existing type. " "Types must have `UpperCamelCase` names, or the compiler will raise a " "warning. The exception to this rule are the primitive types: `usize`, `f32`, " "etc." msgstr "" "`type` 语句用于为现有类型创建新名称。类型名必须使用 `UpperCamelCase`（大驼" "峰）命名，否则编译器会发出警告。此规则的例外是原始类型，如 `usize`、`f32` " "等。" #: src/types/alias.md:8 msgid "// `NanoSecond`, `Inch`, and `U64` are new names for `u64`.\n" msgstr "// `NanoSecond`、`Inch` 和 `U64` 都是 `u64` 的新名称。\n" #: src/types/alias.md:14 msgid "// `NanoSecond` = `Inch` = `U64` = `u64`.\n" msgstr "// `NanoSecond` = `Inch` = `U64` = `u64`。\n" #: src/types/alias.md:18 msgid "" "// Note that type aliases *don't* provide any extra type safety, because\n" " // aliases are *not* new types\n" msgstr "// 注意，类型别名*不会*提供额外的类型安全性，因为别名*不是*新类型\n" #: src/types/alias.md:20 msgid "\"{} nanoseconds + {} inches = {} unit?\"" msgstr "\"{} 纳秒 + {} 英寸 = {} 单位？\"" #: src/types/alias.md:27 msgid "" "The main use of aliases is to reduce boilerplate; for example the " "`io::Result` type is an alias for the `Result` type." msgstr "" "别名的主要用途是减少重复代码。例如，`io::Result` 类型是 `Result` 类型的别名。" #: src/types/alias.md:32 msgid "[Attributes](../attribute.md)" msgstr "[属性](../attribute.md)" #: src/conversion.md:3 msgid "" "Primitive types can be converted to each other through [casting](types/" "cast.md)." msgstr "原始类型可以通过[类型转换](types/cast.md)相互转换。" #: src/conversion.md:5 msgid "" "Rust addresses conversion between custom types (i.e., `struct` and `enum`) " "by the use of [traits](trait.md). The generic conversions will use the " "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`Into`]" "(https://doc.rust-lang.org/std/convert/trait.Into.html) traits. However " "there are more specific ones for the more common cases, in particular when " "converting to and from `String`s." msgstr "" "Rust 通过使用[特质](trait.md)来处理自定义类型（如 `struct` 和 `enum`）之间的" "转换。通用转换使用 [`From`](https://doc.rust-lang.org/std/convert/" "trait.From.html) 和 [`Into`](https://doc.rust-lang.org/std/convert/" "trait.Into.html) 特质。然而，对于更常见的情况，特别是与 `String` 相互转换时，" "还有一些更具体的特质。" #: src/conversion/from_into.md:3 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) traits are " "inherently linked, and this is actually part of its implementation. If you " "are able to convert type A from type B, then it should be easy to believe " "that we should be able to convert type B to type A." msgstr "" "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) 和 [`Into`]" "(https://doc.rust-lang.org/std/convert/trait.Into.html) 特质本质上是相互关联" "的，这实际上是其实现的一部分。如果你能将类型 A 从类型 B 转换，那么我们也应该" "能够将类型 B 转换为类型 A。" #: src/conversion/from_into.md:7 msgid "`From`" msgstr "`From`" #: src/conversion/from_into.md:9 msgid "" "The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) trait " "allows for a type to define how to create itself from another type, hence " "providing a very simple mechanism for converting between several types. " "There are numerous implementations of this trait within the standard library " "for conversion of primitive and common types." msgstr "" "[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) 特质允许一个" "类型定义如何从另一个类型创建自身，从而提供了一种非常简单的机制来在多种类型之" "间进行转换。标准库中有许多这个特质的实现，用于原始类型和常见类型的转换。" #: src/conversion/from_into.md:14 msgid "For example we can easily convert a `str` into a `String`" msgstr "例如，我们可以轻松地将 `str` 转换为 `String`" #: src/conversion/from_into.md:21 msgid "We can do something similar for defining a conversion for our own type." msgstr "我们可以为自己的类型定义类似的转换。" #: src/conversion/from_into.md:39 src/conversion/from_into.md:68 #: src/conversion/from_into.md:98 msgid "\"My number is {:?}\"" msgstr "\"我的数字是 {:?}\"" #: src/conversion/from_into.md:43 msgid "`Into`" msgstr "`Into`" #: src/conversion/from_into.md:45 msgid "" "The [`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) trait is " "simply the reciprocal of the `From` trait. It defines how to convert a type " "into another type." msgstr "" "[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) 特质简单来说" "就是 `From` 特质的反向操作。它定义了如何将一个类型转换为另一个类型。" #: src/conversion/from_into.md:48 msgid "" "Calling `into()` typically requires us to specify the result type as the " "compiler is unable to determine this most of the time." msgstr "" "调用 `into()` 通常需要我们指定结果类型，因为编译器大多数时候无法确定这一点。" #: src/conversion/from_into.md:66 msgid "// Try removing the type annotation\n" msgstr "// 尝试移除类型标注\n" #: src/conversion/from_into.md:72 msgid "`From` and `Into` are interchangeable" msgstr "`From` 和 `Into` 是可互换的" #: src/conversion/from_into.md:74 msgid "" "`From` and `Into` are designed to be complementary. We do not need to " "provide an implementation for both traits. If you have implemented the " "`From` trait for your type, `Into` will call it when necessary. Note, " "however, that the converse is not true: implementing `Into` for your type " "will not automatically provide it with an implementation of `From`." msgstr "" "`From` 和 `Into` 被设计为互补的。我们不需要为两个特质都提供实现。如果你为你的" "类型实现了 `From` 特质，`Into` 会在必要时调用它。但请注意，反过来并不成立：为" "你的类型实现 `Into` 不会自动为它提供 `From` 的实现。" #: src/conversion/from_into.md:86 msgid "// Define `From`\n" msgstr "// 定义 `From`\n" #: src/conversion/from_into.md:96 msgid "// use `Into`\n" msgstr "// 使用 `Into`\n" #: src/conversion/try_from_try_into.md:3 msgid "" "Similar to [`From` and `Into`](from_into.html), [`TryFrom`](https://doc.rust-" "lang.org/std/convert/trait.TryFrom.html) and [`TryInto`](https://doc.rust-" "lang.org/std/convert/trait.TryInto.html) are generic traits for converting " "between types. Unlike `From`/`Into`, the `TryFrom`/`TryInto` traits are used " "for fallible conversions, and as such, return [`Result`](https://doc.rust-" "lang.org/std/result/enum.Result.html)s." msgstr "" "与 [`From` 和 `Into`](from_into.html) 类似，[`TryFrom`] 和 [`TryInto`] 是用于" "类型转换的泛型特质。与 `From`/`Into` 不同，`TryFrom`/`TryInto` 特质用于可能失" "败的转换，因此返回 [`Result`]。\n" "\n" "[`TryFrom`]: https://doc.rust-lang.org/std/convert/trait.TryFrom.html\n" "[`TryInto`]: https://doc.rust-lang.org/std/convert/trait.TryInto.html\n" "[`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html" #: src/conversion/try_from_try_into.md:33 msgid "// TryFrom\n" msgstr "// TryFrom\n" #: src/conversion/try_from_try_into.md:38 msgid "// TryInto\n" msgstr "// TryInto\n" #: src/conversion/string.md:1 msgid "To and from Strings" msgstr "字符串的转换" #: src/conversion/string.md:3 msgid "Converting to String" msgstr "转换为字符串" #: src/conversion/string.md:5 msgid "" "To convert any type to a `String` is as simple as implementing the " "[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait " "for the type. Rather than doing so directly, you should implement the " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html) trait " "which automatically provides [`ToString`](https://doc.rust-lang.org/std/" "string/trait.ToString.html) and also allows printing the type as discussed " "in the section on [`print!`](../hello/print.md)." msgstr "" "要将任何类型转换为 `String`，只需为该类型实现 [`ToString`](https://doc.rust-" "lang.org/std/string/trait.ToString.html) 特质即可。但更好的做法是实现 " "[`fmt::Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html) 特质，" "它不仅会自动提供 [`ToString`](https://doc.rust-lang.org/std/string/" "trait.ToString.html)，还允许打印该类型，就像在 [`print!`](../hello/print.md) " "部分讨论的那样。" #: src/conversion/string.md:19 msgid "\"Circle of radius {}\"" msgstr "\"半径为 {} 的圆\"" #: src/conversion/string.md:29 msgid "Parsing a String" msgstr "解析字符串" #: src/conversion/string.md:31 msgid "" "It's useful to convert strings into many types, but one of the more common " "string operations is to convert them from string to number. The idiomatic " "approach to this is to use the [`parse`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) function and either to arrange for type " "inference or to specify the type to parse using the 'turbofish' syntax. Both " "alternatives are shown in the following example." msgstr "" "将字符串转换为其他类型很有用，其中最常见的操作之一是将字符串转换为数字。惯用" "的方法是使用 [`parse`] 函数，可以通过类型推断或使用\"涡轮鱼\"语法指定要解析的" "类型。以下示例展示了这两种方法。\n" "\n" "[`parse`]: https://doc.rust-lang.org/std/primitive.str.html#method.parse" #: src/conversion/string.md:37 msgid "" "This will convert the string into the type specified as long as the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait is " "implemented for that type. This is implemented for numerous types within the " "standard library." msgstr "" "只要为目标类型实现了 [`FromStr`] 特质，就可以将字符串转换为指定的类型。标准库" "中为许多类型实现了这个特质。\n" "\n" "[`FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html" #: src/conversion/string.md:43 src/std_misc/process/wait.md:10 msgid "\"5\"" msgstr "\"5\"" #: src/conversion/string.md:44 src/error/result.md:33 src/error/result.md:68 #: src/error/result/result_map.md:42 src/error/result/result_map.md:75 #: src/error/result/result_alias.md:36 src/error/result/early_returns.md:36 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:67 msgid "\"10\"" msgstr "\"10\"" #: src/conversion/string.md:47 msgid "\"Sum: {:?}\"" msgstr "\"总和：{:?}\"" #: src/conversion/string.md:51 msgid "" "To obtain this functionality on a user defined type simply implement the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "that type." msgstr "" "要在自定义类型上获得这个功能，只需为该类型实现 [`FromStr`] 特质。\n" "\n" "[`FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html" #: src/conversion/string.md:74 msgid "\" 3 \"" msgstr "\" 3 \"" #: src/expression.md:3 msgid "A Rust program is (mostly) made up of a series of statements:" msgstr "Rust 程序（主要）由一系列语句组成：" #: src/expression.md:7 msgid "" "// statement\n" " // statement\n" " // statement\n" msgstr "" "// 语句\n" " // 语句\n" " // 语句\n" #: src/expression.md:13 msgid "" "There are a few kinds of statements in Rust. The most common two are " "declaring a variable binding, and using a `;` with an expression:" msgstr "" "Rust 中有几种语句。最常见的两种是声明变量绑定，以及在表达式后使用分号 `;`：" #: src/expression.md:18 msgid "// variable binding\n" msgstr "// 变量绑定\n" #: src/expression.md:21 msgid "// expression;\n" msgstr "// 表达式;\n" #: src/expression.md:28 msgid "" "Blocks are expressions too, so they can be used as values in assignments. " "The last expression in the block will be assigned to the place expression " "such as a local variable. However, if the last expression of the block ends " "with a semicolon, the return value will be `()`." msgstr "" "代码块也是表达式，因此可以在赋值中作为值使用。代码块中的最后一个表达式会被赋" "值给左值表达式（如局部变量）。但是，如果代码块的最后一个表达式以分号结尾，返" "回值将是 `()`。" #: src/expression.md:41 msgid "// This expression will be assigned to `y`\n" msgstr "// 这个表达式将被赋值给 `y`\n" #: src/expression.md:46 msgid "" "// The semicolon suppresses this expression and `()` is assigned to `z`\n" msgstr "// 分号抑制了这个表达式，`()` 被赋值给 `z`\n" #: src/expression.md:50 msgid "\"x is {:?}\"" msgstr "\"x 是 {:?}\"" #: src/expression.md:51 msgid "\"y is {:?}\"" msgstr "\"y 是 {:?}\"" #: src/expression.md:52 msgid "\"z is {:?}\"" msgstr "\"z 是 {:?}\"" #: src/flow_control.md:3 msgid "" "An integral part of any programming language are ways to modify control " "flow: `if`/`else`, `for`, and others. Let's talk about them in Rust." msgstr "" "控制流是任何编程语言的重要组成部分，如 `if`/`else`、`for` 等。让我们来讨论 " "Rust 中的这些内容。" #: src/flow_control/if_else.md:3 msgid "" "Branching with `if`\\-`else` is similar to other languages. Unlike many of " "them, the boolean condition doesn't need to be surrounded by parentheses, " "and each condition is followed by a block. `if`\\-`else` conditionals are " "expressions, and, all branches must return the same type." msgstr "" "`if`-`else` 分支结构与其他语言类似。不同之处在于，布尔条件不需要用括号括起" "来，每个条件后面都跟着一个代码块。`if`-`else` 条件是表达式，所有分支必须返回" "相同的类型。" #: src/flow_control/if_else.md:13 msgid "\"{} is negative\"" msgstr "\"{} 是负数\"" #: src/flow_control/if_else.md:15 msgid "\"{} is positive\"" msgstr "\"{} 是正数\"" #: src/flow_control/if_else.md:17 msgid "\"{} is zero\"" msgstr "\"{} 是零\"" #: src/flow_control/if_else.md:22 msgid "\", and is a small number, increase ten-fold\"" msgstr "\"，是一个小数字，扩大十倍\"" #: src/flow_control/if_else.md:24 msgid "// This expression returns an `i32`.\n" msgstr "// 这个表达式返回 `i32` 类型。\n" #: src/flow_control/if_else.md:27 msgid "\", and is a big number, halve the number\"" msgstr "\"，是一个大数字，将数字减半\"" #: src/flow_control/if_else.md:29 msgid "// This expression must return an `i32` as well.\n" msgstr "// 这个表达式也必须返回 `i32` 类型。\n" #: src/flow_control/if_else.md:31 msgid "// TODO ^ Try suppressing this expression with a semicolon.\n" msgstr "// TODO ^ 尝试用分号结束这个表达式。\n" #: src/flow_control/if_else.md:33 msgid "" "// ^ Don't forget to put a semicolon here! All `let` bindings need it.\n" msgstr "// ^ 别忘了在这里加分号！所有 `let` 绑定都需要它。\n" #: src/flow_control/if_else.md:35 src/flow_control/match.md:35 msgid "\"{} -> {}\"" msgstr "\"{} -> {}\"" #: src/flow_control/loop.md:3 msgid "Rust provides a `loop` keyword to indicate an infinite loop." msgstr "Rust 提供 `loop` 关键字来表示无限循环。" #: src/flow_control/loop.md:5 msgid "" "The `break` statement can be used to exit a loop at anytime, whereas the " "`continue` statement can be used to skip the rest of the iteration and start " "a new one." msgstr "" "`break` 语句可以随时退出循环，而 `continue` 语句可以跳过当前迭代的剩余部分并" "开始下一次迭代。" #: src/flow_control/loop.md:13 msgid "\"Let's count until infinity!\"" msgstr "\"让我们数到无穷大！\"" #: src/flow_control/loop.md:15 msgid "// Infinite loop\n" msgstr "// 无限循环\n" #: src/flow_control/loop.md:20 msgid "\"three\"" msgstr "\"three\"" #: src/flow_control/loop.md:22 msgid "// Skip the rest of this iteration\n" msgstr "// 跳过本次迭代的剩余部分\n" #: src/flow_control/loop.md:29 msgid "\"OK, that's enough\"" msgstr "\"好了，够了\"" #: src/flow_control/loop.md:31 msgid "// Exit this loop\n" msgstr "// 退出这个循环\n" #: src/flow_control/loop/nested.md:3 msgid "" "It's possible to `break` or `continue` outer loops when dealing with nested " "loops. In these cases, the loops must be annotated with some `'label`, and " "the label must be passed to the `break`/`continue` statement." msgstr "" "在处理嵌套循环时，可以 `break` 或 `continue` 外层循环。这种情况下，循环必须" "用 `'label` 标记，并且必须将标签传递给 `break`/`continue` 语句。" #: src/flow_control/loop/nested.md:12 msgid "\"Entered the outer loop\"" msgstr "\"进入外层循环\"" #: src/flow_control/loop/nested.md:15 msgid "\"Entered the inner loop\"" msgstr "\"进入内层循环\"" #: src/flow_control/loop/nested.md:17 msgid "" "// This would break only the inner loop\n" " //break;\n" msgstr "" "// 这只会中断内层循环\n" " //break;\n" #: src/flow_control/loop/nested.md:20 msgid "// This breaks the outer loop\n" msgstr "// 这会中断外层循环\n" #: src/flow_control/loop/nested.md:24 msgid "\"This point will never be reached\"" msgstr "\"这一点永远不会到达\"" #: src/flow_control/loop/nested.md:27 msgid "\"Exited the outer loop\"" msgstr "\"退出外层循环\"" #: src/flow_control/loop/return.md:3 msgid "" "One of the uses of a `loop` is to retry an operation until it succeeds. If " "the operation returns a value though, you might need to pass it to the rest " "of the code: put it after the `break`, and it will be returned by the `loop` " "expression." msgstr "" "`loop` 的一个用途是重试操作直到成功。如果操作返回一个值，你可能需要将它传递给" "代码的其余部分：将它放在 `break` 之后，它将被 `loop` 表达式返回。" #: src/flow_control/while.md:3 msgid "" "The `while` keyword can be used to run a loop while a condition is true." msgstr "`while` 关键字用于在条件为真时运行循环。" #: src/flow_control/while.md:5 msgid "" "Let's write the infamous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) " "using a `while` loop." msgstr "" "让我们用 `while` 循环来编写著名的 [FizzBuzz](https://en.wikipedia.org/wiki/" "Fizz_buzz) 程序。" #: src/flow_control/while.md:9 msgid "// A counter variable\n" msgstr "// 计数器变量\n" #: src/flow_control/while.md:12 msgid "// Loop while `n` is less than 101\n" msgstr "// 当 `n` 小于 101 时继续循环\n" #: src/flow_control/while.md:15 src/flow_control/for.md:17 #: src/flow_control/for.md:37 src/fn.md:34 msgid "\"fizzbuzz\"" msgstr "\"fizzbuzz\"" #: src/flow_control/while.md:17 src/flow_control/for.md:19 #: src/flow_control/for.md:39 src/fn.md:36 msgid "\"fizz\"" msgstr "\"fizz\"" #: src/flow_control/while.md:19 src/flow_control/for.md:21 #: src/flow_control/for.md:41 src/fn.md:38 msgid "\"buzz\"" msgstr "\"buzz\"" #: src/flow_control/while.md:24 msgid "// Increment counter\n" msgstr "// 计数器递增\n" #: src/flow_control/for.md:1 msgid "for loops" msgstr "for 循环" #: src/flow_control/for.md:5 msgid "" "The `for in` construct can be used to iterate through an `Iterator`. One of " "the easiest ways to create an iterator is to use the range notation `a..b`. " "This yields values from `a` (inclusive) to `b` (exclusive) in steps of one." msgstr "" "`for in` 结构可用于遍历 `Iterator`。创建迭代器最简单的方法之一是使用区间表示" "法 `a..b`。这会生成从 `a`（包含）到 `b`（不包含）的值，步长为 1。" #: src/flow_control/for.md:10 msgid "Let's write FizzBuzz using `for` instead of `while`." msgstr "让我们用 `for` 而不是 `while` 来编写 FizzBuzz。" #: src/flow_control/for.md:14 src/flow_control/for.md:34 msgid "// `n` will take the values: 1, 2, ..., 100 in each iteration\n" msgstr "// `n` 在每次迭代中将取值：1, 2, ..., 100\n" #: src/flow_control/for.md:29 msgid "" "Alternatively, `a..=b` can be used for a range that is inclusive on both " "ends. The above can be written as:" msgstr "另外，可以使用 `a..=b` 表示两端都包含的范围。上面的代码可以改写为：" #: src/flow_control/for.md:49 msgid "for and iterators" msgstr "for 与迭代器" #: src/flow_control/for.md:51 msgid "" "The `for in` construct is able to interact with an `Iterator` in several " "ways. As discussed in the section on the [Iterator](../trait/iter.md) trait, " "by default the `for` loop will apply the `into_iter` function to the " "collection. However, this is not the only means of converting collections " "into iterators." msgstr "" "`for in` 结构能以多种方式与 `Iterator` 交互。正如在 [Iterator](../trait/" "iter.md) 特质一节中讨论的那样，默认情况下 `for` 循环会对集合应用 `into_iter` " "函数。然而，这并不是将集合转换为迭代器的唯一方法。" #: src/flow_control/for.md:56 msgid "" "`into_iter`, `iter` and `iter_mut` all handle the conversion of a collection " "into an iterator in different ways, by providing different views on the data " "within." msgstr "" "`into_iter`、`iter` 和 `iter_mut` 都以不同的方式处理集合到迭代器的转换，通过" "提供对数据的不同视图。" #: src/flow_control/for.md:60 msgid "" "`iter` - This borrows each element of the collection through each iteration. " "Thus leaving the collection untouched and available for reuse after the loop." msgstr "" "`iter` - 在每次迭代中借用集合的每个元素。因此，集合保持不变，并且在循环之后可" "以重复使用。" #: src/flow_control/for.md:65 src/flow_control/for.md:85 #: src/flow_control/for.md:104 msgid "\"Frank\"" msgstr "\"Frank\"" #: src/flow_control/for.md:65 src/flow_control/for.md:69 #: src/flow_control/for.md:85 src/flow_control/for.md:89 #: src/flow_control/for.md:104 src/flow_control/for.md:108 msgid "\"Ferris\"" msgstr "\"Ferris\"" #: src/flow_control/for.md:69 src/flow_control/for.md:89 #: src/flow_control/for.md:108 msgid "\"There is a rustacean among us!\"" msgstr "\"我们中间有一个 Rustacean！\"" #: src/flow_control/for.md:70 msgid "// TODO ^ Try deleting the & and matching just \"Ferris\"\n" msgstr "// TODO ^ 尝试删除 & 并只匹配 \"Ferris\"\n" #: src/flow_control/for.md:71 src/flow_control/for.md:90 msgid "\"Hello {}\"" msgstr "\"你好 {}\"" #: src/flow_control/for.md:75 src/flow_control/for.md:94 #: src/flow_control/for.md:113 msgid "\"names: {:?}\"" msgstr "\"names: {:?}\"" #: src/flow_control/for.md:79 msgid "" "`into_iter` - This consumes the collection so that on each iteration the " "exact data is provided. Once the collection has been consumed it is no " "longer available for reuse as it has been 'moved' within the loop." msgstr "" "`into_iter` - 这会消耗集合，使得在每次迭代中提供确切的数据。一旦集合被消耗，" "它就不再可用于重复使用，因为它已经在循环中被\"移动\"了。" #: src/flow_control/for.md:99 msgid "" "`iter_mut` - This mutably borrows each element of the collection, allowing " "for the collection to be modified in place." msgstr "`iter_mut` - 这会可变地借用集合的每个元素，允许在原地修改集合。" #: src/flow_control/for.md:109 msgid "\"Hello\"" msgstr "\"你好\"" #: src/flow_control/for.md:117 msgid "" "In the above snippets note the type of `match` branch, that is the key " "difference in the types of iteration. The difference in type then of course " "implies differing actions that are able to be performed." msgstr "" "在上面的代码片段中，注意 `match` 分支的类型，这是迭代类型的关键区别。类型的差" "异意味着可以执行不同的操作。" #: src/flow_control/for.md:123 msgid "[Iterator](../trait/iter.md)" msgstr "[迭代器](../trait/iter.md)" #: src/flow_control/match.md:3 msgid "" "Rust provides pattern matching via the `match` keyword, which can be used " "like a C `switch`. The first matching arm is evaluated and all possible " "values must be covered." msgstr "" "Rust 通过 `match` 关键字提供模式匹配，类似于 C 语言的 `switch`。第一个匹配的" "分支会被求值，并且必须覆盖所有可能的值。" #: src/flow_control/match.md:10 msgid "// TODO ^ Try different values for `number`\n" msgstr "// TODO ^ 尝试为 `number` 赋不同的值\n" #: src/flow_control/match.md:12 msgid "\"Tell me about {}\"" msgstr "\"告诉我关于 {} 的信息\"" #: src/flow_control/match.md:14 msgid "// Match a single value\n" msgstr "// 匹配单个值\n" #: src/flow_control/match.md:15 msgid "\"One!\"" msgstr "\"一！\"" #: src/flow_control/match.md:16 msgid "// Match several values\n" msgstr "// 匹配多个值\n" #: src/flow_control/match.md:17 msgid "\"This is a prime\"" msgstr "\"这是个质数\"" #: src/flow_control/match.md:18 msgid "" "// TODO ^ Try adding 13 to the list of prime values\n" " // Match an inclusive range\n" msgstr "" "// TODO ^ 尝试将 13 添加到质数列表中\n" " // 匹配一个闭区间范围\n" #: src/flow_control/match.md:20 msgid "\"A teen\"" msgstr "\"一个青少年\"" #: src/flow_control/match.md:21 msgid "// Handle the rest of cases\n" msgstr "// 处理其余情况\n" #: src/flow_control/match.md:22 msgid "\"Ain't special\"" msgstr "\"没什么特别的\"" #: src/flow_control/match.md:23 msgid "// TODO ^ Try commenting out this catch-all arm\n" msgstr "// TODO ^ 尝试注释掉这个匹配所有情况的分支\n" #: src/flow_control/match.md:27 msgid "// Match is an expression too\n" msgstr "// match 也是一个表达式\n" #: src/flow_control/match.md:29 msgid "// The arms of a match must cover all the possible values\n" msgstr "// match 的分支必须覆盖所有可能的值\n" #: src/flow_control/match.md:32 msgid "// TODO ^ Try commenting out one of these arms\n" msgstr "// TODO ^ 尝试注释掉其中一个分支\n" #: src/flow_control/match/destructuring.md:3 msgid "A `match` block can destructure items in a variety of ways." msgstr "`match` 块可以以多种方式解构项。" #: src/flow_control/match/destructuring.md:5 msgid "[Destructuring Tuples](destructuring/destructure_tuple.md)" msgstr "[解构元组](destructuring/destructure_tuple.md)" #: src/flow_control/match/destructuring.md:6 msgid "[Destructuring Arrays and Slices](destructuring/destructure_slice.md)" msgstr "[解构数组和切片](destructuring/destructure_slice.md)" #: src/flow_control/match/destructuring.md:7 msgid "[Destructuring Enums](destructuring/destructure_enum.md)" msgstr "[解构枚举](destructuring/destructure_enum.md)" #: src/flow_control/match/destructuring.md:8 msgid "[Destructuring Pointers](destructuring/destructure_pointers.md)" msgstr "[解构指针](destructuring/destructure_pointers.md)" #: src/flow_control/match/destructuring.md:9 msgid "[Destructuring Structures](destructuring/destructure_structures.md)" msgstr "[解构结构体](destructuring/destructure_structures.md)" #: src/flow_control/match/destructuring/destructure_tuple.md:3 msgid "Tuples can be destructured in a `match` as follows:" msgstr "元组可以在 `match` 中按如下方式解构：" #: src/flow_control/match/destructuring/destructure_tuple.md:8 msgid "// TODO ^ Try different values for `triple`\n" msgstr "// TODO ^ 尝试为 `triple` 赋不同的值\n" #: src/flow_control/match/destructuring/destructure_tuple.md:10 msgid "\"Tell me about {:?}\"" msgstr "\"告诉我关于 {:?} 的信息\"" #: src/flow_control/match/destructuring/destructure_tuple.md:11 msgid "// Match can be used to destructure a tuple\n" msgstr "// match 可用于解构元组\n" #: src/flow_control/match/destructuring/destructure_tuple.md:13 msgid "// Destructure the second and third elements\n" msgstr "// 解构第二和第三个元素\n" #: src/flow_control/match/destructuring/destructure_tuple.md:14 msgid "\"First is `0`, `y` is {:?}, and `z` is {:?}\"" msgstr "\"第一个是 `0`，`y` 是 {:?}，`z` 是 {:?}\"" #: src/flow_control/match/destructuring/destructure_tuple.md:15 msgid "\"First is `1` and the rest doesn't matter\"" msgstr "\"第一个是 `1`，其余的不重要\"" #: src/flow_control/match/destructuring/destructure_tuple.md:16 msgid "\"last is `2` and the rest doesn't matter\"" msgstr "\"最后一个是 `2`，其余的不重要\"" #: src/flow_control/match/destructuring/destructure_tuple.md:17 msgid "\"First is `3`, last is `4`, and the rest doesn't matter\"" msgstr "\"第一个是 `3`，最后一个是 `4`，其余的不重要\"" #: src/flow_control/match/destructuring/destructure_tuple.md:18 msgid "// `..` can be used to ignore the rest of the tuple\n" msgstr "// `..` 可用于忽略元组中的其余部分\n" #: src/flow_control/match/destructuring/destructure_tuple.md:19 msgid "\"It doesn't matter what they are\"" msgstr "\"它们是什么并不重要\"" #: src/flow_control/match/destructuring/destructure_tuple.md:20 msgid "// `_` means don't bind the value to a variable\n" msgstr "// `_` 表示不将值绑定到变量\n" #: src/flow_control/match/destructuring/destructure_tuple.md:27 msgid "[Tuples](../../../primitives/tuples.md)" msgstr "[元组](../../../primitives/tuples.md)" #: src/flow_control/match/destructuring/destructure_slice.md:3 msgid "Like tuples, arrays and slices can be destructured this way:" msgstr "与元组类似，数组和切片也可以用这种方式解构：" #: src/flow_control/match/destructuring/destructure_slice.md:7 msgid "// Try changing the values in the array, or make it a slice!\n" msgstr "// 尝试改变数组中的值，或将其变成切片！\n" #: src/flow_control/match/destructuring/destructure_slice.md:11 msgid "" "// Binds the second and the third elements to the respective variables\n" msgstr "// 将第二个和第三个元素分别绑定到相应的变量\n" #: src/flow_control/match/destructuring/destructure_slice.md:13 msgid "\"array[0] = 0, array[1] = {}, array[2] = {}\"" msgstr "\"array[0] = 0，array[1] = {}，array[2] = {}\"" #: src/flow_control/match/destructuring/destructure_slice.md:15 msgid "// Single values can be ignored with _\n" msgstr "// 单个值可以用 _ 忽略\n" #: src/flow_control/match/destructuring/destructure_slice.md:17 msgid "\"array[0] = 1, array[2] = {} and array[1] was ignored\"" msgstr "\"array[0] = 1，array[2] = {}，array[1] 被忽略了\"" #: src/flow_control/match/destructuring/destructure_slice.md:21 msgid "// You can also bind some and ignore the rest\n" msgstr "// 你也可以绑定一部分值并忽略其余的\n" #: src/flow_control/match/destructuring/destructure_slice.md:23 msgid "\"array[0] = -1, array[1] = {} and all the other ones were ignored\"" msgstr "\"array[0] = -1，array[1] = {}，其他所有的都被忽略了\"" #: src/flow_control/match/destructuring/destructure_slice.md:26 msgid "" "// The code below would not compile\n" " // [-1, second] => ...\n" msgstr "" "// 下面的代码无法编译\n" " // [-1, second] => ...\n" #: src/flow_control/match/destructuring/destructure_slice.md:29 msgid "" "// Or store them in another array/slice (the type depends on\n" " // that of the value that is being matched against)\n" msgstr "" "// 或者将它们存储在另一个数组/切片中（类型取决于\n" " // 正在匹配的值的类型）\n" #: src/flow_control/match/destructuring/destructure_slice.md:32 msgid "\"array[0] = 3, array[1] = {} and the other elements were {:?}\"" msgstr "\"array[0] = 3，array[1] = {}，其他元素是 {:?}\"" #: src/flow_control/match/destructuring/destructure_slice.md:36 msgid "" "// Combining these patterns, we can, for example, bind the first and\n" " // last values, and store the rest of them in a single array\n" msgstr "" "// 结合这些模式，我们可以，例如，绑定第一个和\n" " // 最后一个值，并将其余的存储在一个单独的数组中\n" #: src/flow_control/match/destructuring/destructure_slice.md:39 msgid "\"array[0] = {}, middle = {:?}, array[2] = {}\"" msgstr "\"array[0] = {}，中间部分 = {:?}，array[2] = {}\"" #: src/flow_control/match/destructuring/destructure_slice.md:48 msgid "" "[Arrays and Slices](../../../primitives/array.md) and [Binding](../" "binding.md) for `@` sigil" msgstr "" "关于 `@` 符号的更多信息，请参阅[数组和切片](../../../primitives/array.md)和" "[绑定](../binding.md)" #: src/flow_control/match/destructuring/destructure_enum.md:3 msgid "An `enum` is destructured similarly:" msgstr "`enum` 的解构方式类似：" #: src/flow_control/match/destructuring/destructure_enum.md:6 msgid "" "// `allow` required to silence warnings because only\n" "// one variant is used.\n" msgstr "// 使用 `allow` 来抑制警告，因为只使用了一个变体。\n" #: src/flow_control/match/destructuring/destructure_enum.md:10 msgid "// These 3 are specified solely by their name.\n" msgstr "// 这 3 个仅通过名称指定。\n" #: src/flow_control/match/destructuring/destructure_enum.md:14 msgid "// These likewise tie `u32` tuples to different names: color models.\n" msgstr "// 这些同样将 `u32` 元组与不同的名称（颜色模型）关联。\n" #: src/flow_control/match/destructuring/destructure_enum.md:24 msgid "// TODO ^ Try different variants for `color`\n" msgstr "// TODO ^ 尝试为 `color` 使用不同的变体\n" #: src/flow_control/match/destructuring/destructure_enum.md:26 msgid "\"What color is it?\"" msgstr "\"这是什么颜色？\"" #: src/flow_control/match/destructuring/destructure_enum.md:27 msgid "// An `enum` can be destructured using a `match`.\n" msgstr "// 可以使用 `match` 来解构 `enum`。\n" #: src/flow_control/match/destructuring/destructure_enum.md:29 msgid "\"The color is Red!\"" msgstr "\"颜色是红色！\"" #: src/flow_control/match/destructuring/destructure_enum.md:30 msgid "\"The color is Blue!\"" msgstr "\"颜色是蓝色！\"" #: src/flow_control/match/destructuring/destructure_enum.md:31 msgid "\"The color is Green!\"" msgstr "\"颜色是绿色！\"" #: src/flow_control/match/destructuring/destructure_enum.md:33 msgid "\"Red: {}, green: {}, and blue: {}!\"" msgstr "\"红：{}，绿：{}，蓝：{}！\"" #: src/flow_control/match/destructuring/destructure_enum.md:35 msgid "\"Hue: {}, saturation: {}, value: {}!\"" msgstr "\"色相：{}，饱和度：{}，明度：{}！\"" #: src/flow_control/match/destructuring/destructure_enum.md:37 msgid "\"Hue: {}, saturation: {}, lightness: {}!\"" msgstr "\"色相：{}，饱和度：{}，亮度：{}！\"" #: src/flow_control/match/destructuring/destructure_enum.md:39 msgid "\"Cyan: {}, magenta: {}, yellow: {}!\"" msgstr "\"青：{}，品红：{}，黄：{}！\"" #: src/flow_control/match/destructuring/destructure_enum.md:41 msgid "\"Cyan: {}, magenta: {}, yellow: {}, key (black): {}!\"" msgstr "\"青：{}，品红：{}，黄：{}，黑（K）：{}！\"" #: src/flow_control/match/destructuring/destructure_enum.md:43 msgid "// Don't need another arm because all variants have been examined\n" msgstr "// 不需要其他分支，因为所有变体都已检查\n" #: src/flow_control/match/destructuring/destructure_enum.md:50 msgid "" "[`#[allow(...)]`](../../../attribute/unused.md), [color models](https://" "en.wikipedia.org/wiki/Color_model) and [`enum`](../../../custom_types/" "enum.md)" msgstr "" "[`#[allow(...)]`](../../../attribute/unused.md)、[颜色模型](https://" "en.wikipedia.org/wiki/Color_model)和[`enum`](../../../custom_types/enum.md)" #: src/flow_control/match/destructuring/destructure_pointers.md:3 msgid "" "For pointers, a distinction needs to be made between destructuring and " "dereferencing as they are different concepts which are used differently from " "languages like C/C++." msgstr "" "对于指针，需要区分解构和解引用，因为它们是不同的概念，其用法与 C/C++ 等语言不" "同。" #: src/flow_control/match/destructuring/destructure_pointers.md:7 msgid "Dereferencing uses `*`" msgstr "解引用使用 `*`" #: src/flow_control/match/destructuring/destructure_pointers.md:8 msgid "Destructuring uses `&`, `ref`, and `ref mut`" msgstr "解构使用 `&`、`ref` 和 `ref mut`" #: src/flow_control/match/destructuring/destructure_pointers.md:12 msgid "" "// Assign a reference of type `i32`. The `&` signifies there\n" " // is a reference being assigned.\n" msgstr "" "// 分配一个 `i32` 类型的引用。`&` 表示\n" " // 正在分配一个引用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:17 msgid "" "// If `reference` is pattern matched against `&val`, it results\n" " // in a comparison like:\n" " // `&i32`\n" " // `&val`\n" " // ^ We see that if the matching `&`s are dropped, then the `i32`\n" " // should be assigned to `val`.\n" msgstr "" "// 如果 `reference` 与 `&val` 进行模式匹配，结果\n" " // 就像这样的比较：\n" " // `&i32`\n" " // `&val`\n" " // ^ 我们可以看到，如果去掉匹配的 `&`，那么 `i32`\n" " // 应该被赋值给 `val`。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:23 msgid "\"Got a value via destructuring: {:?}\"" msgstr "\"通过解构获得的值：{:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:26 msgid "// To avoid the `&`, you dereference before matching.\n" msgstr "// 为了避免 `&`，你可以在匹配前解引用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:28 msgid "\"Got a value via dereferencing: {:?}\"" msgstr "\"通过解引用获得的值：{:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:31 msgid "" "// What if you don't start with a reference? `reference` was a `&`\n" " // because the right side was already a reference. This is not\n" " // a reference because the right side is not one.\n" msgstr "" "// 如果你一开始没有引用怎么办？`reference` 是一个 `&`\n" " // 因为右侧已经是一个引用。这不是\n" " // 一个引用，因为右侧不是引用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:36 msgid "" "// Rust provides `ref` for exactly this purpose. It modifies the\n" " // assignment so that a reference is created for the element; this\n" " // reference is assigned.\n" msgstr "" "// Rust 提供 `ref` 正是为了这个目的。它修改了\n" " // 赋值，为元素创建一个引用；\n" " // 这个引用被赋值。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:41 msgid "" "// Accordingly, by defining 2 values without references, references\n" " // can be retrieved via `ref` and `ref mut`.\n" msgstr "" "// 相应地，通过定义两个没有引用的值，\n" " // 可以通过 `ref` 和 `ref mut` 获取引用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:46 msgid "// Use `ref` keyword to create a reference.\n" msgstr "// 使用 `ref` 关键字创建引用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:48 msgid "\"Got a reference to a value: {:?}\"" msgstr "\"获得了一个值的引用：{:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:51 msgid "// Use `ref mut` similarly.\n" msgstr "// 类似地使用 `ref mut`。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:54 msgid "" "// Got a reference. Gotta dereference it before we can\n" " // add anything to it.\n" msgstr "" "// 获得了一个引用。在我们能够\n" " // 对其进行任何添加操作之前，必须先解引用。\n" #: src/flow_control/match/destructuring/destructure_pointers.md:57 msgid "\"We added 10. `mut_value`: {:?}\"" msgstr "\"我们加了 10。`mut_value`：{:?}\"" #: src/flow_control/match/destructuring/destructure_pointers.md:65 msgid "[The ref pattern](../../../scope/borrow/ref.md)" msgstr "[ref 模式](../../../scope/borrow/ref.md)" #: src/flow_control/match/destructuring/destructure_structures.md:3 msgid "Similarly, a `struct` can be destructured as shown:" msgstr "同样，`struct` 可以按如下方式解构：" #: src/flow_control/match/destructuring/destructure_structures.md:12 msgid "// Try changing the values in the struct to see what happens\n" msgstr "// 尝试更改结构体中的值，看看会发生什么\n" #: src/flow_control/match/destructuring/destructure_structures.md:16 msgid "\"First of x is 1, b = {}, y = {} \"" msgstr "\"x 的第一个元素是 1，b = {}，y = {}\"" #: src/flow_control/match/destructuring/destructure_structures.md:18 msgid "" "// you can destructure structs and rename the variables,\n" " // the order is not important\n" msgstr "" "// 你可以解构结构体并重命名变量，\n" " // 顺序并不重要\n" #: src/flow_control/match/destructuring/destructure_structures.md:20 msgid "\"y is 2, i = {:?}\"" msgstr "\"y 为 2，i = {:?}\"" #: src/flow_control/match/destructuring/destructure_structures.md:22 msgid "// and you can also ignore some variables:\n" msgstr "// 你也可以忽略某些变量：\n" #: src/flow_control/match/destructuring/destructure_structures.md:23 msgid "\"y = {}, we don't care about x\"" msgstr "\"y = {}，我们不关心 x 的值\"" #: src/flow_control/match/destructuring/destructure_structures.md:24 msgid "" "// this will give an error: pattern does not mention field `x`\n" " //Foo { y } => println!(\"y = {}\", y),\n" msgstr "" "// 这会导致错误：模式中未提及字段 `x`\n" " //Foo { y } => println!(\"y = {}\", y),\n" #: src/flow_control/match/destructuring/destructure_structures.md:30 msgid "// You do not need a match block to destructure structs:\n" msgstr "// 解构结构体不一定需要 match 块：\n" #: src/flow_control/match/destructuring/destructure_structures.md:32 msgid "\"Outside: x0 = {x0:?}, y0 = {y0}\"" msgstr "\"外部：x0 = {x0:?}，y0 = {y0}\"" #: src/flow_control/match/destructuring/destructure_structures.md:34 msgid "// Destructuring works with nested structs as well:\n" msgstr "// 解构也适用于嵌套结构体：\n" #: src/flow_control/match/destructuring/destructure_structures.md:41 msgid "\"Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}\"" msgstr "\"嵌套：nested_x = {nested_x:?}，nested_y = {nested_y:?}\"" #: src/flow_control/match/destructuring/destructure_structures.md:47 msgid "[Structs](../../../custom_types/structs.md)" msgstr "[结构体](../../../custom_types/structs.md)" #: src/flow_control/match/guard.md:3 msgid "A `match` _guard_ can be added to filter the arm." msgstr "`match` 分支可以使用**守卫**进行额外的筛选。" #: src/flow_control/match/guard.md:14 msgid "// ^ TODO try different values for `temperature`\n" msgstr "// ^ TODO：尝试为 `temperature` 赋予不同的值\n" #: src/flow_control/match/guard.md:17 msgid "\"{}C is above 30 Celsius\"" msgstr "\"{}°C 高于 30°C\"" #: src/flow_control/match/guard.md:18 msgid "// The `if condition` part ^ is a guard\n" msgstr "// `if condition` 部分 ^ 就是守卫\n" #: src/flow_control/match/guard.md:19 msgid "\"{}C is equal to or below 30 Celsius\"" msgstr "\"{}°C 不高于 30°C\"" #: src/flow_control/match/guard.md:21 msgid "\"{}F is above 86 Fahrenheit\"" msgstr "\"{}°F 高于 86°F\"" #: src/flow_control/match/guard.md:22 msgid "\"{}F is equal to or below 86 Fahrenheit\"" msgstr "\"{}°F 不高于 86°F\"" #: src/flow_control/match/guard.md:27 msgid "" "Note that the compiler won't take guard conditions into account when " "checking if all patterns are covered by the match expression." msgstr "" "注意，编译器在检查 match 表达式是否涵盖了所有模式时，不会考虑守卫条件。" #: src/flow_control/match/guard.md:35 msgid "\"Zero\"" msgstr "\"零\"" #: src/flow_control/match/guard.md:36 msgid "\"Greater than zero\"" msgstr "\"大于零\"" #: src/flow_control/match/guard.md:37 msgid "" "// _ => unreachable!(\"Should never happen.\"),\n" " // TODO ^ uncomment to fix compilation\n" msgstr "" "// _ => unreachable!(\"不应该发生。\"),\n" " // TODO ^ 取消注释以修复编译错误\n" #: src/flow_control/match/guard.md:45 msgid "" "[Tuples](../../primitives/tuples.md) [Enums](../../custom_types/enum.md)" msgstr "[元组](../../primitives/tuples.md) [枚举](../../custom_types/enum.md)" #: src/flow_control/match/binding.md:3 msgid "" "Indirectly accessing a variable makes it impossible to branch and use that " "variable without re-binding. `match` provides the `@` sigil for binding " "values to names:" msgstr "" "间接访问变量时，无法在分支中使用该变量而不重新绑定。`match` 提供了 `@` 符号，" "用于将值绑定到名称：" #: src/flow_control/match/binding.md:8 msgid "// A function `age` which returns a `u32`.\n" msgstr "// 一个返回 `u32` 的 `age` 函数。\n" #: src/flow_control/match/binding.md:14 msgid "\"Tell me what type of person you are\"" msgstr "\"告诉我你是什么类型的人\"" #: src/flow_control/match/binding.md:17 msgid "\"I haven't celebrated my first birthday yet\"" msgstr "\"我还没有过第一个生日\"" #: src/flow_control/match/binding.md:18 msgid "" "// Could `match` 1 ..= 12 directly but then what age\n" " // would the child be?\n" " // Could `match` n and use an `if` guard, but would\n" " // not contribute to exhaustiveness checks.\n" " // (Although in this case that would not matter since\n" " // a \"catch-all\" pattern is present at the bottom)\n" " // Instead, bind to `n` for the sequence of 1 ..= 12.\n" " // Now the age can be reported.\n" msgstr "" "// 我们可以直接 `match` 1 ..= 12，但那样的话如何确定\n" " // 孩子的确切年龄呢？\n" " // 可以 `match` n 并使用 `if` 守卫，但这并不是\n" " // 穷尽性检查。\n" " // （虽然在这种情况下无关紧要，因为底部有一个\n" " // \"兜底\" 模式）\n" " // 因此，将 1 ..= 12 序列绑定到 `n`。\n" " // 现在可以报告年龄了。\n" #: src/flow_control/match/binding.md:26 msgid "\"I'm a child of age {:?}\"" msgstr "\"我是 {:?} 岁的儿童\"" #: src/flow_control/match/binding.md:27 msgid "\"I'm a teen of age {:?}\"" msgstr "\"我是 {:?} 岁的青少年\"" #: src/flow_control/match/binding.md:28 msgid "// Nothing bound. Return the result.\n" msgstr "// 没有绑定。直接返回结果。\n" #: src/flow_control/match/binding.md:29 msgid "\"I'm an old person of age {:?}\"" msgstr "\"我是 {:?} 岁的成年人\"" #: src/flow_control/match/binding.md:34 msgid "" "You can also use binding to \"destructure\" `enum` variants, such as " "`Option`:" msgstr "你也可以使用绑定来\"解构\" `enum` 变体，例如 `Option`：" #: src/flow_control/match/binding.md:43 msgid "" "// Got `Some` variant, match if its value, bound to `n`,\n" " // is equal to 42.\n" " // Could also use `Some(42)` and print `\"The Awnser: 42!\"`\n" " // but that would require changing `42` in 2 spots should\n" " // you ever wish to change it.\n" " // Could also use `Some(n) if n == 42` and print `\"The Awnser: {n}!" "\"`\n" " // but that would not contribute to exhaustiveness checks.\n" " // (Although in this case that would not matter since\n" " // the next arm is a \"catch-all\" pattern)\n" msgstr "" "// 匹配到 `Some` 变体，检查其绑定到 `n` 的值\n" " // 是否等于 42。\n" " // 也可以使用 `Some(42)` 并打印 `\"答案是: 42!\"`\n" " // 但如果想要改变这个值，就需要在两个地方修改 `42`。\n" " // 也可以使用 `Some(n) if n == 42` 并打印 `\"答案是: {n}!\"`\n" " // 但这不是穷尽性检查。\n" " // （虽然在这种情况下无关紧要，因为\n" " // 下一个分支是\"兜底\"模式）\n" #: src/flow_control/match/binding.md:52 msgid "\"The Answer: {}!\"" msgstr "\"答案是：{}！\"" #: src/flow_control/match/binding.md:53 msgid "// Match any other number.\n" msgstr "// 匹配任何其他数字\n" #: src/flow_control/match/binding.md:54 msgid "\"Not interesting... {}\"" msgstr "\"不感兴趣... {}\"" #: src/flow_control/match/binding.md:55 msgid "// Match anything else (`None` variant).\n" msgstr "// 匹配其他任何情况（`None` 变体）\n" #: src/flow_control/match/binding.md:63 msgid "" "[`functions`](../../fn.md), [`enums`](../../custom_types/enum.md) and " "[`Option`](../../std/option.md)" msgstr "" "[`函数`](../../fn.md)、[`枚举`](../../custom_types/enum.md) 和 [`Option`]" "(../../std/option.md)" #: src/flow_control/if_let.md:3 msgid "" "For some use cases, when matching enums, `match` is awkward. For example:" msgstr "在某些情况下，使用 `match` 匹配枚举可能会显得繁琐。例如：" #: src/flow_control/if_let.md:6 src/flow_control/while_let.md:7 #: src/flow_control/while_let.md:35 msgid "// Make `optional` of type `Option`\n" msgstr "// 创建 `Option` 类型的 `optional`\n" #: src/flow_control/if_let.md:10 msgid "\"This is a really long string and `{:?}`\"" msgstr "\"这是一个很长的字符串，其中包含 `{:?}`\"" #: src/flow_control/if_let.md:12 msgid "" "// ^ Required because `match` is exhaustive. Doesn't it seem\n" " // like wasted space?\n" msgstr "" "// ^ 这是必需的，因为 `match` 要求穷举所有情况。\n" " // 是不是觉得有些浪费空间？\n" #: src/flow_control/if_let.md:18 msgid "" "`if let` is cleaner for this use case and in addition allows various failure " "options to be specified:" msgstr "对于这种情况，`if let` 更加简洁，而且还允许指定各种失败时的处理选项：" #: src/flow_control/if_let.md:23 msgid "// All have type `Option`\n" msgstr "// 以下都是 `Option` 类型\n" #: src/flow_control/if_let.md:28 msgid "" "// The `if let` construct reads: \"if `let` destructures `number` into\n" " // `Some(i)`, evaluate the block (`{}`).\n" msgstr "" "// `if let` 结构的含义是：如果 `let` 能将 `number` 解构为\n" " // `Some(i)`，则执行代码块（`{}`）。\n" #: src/flow_control/if_let.md:31 src/flow_control/if_let.md:36 #: src/flow_control/if_let.md:46 msgid "\"Matched {:?}!\"" msgstr "\"匹配到 {:?}！\"" #: src/flow_control/if_let.md:34 msgid "// If you need to specify a failure, use an else:\n" msgstr "// 如果需要指定匹配失败的情况，可以使用 else：\n" #: src/flow_control/if_let.md:38 msgid "// Destructure failed. Change to the failure case.\n" msgstr "// 解构失败。转到失败处理的情况。\n" #: src/flow_control/if_let.md:39 src/flow_control/if_let.md:50 msgid "\"Didn't match a number. Let's go with a letter!\"" msgstr "\"没有匹配到数字。那就用一个字母吧！\"" #: src/flow_control/if_let.md:42 msgid "// Provide an altered failing condition.\n" msgstr "// 提供一个修改后的失败条件。\n" #: src/flow_control/if_let.md:47 msgid "" "// Destructure failed. Evaluate an `else if` condition to see if the\n" " // alternate failure branch should be taken:\n" msgstr "// 解构失败。评估 `else if` 条件，看是否应该执行替代的失败分支：\n" #: src/flow_control/if_let.md:52 msgid "// The condition evaluated false. This branch is the default:\n" msgstr "// 条件判断为假。这个分支是默认情况：\n" #: src/flow_control/if_let.md:53 msgid "\"I don't like letters. Let's go with an emoticon :)!\"" msgstr "\"我不喜欢字母。那就用个表情符号吧 :)！\"" #: src/flow_control/if_let.md:58 msgid "In the same way, `if let` can be used to match any enum value:" msgstr "同样地，`if let` 可以用来匹配任何枚举值：" #: src/flow_control/if_let.md:61 msgid "// Our example enum\n" msgstr "// 我们的示例枚举\n" #: src/flow_control/if_let.md:69 msgid "// Create example variables\n" msgstr "// 创建示例变量\n" #: src/flow_control/if_let.md:74 src/flow_control/if_let.md:110 msgid "// Variable a matches Foo::Bar\n" msgstr "// 变量 a 匹配 Foo::Bar\n" #: src/flow_control/if_let.md:76 src/flow_control/if_let.md:113 msgid "\"a is foobar\"" msgstr "\"a 是 foobar\"" #: src/flow_control/if_let.md:79 msgid "" "// Variable b does not match Foo::Bar\n" " // So this will print nothing\n" msgstr "" "// 变量 b 不匹配 Foo::Bar\n" " // 所以这里不会打印任何内容\n" #: src/flow_control/if_let.md:82 msgid "\"b is foobar\"" msgstr "\"b 是 foobar\"" #: src/flow_control/if_let.md:85 msgid "" "// Variable c matches Foo::Qux which has a value\n" " // Similar to Some() in the previous example\n" msgstr "" "// 变量 c 匹配 Foo::Qux，它包含一个值\n" " // 类似于前面例子中的 Some()\n" #: src/flow_control/if_let.md:88 msgid "\"c is {}\"" msgstr "\"c 是 {}\"" #: src/flow_control/if_let.md:91 msgid "// Binding also works with `if let`\n" msgstr "// `if let` 也可以进行绑定\n" #: src/flow_control/if_let.md:93 msgid "\"c is one hundred\"" msgstr "\"c 是一百\"" #: src/flow_control/if_let.md:98 msgid "" "Another benefit is that `if let` allows us to match non-parameterized enum " "variants. This is true even in cases where the enum doesn't implement or " "derive `PartialEq`. In such cases `if Foo::Bar == a` would fail to compile, " "because instances of the enum cannot be equated, however `if let` will " "continue to work." msgstr "" "`if let` 的另一个优点是它允许我们匹配非参数化的枚举变体。即使在枚举没有实现或" "派生 `PartialEq` 的情况下也是如此。在这种情况下，`if Foo::Bar == a` 将无法编" "译，因为枚举的实例无法进行相等比较，但 `if let` 仍然可以正常工作。" #: src/flow_control/if_let.md:100 msgid "Would you like a challenge? Fix the following example to use `if let`:" msgstr "想要挑战一下吗？请修改以下示例，使用 `if let`：" #: src/flow_control/if_let.md:103 msgid "" "// This enum purposely neither implements nor derives PartialEq.\n" "// That is why comparing Foo::Bar == a fails below.\n" msgstr "" "// 这个枚举故意既不实现也不派生 PartialEq。\n" "// 这就是为什么下面比较 Foo::Bar == a 会失败。\n" #: src/flow_control/if_let.md:112 msgid "// ^-- this causes a compile-time error. Use `if let` instead.\n" msgstr "// ^-- 这会导致编译时错误。请改用 `if let`。\n" #: src/flow_control/if_let.md:120 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/160)" msgstr "" "[`枚举`](../custom_types/enum.md)、[`Option`](../std/option.md) 和 [RFC]" "(https://github.com/rust-lang/rfcs/pull/160)" #: src/flow_control/let_else.md:3 msgid "🛈 stable since: rust 1.65" msgstr "🛈 自 Rust 1.65 版本起稳定" #: src/flow_control/let_else.md:5 msgid "" "🛈 you can target specific edition by compiling like this `rustc --" "edition=2021 main.rs`" msgstr "🛈 你可以通过这种方式编译来指定特定版本：`rustc --edition=2021 main.rs`" #: src/flow_control/let_else.md:8 msgid "" "With `let`\\-`else`, a refutable pattern can match and bind variables in the " "surrounding scope like a normal `let`, or else diverge (e.g. `break`, " "`return`, `panic!`) when the pattern doesn't match." msgstr "" "`let`-`else` 语法允许可能失败的模式匹配像普通 `let` 一样绑定变量到当前作用" "域，或在匹配失败时执行中断操作（如 `break`、`return`、`panic!`）。" #: src/flow_control/let_else.md:16 src/flow_control/let_else.md:39 #: src/std/str.md:41 msgid "' '" msgstr "' '" #: src/flow_control/let_else.md:18 src/flow_control/let_else.md:42 msgid "\"Can't segment count item pair: '{s}'\"" msgstr "\"无法分割计数项对：'{s}'\"" #: src/flow_control/let_else.md:21 src/flow_control/let_else.md:47 msgid "\"Can't parse integer: '{count_str}'\"" msgstr "\"无法解析整数：'{count_str}'\"" #: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52 msgid "\"3 chairs\"" msgstr "\"3 chairs\"" #: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52 msgid "\"chairs\"" msgstr "\"chairs\"" #: src/flow_control/let_else.md:31 msgid "" "The scope of name bindings is the main thing that makes this different from " "`match` or `if let`\\-`else` expressions. You could previously approximate " "these patterns with an unfortunate bit of repetition and an outer `let`:" msgstr "" "名称绑定的作用域是使其区别于 `match` 或 `if let`-`else` 表达式的主要特点。在" "此之前，你可能需要通过一些冗余的重复和外部 `let` 来近似实现这些模式：" #: src/flow_control/let_else.md:57 msgid "" "[option](../std/option.md), [match](./match.md), [if let](./if_let.md) and " "the [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)." msgstr "" "[Option](../std/option.md)、[match](./match.md)、[if let](./if_let.md) 和 " "[let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)。" #: src/flow_control/while_let.md:3 msgid "" "Similar to `if let`, `while let` can make awkward `match` sequences more " "tolerable. Consider the following sequence that increments `i`:" msgstr "" "与 `if let` 类似，`while let` 可以简化繁琐的 `match` 序列。让我们来看一个递" "增 `i` 的例子：" #: src/flow_control/while_let.md:9 msgid "// Repeatedly try this test.\n" msgstr "// 重复执行此测试。\n" #: src/flow_control/while_let.md:13 msgid "// If `optional` destructures, evaluate the block.\n" msgstr "// 如果 `optional` 解构成功，则执行代码块。\n" #: src/flow_control/while_let.md:16 src/flow_control/while_let.md:42 msgid "\"Greater than 9, quit!\"" msgstr "\"大于 9，退出！\"" #: src/flow_control/while_let.md:19 src/flow_control/while_let.md:45 msgid "\"`i` is `{:?}`. Try again.\"" msgstr "\"`i` 是 `{:?}`。再试一次。\"" #: src/flow_control/while_let.md:22 msgid "// ^ Requires 3 indentations!\n" msgstr "// ^ 需要 3 层缩进！\n" #: src/flow_control/while_let.md:24 msgid "// Quit the loop when the destructure fails:\n" msgstr "// 当解构失败时退出循环：\n" #: src/flow_control/while_let.md:26 msgid "// ^ Why should this be required? There must be a better way!\n" msgstr "// ^ 为什么需要这样？一定有更好的方法！\n" #: src/flow_control/while_let.md:31 msgid "Using `while let` makes this sequence much nicer:" msgstr "使用 `while let` 可以让这个序列更加简洁：" #: src/flow_control/while_let.md:38 msgid "" "// This reads: \"while `let` destructures `optional` into\n" " // `Some(i)`, evaluate the block (`{}`). Else `break`.\n" msgstr "" "// 这段代码的含义是：当 `let` 将 `optional` 解构为 `Some(i)` 时，\n" " // 执行代码块 `{}`，否则 `break`。\n" #: src/flow_control/while_let.md:48 msgid "" "// ^ Less rightward drift and doesn't require\n" " // explicitly handling the failing case.\n" msgstr "// ^ 减少了代码缩进右移，无需显式处理失败情况\n" #: src/flow_control/while_let.md:51 msgid "" "// ^ `if let` had additional optional `else`/`else if`\n" " // clauses. `while let` does not have these.\n" msgstr "" "// ^ `if let` 可以有额外的 `else`/`else if` 子句，`while let` 则没有。\n" #: src/flow_control/while_let.md:58 msgid "" "[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the " "[RFC](https://github.com/rust-lang/rfcs/pull/214)" msgstr "" "[`enum`](../custom_types/enum.md)、[`Option`](../std/option.md) 和 [RFC]" "(https://github.com/rust-lang/rfcs/pull/214)" #: src/fn.md:3 msgid "" "Functions are declared using the `fn` keyword. Its arguments are type " "annotated, just like variables, and, if the function returns a value, the " "return type must be specified after an arrow `->`." msgstr "" "函数使用 `fn` 关键字声明。函数参数需要标注类型，就像变量一样。如果函数返回" "值，则必须在箭头 `->` 后指定返回类型。" #: src/fn.md:7 msgid "" "The final expression in the function will be used as return value. " "Alternatively, the `return` statement can be used to return a value earlier " "from within the function, even from inside loops or `if` statements." msgstr "" "函数的最后一个表达式将作为返回值。另外，可以使用 `return` 语句在函数内部提前" "返回值，甚至可以在循环或 `if` 语句内部使用。" #: src/fn.md:11 msgid "Let's rewrite FizzBuzz using functions!" msgstr "让我们用函数重写 FizzBuzz 吧！" #: src/fn.md:14 msgid "" "// Unlike C/C++, there's no restriction on the order of function " "definitions\n" msgstr "// 与 C/C++ 不同，Rust 中函数定义的顺序没有限制\n" #: src/fn.md:16 msgid "// We can use this function here, and define it somewhere later\n" msgstr "// 我们可以在这里使用函数，并在稍后的某处定义它\n" #: src/fn.md:19 msgid "// Function that returns a boolean value\n" msgstr "// 返回布尔值的函数\n" #: src/fn.md:22 msgid "// Corner case, early return\n" msgstr "// 特殊情况，提前返回\n" #: src/fn.md:27 msgid "// This is an expression, the `return` keyword is not necessary here\n" msgstr "// 这是一个表达式，此处不需要 `return` 关键字\n" #: src/fn.md:30 msgid "" "// Functions that \"don't\" return a value, actually return the unit type " "`()`\n" msgstr "// \"无返回值\"的函数实际上返回单元类型 `()`\n" #: src/fn.md:43 msgid "" "// When a function returns `()`, the return type can be omitted from the\n" "// signature\n" msgstr "// 当函数返回 `()` 时，可以在函数签名中省略返回类型\n" #: src/fn/methods.md:1 msgid "Associated functions & Methods" msgstr "关联函数和方法" #: src/fn/methods.md:3 msgid "" "Some functions are connected to a particular type. These come in two forms: " "associated functions, and methods. Associated functions are functions that " "are defined on a type generally, while methods are associated functions that " "are called on a particular instance of a type." msgstr "" "某些函数与特定类型相关联。这些函数有两种形式：关联函数和方法。关联函数是在类" "型上定义的函数，而方法是在类型的特定实例上调用的关联函数。" #: src/fn/methods.md:13 msgid "" "// Implementation block, all `Point` associated functions & methods go in " "here\n" msgstr "// 实现块，所有 `Point` 的关联函数和方法都在此处定义\n" #: src/fn/methods.md:16 msgid "" "// This is an \"associated function\" because this function is associated " "with\n" " // a particular type, that is, Point.\n" " //\n" " // Associated functions don't need to be called with an instance.\n" " // These functions are generally used like constructors.\n" msgstr "" "// 这是一个\"关联函数\"，因为这个函数与特定类型 Point 相关联。\n" " //\n" " // 关联函数不需要通过实例来调用。\n" " // 这些函数通常用作构造函数。\n" #: src/fn/methods.md:25 msgid "// Another associated function, taking two arguments:\n" msgstr "// 另一个接受两个参数的关联函数：\n" #: src/fn/methods.md:37 msgid "" "// This is a method\n" " // `&self` is sugar for `self: &Self`, where `Self` is the type of the\n" " // caller object. In this case `Self` = `Rectangle`\n" msgstr "" "// 这是一个方法\n" " // `&self` 是 `self: &Self` 的语法糖，其中 `Self` 是调用者对象的类型。\n" " // 在这个例子中 `Self` = `Rectangle`\n" #: src/fn/methods.md:41 msgid "// `self` gives access to the struct fields via the dot operator\n" msgstr "// `self` 通过点运算符访问结构体字段\n" #: src/fn/methods.md:45 msgid "" "// `abs` is a `f64` method that returns the absolute value of the\n" " // caller\n" msgstr "// `abs` 是 `f64` 类型的方法，返回调用者的绝对值\n" #: src/fn/methods.md:57 msgid "" "// This method requires the caller object to be mutable\n" " // `&mut self` desugars to `self: &mut Self`\n" msgstr "" "// 这个方法要求调用对象是可变的\n" " // `&mut self` 是 `self: &mut Self` 的语法糖\n" #: src/fn/methods.md:67 msgid "// `Pair` owns resources: two heap allocated integers\n" msgstr "// `Pair` 拥有两个堆分配的整数资源\n" #: src/fn/methods.md:72 msgid "" "// This method \"consumes\" the resources of the caller object\n" " // `self` desugars to `self: Self`\n" msgstr "" "// 这个方法会\"消耗\"调用对象的资源\n" " // `self` 是 `self: Self` 的语法糖\n" #: src/fn/methods.md:75 msgid "// Destructure `self`\n" msgstr "// 解构 `self`\n" #: src/fn/methods.md:78 msgid "\"Destroying Pair({}, {})\"" msgstr "\"正在销毁 Pair({}, {})\"" #: src/fn/methods.md:80 msgid "// `first` and `second` go out of scope and get freed\n" msgstr "// `first` 和 `second` 超出作用域并被释放\n" #: src/fn/methods.md:86 msgid "// Associated functions are called using double colons\n" msgstr "// 使用双冒号调用关联函数\n" #: src/fn/methods.md:91 msgid "" "// Methods are called using the dot operator\n" " // Note that the first argument `&self` is implicitly passed, i.e.\n" " // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`\n" msgstr "" "// 使用点运算符调用方法\n" " // 注意，第一个参数 `&self` 是隐式传递的\n" " // 即 `rectangle.perimeter()` 等同于 `Rectangle::perimeter(&rectangle)`\n" #: src/fn/methods.md:94 msgid "\"Rectangle perimeter: {}\"" msgstr "\"矩形周长：{}\"" #: src/fn/methods.md:95 msgid "\"Rectangle area: {}\"" msgstr "\"矩形面积：{}\"" #: src/fn/methods.md:102 msgid "" "// Error! `rectangle` is immutable, but this method requires a mutable\n" " // object\n" " //rectangle.translate(1.0, 0.0);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`rectangle` 是不可变的，但这个方法需要可变对象\n" " //rectangle.translate(1.0, 0.0);\n" " // TODO ^ 尝试取消这行的注释\n" #: src/fn/methods.md:107 msgid "// Okay! Mutable objects can call mutable methods\n" msgstr "// 正确！可变对象可以调用可变方法\n" #: src/fn/methods.md:114 msgid "" "// Error! Previous `destroy` call \"consumed\" `pair`\n" " //pair.destroy();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 报错！之前的 `destroy` 调用已经\"消耗\"了 `pair`\n" " //pair.destroy();\n" " // TODO ^ 尝试取消注释这一行\n" #: src/fn/closures.md:3 msgid "" "Closures are functions that can capture the enclosing environment. For " "example, a closure that captures the `x` variable:" msgstr "闭包是可以捕获周围环境的函数。例如，下面是一个捕获变量 `x` 的闭包：" #: src/fn/closures.md:10 msgid "" "The syntax and capabilities of closures make them very convenient for on the " "fly usage. Calling a closure is exactly like calling a function. However, " "both input and return types _can_ be inferred and input variable names " "_must_ be specified." msgstr "" "闭包的语法和功能使其非常适合即时使用。调用闭包与调用函数完全相同。不过，闭包" "的输入和返回类型**可以**被推断，而输入变量名**必须**指定。" #: src/fn/closures.md:15 msgid "Other characteristics of closures include:" msgstr "闭包的其他特点包括：" #: src/fn/closures.md:17 msgid "using `||` instead of `()` around input variables." msgstr "使用 `||` 而不是 `()` 来包围输入变量。" #: src/fn/closures.md:18 msgid "" "optional body delimitation (`{}`) for a single line expression (mandatory " "otherwise)." msgstr "单行表达式可省略函数体定界符（`{}`），其他情况则必须使用" #: src/fn/closures.md:19 msgid "the ability to capture the outer environment variables." msgstr "能够捕获外部环境的变量" #: src/fn/closures.md:25 msgid "" "// A regular function can't refer to variables in the enclosing environment\n" " //fn function(i: i32) -> i32 { i + outer_var }\n" " // TODO: uncomment the line above and see the compiler error. The " "compiler\n" " // suggests that we define a closure instead.\n" msgstr "" "// 常规函数无法引用外部环境的变量\n" " //fn function(i: i32) -> i32 { i + outer_var }\n" " // TODO：取消上面这行的注释，查看编译器错误\n" " // 编译器会建议我们定义一个闭包来替代\n" #: src/fn/closures.md:30 msgid "" "// Closures are anonymous, here we are binding them to references.\n" " // Annotation is identical to function annotation but is optional\n" " // as are the `{}` wrapping the body. These nameless functions\n" " // are assigned to appropriately named variables.\n" msgstr "" "// 闭包是匿名的，这里我们将它们绑定到引用\n" " // 注解与函数注解相同，但是可选的\n" " // 包裹函数体的 `{}` 也是可选的\n" " // 这些无名函数被赋值给适当命名的变量\n" #: src/fn/closures.md:37 msgid "// Call the closures.\n" msgstr "// 调用闭包\n" #: src/fn/closures.md:38 msgid "\"closure_annotated: {}\"" msgstr "\"closure_annotated：{}\"" #: src/fn/closures.md:39 msgid "\"closure_inferred: {}\"" msgstr "\"closure_inferred：{}\"" #: src/fn/closures.md:40 msgid "" "// Once closure's type has been inferred, it cannot be inferred again with " "another type.\n" " //println!(\"cannot reuse closure_inferred with another type: {}\", " "closure_inferred(42i64));\n" " // TODO: uncomment the line above and see the compiler error.\n" msgstr "" "// 闭包类型一旦被推断，就不能再用其他类型重新推断。\n" " //println!(\"不能用其他类型重用 closure_inferred：{}\", " "closure_inferred(42i64));\n" " // TODO：取消上面这行的注释，观察编译器错误。\n" #: src/fn/closures.md:44 msgid "" "// A closure taking no arguments which returns an `i32`.\n" " // The return type is inferred.\n" msgstr "" "// 一个无参数并返回 `i32` 的闭包。\n" " // 返回类型是推断的。\n" #: src/fn/closures.md:47 msgid "\"closure returning one: {}\"" msgstr "\"返回 1 的闭包：{}\"" #: src/fn/closures/capture.md:3 msgid "" "Closures are inherently flexible and will do what the functionality requires " "to make the closure work without annotation. This allows capturing to " "flexibly adapt to the use case, sometimes moving and sometimes borrowing. " "Closures can capture variables:" msgstr "" "闭包本质上很灵活，无需注解就能根据功能需求自动适应。这使得捕获可以灵活地适应" "不同场景，有时移动，有时借用。闭包可以通过以下方式捕获变量：" #: src/fn/closures/capture.md:8 msgid "by reference: `&T`" msgstr "通过引用：`&T`" #: src/fn/closures/capture.md:9 msgid "by mutable reference: `&mut T`" msgstr "通过可变引用：`&mut T`" #: src/fn/closures/capture.md:10 msgid "by value: `T`" msgstr "通过值：`T`" #: src/fn/closures/capture.md:12 msgid "" "They preferentially capture variables by reference and only go lower when " "required." msgstr "闭包优先通过引用捕获变量，仅在必要时才使用更底部的的捕获方式。" #: src/fn/closures/capture.md:19 msgid "\"green\"" msgstr "\"green\"" #: src/fn/closures/capture.md:21 msgid "" "// A closure to print `color` which immediately borrows (`&`) `color` and\n" " // stores the borrow and closure in the `print` variable. It will " "remain\n" " // borrowed until `print` is used the last time.\n" " //\n" " // `println!` only requires arguments by immutable reference so it " "doesn't\n" " // impose anything more restrictive.\n" msgstr "" "// 打印 `color` 的闭包，立即借用（`&`）`color` 并\n" " // 将借用和闭包存储在 `print` 变量中。借用状态\n" " // 将持续到 `print` 最后一次使用。\n" " //\n" " // `println!` 只需要不可变引用参数，所以\n" " // 不会施加更多限制。\n" #: src/fn/closures/capture.md:27 msgid "\"`color`: {}\"" msgstr "\"`color`: {}\"" #: src/fn/closures/capture.md:29 msgid "// Call the closure using the borrow.\n" msgstr "// 使用借用调用闭包。\n" #: src/fn/closures/capture.md:32 msgid "" "// `color` can be borrowed immutably again, because the closure only holds\n" " // an immutable reference to `color`.\n" msgstr "" "// `color` 可以再次被不可变借用，因为闭包只持有\n" " // `color` 的不可变引用。\n" #: src/fn/closures/capture.md:37 msgid "// A move or reborrow is allowed after the final use of `print`\n" msgstr "// `print` 最后一次使用后，允许移动或重新借用\n" #: src/fn/closures/capture.md:42 msgid "" "// A closure to increment `count` could take either `&mut count` or `count`\n" " // but `&mut count` is less restrictive so it takes that. Immediately\n" " // borrows `count`.\n" " //\n" " // A `mut` is required on `inc` because a `&mut` is stored inside. " "Thus,\n" " // calling the closure mutates `count` which requires a `mut`.\n" msgstr "" "// 增加 `count` 的闭包可以接受 `&mut count` 或 `count`，\n" " // 但 `&mut count` 限制更少，所以选择它。立即\n" " // 借用 `count`。\n" " //\n" " // `inc` 需要 `mut` 因为内部存储了 `&mut`。因此，\n" " // 调用闭包会修改 `count`，这需要 `mut`。\n" #: src/fn/closures/capture.md:50 msgid "\"`count`: {}\"" msgstr "\"`count`: {}\"" #: src/fn/closures/capture.md:53 msgid "// Call the closure using a mutable borrow.\n" msgstr "// 使用可变借用调用闭包。\n" #: src/fn/closures/capture.md:56 msgid "" "// The closure still mutably borrows `count` because it is called later.\n" " // An attempt to reborrow will lead to an error.\n" " // let _reborrow = &count;\n" " // ^ TODO: try uncommenting this line.\n" msgstr "" "// 闭包仍然可变借用 `count`，因为它稍后会被调用。\n" " // 尝试重新借用会导致错误。\n" " // let _reborrow = &count; \n" " // ^ TODO：尝试取消注释这行。\n" #: src/fn/closures/capture.md:62 msgid "" "// The closure no longer needs to borrow `&mut count`. Therefore, it is\n" " // possible to reborrow without an error\n" msgstr "" "// 闭包不再需要借用 `&mut count`。因此，\n" " // 可以在没有错误的情况下重新借用\n" #: src/fn/closures/capture.md:67 msgid "// A non-copy type.\n" msgstr "// 不可复制类型。\n" #: src/fn/closures/capture.md:70 msgid "" "// `mem::drop` requires `T` so this must take by value. A copy type\n" " // would copy into the closure leaving the original untouched.\n" " // A non-copy must move and so `movable` immediately moves into\n" " // the closure.\n" msgstr "" "// `mem::drop` 需要 `T`，所以这里必须通过值获取。可复制类型\n" " // 会被复制到闭包中，原始值保持不变。\n" " // 不可复制类型必须移动，所以 `movable` 立即移动到闭包中。\n" #: src/fn/closures/capture.md:75 msgid "\"`movable`: {:?}\"" msgstr "\"`movable`: {:?}\"" #: src/fn/closures/capture.md:79 msgid "// `consume` consumes the variable so this can only be called once.\n" msgstr "// `consume` 消耗了变量，所以只能调用一次。\n" #: src/fn/closures/capture.md:81 msgid "" "// consume();\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" "// consume();\n" " // ^ TODO：尝试取消注释这行。\n" #: src/fn/closures/capture.md:86 msgid "" "Using `move` before vertical pipes forces closure to take ownership of " "captured variables:" msgstr "在竖线前使用 `move` 强制闭包获取捕获变量的所有权：" #: src/fn/closures/capture.md:91 msgid "// `Vec` has non-copy semantics.\n" msgstr "// `Vec` 是非复制语义。\n" #: src/fn/closures/capture.md:99 msgid "" "// println!(\"There're {} elements in vec\", haystack.len());\n" " // ^ Uncommenting above line will result in compile-time error\n" " // because borrow checker doesn't allow re-using variable after it\n" " // has been moved.\n" msgstr "" "// println!(\"vec 中有 {} 个元素\", haystack.len());\n" " // ^ 取消上面这行的注释会导致编译时错误\n" " // 因为借用检查器不允许在变量被移动后重用。\n" " \n" #: src/fn/closures/capture.md:104 msgid "" "// Removing `move` from closure's signature will cause closure\n" " // to borrow _haystack_ variable immutably, hence _haystack_ is still\n" " // available and uncommenting above line will not cause an error.\n" msgstr "" "// 从闭包签名中移除 `move` 将导致闭包\n" " // 不可变借用 _haystack_ 变量，因此 _haystack_ 仍可用，\n" " // 取消注释上面的行不会导致错误。\n" #: src/fn/closures/capture.md:112 msgid "" "[`Box`](../../std/box.md) and [`std::mem::drop`](https://doc.rust-lang.org/" "std/mem/fn.drop.html)" msgstr "" "[`Box`](../../std/box.md) 和 [`std::mem::drop`](https://doc.rust-lang.org/" "std/mem/fn.drop.html)" #: src/fn/closures/input_parameters.md:3 msgid "" "While Rust chooses how to capture variables on the fly mostly without type " "annotation, this ambiguity is not allowed when writing functions. When " "taking a closure as an input parameter, the closure's complete type must be " "annotated using one of a few `traits`, and they're determined by what the " "closure does with captured value. In order of decreasing restriction, they " "are:" msgstr "" "Rust 通常能自动选择如何捕获变量，无需类型标注。但在编写函数时，这种模糊性是不" "允许的。当将闭包作为输入参数时，必须使用特定的 `trait` 来注解闭包的完整类型。" "这些 trait 由闭包对捕获值的处理方式决定。按限制程度从高到低排列如下：" #: src/fn/closures/input_parameters.md:10 msgid "`Fn`: the closure uses the captured value by reference (`&T`)" msgstr "`Fn`：闭包通过引用使用捕获的值（`&T`）" #: src/fn/closures/input_parameters.md:11 msgid "" "`FnMut`: the closure uses the captured value by mutable reference (`&mut T`)" msgstr "`FnMut`：闭包通过可变引用使用捕获的值（`&mut T`）" #: src/fn/closures/input_parameters.md:12 msgid "`FnOnce`: the closure uses the captured value by value (`T`)" msgstr "`FnOnce`：闭包通过值使用捕获的值（`T`）" #: src/fn/closures/input_parameters.md:14 msgid "" "On a variable-by-variable basis, the compiler will capture variables in the " "least restrictive manner possible." msgstr "编译器会以尽可能最少限制的方式逐个捕获变量。" #: src/fn/closures/input_parameters.md:17 msgid "" "For instance, consider a parameter annotated as `FnOnce`. This specifies " "that the closure _may_ capture by `&T`, `&mut T`, or `T`, but the compiler " "will ultimately choose based on how the captured variables are used in the " "closure." msgstr "" "例如，考虑一个注解为 `FnOnce` 的参数。这表示闭包**可能**通过 `&T`、`&mut T` " "或 `T` 进行捕获，但编译器最终会根据捕获变量在闭包中的使用方式来决定。" #: src/fn/closures/input_parameters.md:22 msgid "" "This is because if a move is possible, then any type of borrow should also " "be possible. Note that the reverse is not true. If the parameter is " "annotated as `Fn`, then capturing variables by `&mut T` or `T` are not " "allowed. However, `&T` is allowed." msgstr "" "这是因为如果可以移动，那么任何类型的借用也应该是可能的。注意反过来并不成立。" "如果参数被注解为 `Fn`，那么通过 `&mut T` 或 `T` 捕获变量是不允许的。但 `&T` " "是允许的。" #: src/fn/closures/input_parameters.md:27 msgid "" "In the following example, try swapping the usage of `Fn`, `FnMut`, and " "`FnOnce` to see what happens:" msgstr "" "在下面的例子中，尝试交换 `Fn`、`FnMut` 和 `FnOnce` 的用法，看看会发生什么：" #: src/fn/closures/input_parameters.md:31 msgid "" "// A function which takes a closure as an argument and calls it.\n" "// denotes that F is a \"Generic type parameter\"\n" msgstr "" "// 这个函数接受一个闭包作为参数并调用它\n" "// 表示 F 是一个\"泛型类型参数\"\n" #: src/fn/closures/input_parameters.md:34 msgid "// The closure takes no input and returns nothing.\n" msgstr "// 这个闭包不接受输入也不返回任何值\n" #: src/fn/closures/input_parameters.md:36 msgid "// ^ TODO: Try changing this to `Fn` or `FnMut`.\n" msgstr "// ^ TODO：试着将其改为 `Fn` 或 `FnMut`\n" #: src/fn/closures/input_parameters.md:40 msgid "// A function which takes a closure and returns an `i32`.\n" msgstr "// 这个函数接受一个闭包并返回 `i32`\n" #: src/fn/closures/input_parameters.md:43 msgid "// The closure takes an `i32` and returns an `i32`.\n" msgstr "// 这个闭包接受一个 `i32` 并返回一个 `i32`\n" #: src/fn/closures/input_parameters.md:53 msgid "" "// A non-copy type.\n" " // `to_owned` creates owned data from borrowed one\n" msgstr "" "// 一个非复制类型\n" " // `to_owned` 从借用的数据创建拥有所有权的数据\n" #: src/fn/closures/input_parameters.md:55 msgid "\"goodbye\"" msgstr "\"goodbye\"" #: src/fn/closures/input_parameters.md:57 msgid "" "// Capture 2 variables: `greeting` by reference and\n" " // `farewell` by value.\n" msgstr "" "// 捕获两个变量：通过引用捕获 `greeting`，\n" " // 通过值捕获 `farewell`\n" #: src/fn/closures/input_parameters.md:60 msgid "// `greeting` is by reference: requires `Fn`.\n" msgstr "// `greeting` 是通过引用捕获的：需要 `Fn`\n" #: src/fn/closures/input_parameters.md:61 msgid "\"I said {}.\"" msgstr "\"我说{}。\"" #: src/fn/closures/input_parameters.md:63 msgid "" "// Mutation forces `farewell` to be captured by\n" " // mutable reference. Now requires `FnMut`.\n" msgstr "" "// 修改强制 `farewell` 通过可变引用捕获\n" " // 现在需要 `FnMut`\n" #: src/fn/closures/input_parameters.md:65 msgid "\"!!!\"" msgstr "\"！！！\"" #: src/fn/closures/input_parameters.md:66 msgid "\"Then I screamed {}.\"" msgstr "\"然后我喊{}。\"" #: src/fn/closures/input_parameters.md:67 msgid "\"Now I can sleep. zzzzz\"" msgstr "\"现在我可以睡觉了。呼呼\"" #: src/fn/closures/input_parameters.md:69 msgid "" "// Manually calling drop forces `farewell` to\n" " // be captured by value. Now requires `FnOnce`.\n" msgstr "" "// 手动调用 drop 强制 `farewell` 通过值捕获\n" " // 现在需要 `FnOnce`\n" #: src/fn/closures/input_parameters.md:74 msgid "// Call the function which applies the closure.\n" msgstr "// 调用应用闭包的函数\n" #: src/fn/closures/input_parameters.md:77 msgid "// `double` satisfies `apply_to_3`'s trait bound\n" msgstr "// `double` 满足 `apply_to_3` 的 trait 约束\n" #: src/fn/closures/input_parameters.md:80 msgid "\"3 doubled: {}\"" msgstr "\"3 的两倍是：{}\"" #: src/fn/closures/input_parameters.md:86 msgid "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md), " "[where](../../generics/where.md) and [`FnOnce`](https://doc.rust-lang.org/" "std/ops/trait.FnOnce.html)" msgstr "" "[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html)、[`Fn`]" "(https://doc.rust-lang.org/std/ops/trait.Fn.html)、[`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html)、[泛型](../../generics.md)、" "[where](../../generics/where.md) 和 [`FnOnce`](https://doc.rust-lang.org/std/" "ops/trait.FnOnce.html)" #: src/fn/closures/anonymity.md:3 msgid "" "Closures succinctly capture variables from enclosing scopes. Does this have " "any consequences? It surely does. Observe how using a closure as a function " "parameter requires [generics](../../generics.md), which is necessary because " "of how they are defined:" msgstr "" "闭包能简洁地从外部作用域捕获变量。这会有什么影响吗？当然会有。注意观察如何将" "闭包作为函数参数使用时需要[泛型](../../generics.md)，这是由于闭包的定义方式所" "决定的：" #: src/fn/closures/anonymity.md:9 msgid "// `F` must be generic.\n" msgstr "// `F` 必须是泛型\n" #: src/fn/closures/anonymity.md:16 msgid "" "When a closure is defined, the compiler implicitly creates a new anonymous " "structure to store the captured variables inside, meanwhile implementing the " "functionality via one of the `traits`: `Fn`, `FnMut`, or `FnOnce` for this " "unknown type. This type is assigned to the variable which is stored until " "calling." msgstr "" "当定义一个闭包时，编译器会隐式创建一个新的匿名结构来存储内部捕获的变量，同时" "通过 `Fn`、`FnMut` 或 `FnOnce` 这些 `trait` 之一为这个未知类型实现功能。这个" "类型被赋给变量并存储，直到被调用。" #: src/fn/closures/anonymity.md:22 msgid "" "Since this new type is of unknown type, any usage in a function will require " "generics. However, an unbounded type parameter `` would still be " "ambiguous and not be allowed. Thus, bounding by one of the `traits`: `Fn`, " "`FnMut`, or `FnOnce` (which it implements) is sufficient to specify its type." msgstr "" "由于这个新类型是未知类型，在函数中使用时就需要泛型。然而，一个无界的类型参数 " "`` 仍然会是模糊的，不被允许。因此，通过 `Fn`、`FnMut` 或 `FnOnce` 这些 " "`trait` 之一（它实现的）来约束就足以指定其类型。" #: src/fn/closures/anonymity.md:28 msgid "" "// `F` must implement `Fn` for a closure which takes no\n" "// inputs and returns nothing - exactly what is required\n" "// for `print`.\n" msgstr "" "// `F` 必须实现 `Fn` 用于一个不接受输入且不返回任何内容的闭包\n" "// - 这正是 `print` 所需要的\n" #: src/fn/closures/anonymity.md:39 msgid "" "// Capture `x` into an anonymous type and implement\n" " // `Fn` for it. Store it in `print`.\n" msgstr "" "// 将 `x` 捕获到一个匿名类型中并为其实现 `Fn`\n" " // 将其存储在 `print` 中\n" #: src/fn/closures/anonymity.md:49 msgid "" "[A thorough analysis](https://huonw.github.io/blog/2015/05/finding-closure-" "in-rust/), [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`]" "(https://doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://" "doc.rust-lang.org/std/ops/trait.FnOnce.html)" msgstr "" "[深入分析](https://huonw.github.io/blog/2015/05/finding-closure-in-rust/)、" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html)、[`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html) 和 [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" #: src/fn/closures/input_functions.md:3 msgid "" "Since closures may be used as arguments, you might wonder if the same can be " "said about functions. And indeed they can! If you declare a function that " "takes a closure as parameter, then any function that satisfies the trait " "bound of that closure can be passed as a parameter." msgstr "" "既然闭包可以作为参数使用，你可能会想知道函数是否也可以这样。确实可以！如果你" "声明一个函数，它接受一个闭包作为参数，那么任何满足该闭包 trait 约束的函数都可" "以作为参数传递。" #: src/fn/closures/input_functions.md:9 msgid "" "// Define a function which takes a generic `F` argument\n" "// bounded by `Fn`, and calls it\n" msgstr "// 定义一个函数，它接受一个由 `Fn` 约束的泛型参数 `F`，并调用它\n" #: src/fn/closures/input_functions.md:14 msgid "// Define a wrapper function satisfying the `Fn` bound\n" msgstr "// 定义一个满足 `Fn` 约束的包装函数\n" #: src/fn/closures/input_functions.md:17 msgid "\"I'm a function!\"" msgstr "\"我是函数！\"" #: src/fn/closures/input_functions.md:21 msgid "// Define a closure satisfying the `Fn` bound\n" msgstr "// 定义一个满足 `Fn` 约束的闭包\n" #: src/fn/closures/input_functions.md:22 msgid "\"I'm a closure!\"" msgstr "\"我是闭包！\"" #: src/fn/closures/input_functions.md:29 msgid "" "As an additional note, the `Fn`, `FnMut`, and `FnOnce` `traits` dictate how " "a closure captures variables from the enclosing scope." msgstr "" "另外需要注意的是，`Fn`、`FnMut` 和 `FnOnce` 这些 trait 决定了闭包如何从外部作" "用域捕获变量。" #: src/fn/closures/input_functions.md:34 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://doc.rust-" "lang.org/std/ops/trait.FnOnce.html)" msgstr "" "[`Fn`]、[`FnMut`] 和 [`FnOnce`]\n" "\n" "[`Fn`]: https://doc.rust-lang.org/std/ops/trait.Fn.html\n" "[`FnMut`]: https://doc.rust-lang.org/std/ops/trait.FnMut.html\n" "[`FnOnce`]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html" #: src/fn/closures/output_parameters.md:3 msgid "" "Closures as input parameters are possible, so returning closures as output " "parameters should also be possible. However, anonymous closure types are, by " "definition, unknown, so we have to use `impl Trait` to return them." msgstr "" "既然闭包可以作为输入参数，那么将闭包作为输出参数返回也应该是可行的。然而，匿" "名闭包类型本质上是未知的，因此我们必须使用 `impl Trait` 来返回它们。" #: src/fn/closures/output_parameters.md:8 msgid "The valid traits for returning a closure are:" msgstr "可用于返回闭包的有效 trait 包括：" #: src/fn/closures/output_parameters.md:10 msgid "`Fn`" msgstr "`Fn`" #: src/fn/closures/output_parameters.md:11 msgid "`FnMut`" msgstr "`FnMut`" #: src/fn/closures/output_parameters.md:12 msgid "`FnOnce`" msgstr "`FnOnce`" #: src/fn/closures/output_parameters.md:14 msgid "" "Beyond this, the `move` keyword must be used, which signals that all " "captures occur by value. This is required because any captures by reference " "would be dropped as soon as the function exited, leaving invalid references " "in the closure." msgstr "" "此外，必须使用 `move` 关键字，它表示所有捕获都是按值进行的。这是必要的，因为" "任何通过引用捕获的变量都会在函数退出时被丢弃，从而在闭包中留下无效的引用。" #: src/fn/closures/output_parameters.md:21 msgid "\"Fn\"" msgstr "\"Fn\"" #: src/fn/closures/output_parameters.md:23 #: src/fn/closures/output_parameters.md:29 #: src/fn/closures/output_parameters.md:35 msgid "\"This is a: {}\"" msgstr "\"这是一个：{}\"" #: src/fn/closures/output_parameters.md:27 msgid "\"FnMut\"" msgstr "\"FnMut\"" #: src/fn/closures/output_parameters.md:33 msgid "\"FnOnce\"" msgstr "\"FnOnce\"" #: src/fn/closures/output_parameters.md:51 msgid "" "[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://" "doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md) " "and [impl Trait](../../trait/impl_trait.md)." msgstr "" "[`Fn`]、[`FnMut`]、[泛型]和 [impl Trait]\n" "\n" "[`Fn`]: https://doc.rust-lang.org/std/ops/trait.Fn.html\n" "[`FnMut`]: https://doc.rust-lang.org/std/ops/trait.FnMut.html\n" "[泛型]: ../../generics.md\n" "[impl Trait]: ../../trait/impl_trait.md" #: src/fn/closures/closure_examples.md:3 msgid "" "This section contains a few examples of using closures from the `std` " "library." msgstr "本节包含一些使用 `std` 库中闭包的示例。" #: src/fn/closures/closure_examples/iter_any.md:3 msgid "" "`Iterator::any` is a function which when passed an iterator, will return " "`true` if any element satisfies the predicate. Otherwise `false`. Its " "signature:" msgstr "" "`Iterator::any` 是一个函数，它接受一个迭代器作为参数。如果任何元素满足给定的" "条件，则返回 `true`，否则返回 `false`。其签名如下：" #: src/fn/closures/closure_examples/iter_any.md:9 #: src/fn/closures/closure_examples/iter_find.md:9 msgid "// The type being iterated over.\n" msgstr "// 被迭代的类型\n" #: src/fn/closures/closure_examples/iter_any.md:12 msgid "" "// `any` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" "// `any` 接受 `&mut self`，意味着调用者可能被借用\n" " // 和修改，但不会被消耗\n" #: src/fn/closures/closure_examples/iter_any.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `Self::Item` states it takes\n" " // arguments to the closure by value.\n" msgstr "" "// `FnMut` 表示任何捕获的变量最多只能被修改，不能被消耗\n" " // `Self::Item` 表示它通过值将参数传递给闭包\n" #: src/fn/closures/closure_examples/iter_any.md:27 msgid "// `iter()` for vecs yields `&i32`. Destructure to `i32`.\n" msgstr "// 对 vec 使用 `iter()` 产生 `&i32`，解构为 `i32`\n" #: src/fn/closures/closure_examples/iter_any.md:28 msgid "\"2 in vec1: {}\"" msgstr "\"2 在 vec1 中：{}\"" #: src/fn/closures/closure_examples/iter_any.md:29 msgid "// `into_iter()` for vecs yields `i32`. No destructuring required.\n" msgstr "// 对 vec 使用 `into_iter()` 产生 `i32`，无需解构\n" #: src/fn/closures/closure_examples/iter_any.md:30 msgid "\"2 in vec2: {}\"" msgstr "\"2 在 vec2 中：{}\"" #: src/fn/closures/closure_examples/iter_any.md:32 msgid "" "// `iter()` only borrows `vec1` and its elements, so they can be used again\n" msgstr "// `iter()` 只借用 `vec1` 及其元素，所以它们可以再次使用\n" #: src/fn/closures/closure_examples/iter_any.md:33 msgid "\"vec1 len: {}\"" msgstr "\"vec1 长度：{}\"" #: src/fn/closures/closure_examples/iter_any.md:34 msgid "\"First element of vec1 is: {}\"" msgstr "\"vec1 的第一个元素是：{}\"" #: src/fn/closures/closure_examples/iter_any.md:35 msgid "" "// `into_iter()` does move `vec2` and its elements, so they cannot be used " "again\n" " // println!(\"First element of vec2 is: {}\", vec2[0]);\n" " // println!(\"vec2 len: {}\", vec2.len());\n" " // TODO: uncomment two lines above and see compiler errors.\n" msgstr "" "// `into_iter()` 会移动 `vec2` 及其元素，所以它们不能再次使用\n" " // println!(\"vec2 的第一个元素是：{}\", vec2[0]);\n" " // println!(\"vec2 长度：{}\", vec2.len());\n" " // TODO：取消上面两行的注释，观察编译器错误\n" #: src/fn/closures/closure_examples/iter_any.md:43 msgid "// `iter()` for arrays yields `&i32`.\n" msgstr "// 对数组使用 `iter()` 产生 `&i32`\n" #: src/fn/closures/closure_examples/iter_any.md:44 msgid "\"2 in array1: {}\"" msgstr "\"2 在 array1 中：{}\"" #: src/fn/closures/closure_examples/iter_any.md:45 msgid "// `into_iter()` for arrays yields `i32`.\n" msgstr "// 对数组使用 `into_iter()` 产生 `i32`\n" #: src/fn/closures/closure_examples/iter_any.md:46 msgid "\"2 in array2: {}\"" msgstr "\"2 在 array2 中：{}\"" #: src/fn/closures/closure_examples/iter_any.md:52 msgid "" "[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.any)" msgstr "" "[`std::iter::Iterator::any`]\n" "\n" "[`std::iter::Iterator::any`]: https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.any" #: src/fn/closures/closure_examples/iter_find.md:3 msgid "" "`Iterator::find` is a function which iterates over an iterator and searches " "for the first value which satisfies some condition. If none of the values " "satisfy the condition, it returns `None`. Its signature:" msgstr "" "`Iterator::find` 是一个函数，它遍历迭代器并搜索满足特定条件的第一个值。如果没" "有值满足条件，则返回 `None`。其签名如下：" #: src/fn/closures/closure_examples/iter_find.md:12 msgid "" "// `find` takes `&mut self` meaning the caller may be borrowed\n" " // and modified, but not consumed.\n" msgstr "" "// `find` 接受 `&mut self`，这意味着调用者可能被借用\n" " // 和修改，但不会被消耗。\n" #: src/fn/closures/closure_examples/iter_find.md:15 msgid "" "// `FnMut` meaning any captured variable may at most be\n" " // modified, not consumed. `&Self::Item` states it takes\n" " // arguments to the closure by reference.\n" msgstr "" "// `FnMut` 表示任何捕获的变量最多只能被修改，不能被消耗。\n" " // `&Self::Item` 表示它通过引用将参数传递给闭包。\n" #: src/fn/closures/closure_examples/iter_find.md:27 msgid "// `iter()` for vecs yields `&i32`.\n" msgstr "// 对 vec 使用 `iter()` 会产生 `&i32`。\n" #: src/fn/closures/closure_examples/iter_find.md:29 msgid "// `into_iter()` for vecs yields `i32`.\n" msgstr "// 对 vec 使用 `into_iter()` 会产生 `i32`。\n" #: src/fn/closures/closure_examples/iter_find.md:32 msgid "" "// `iter()` for vecs yields `&i32`, and we want to reference one of its\n" " // items, so we have to destructure `&&i32` to `i32`\n" msgstr "" "// 对 vec 使用 `iter()` 会产生 `&i32`，而我们想要引用其中的一个\n" " // 元素，所以我们必须将 `&&i32` 解构为 `i32`\n" #: src/fn/closures/closure_examples/iter_find.md:34 msgid "\"Find 2 in vec1: {:?}\"" msgstr "\"在 vec1 中查找 2：{:?}\"" #: src/fn/closures/closure_examples/iter_find.md:35 msgid "" "// `into_iter()` for vecs yields `i32`, and we want to reference one of\n" " // its items, so we have to destructure `&i32` to `i32`\n" msgstr "" "// 对 vec 使用 `into_iter()` 会产生 `i32`，而我们想要引用其中的\n" " // 一个元素，所以我们必须将 `&i32` 解构为 `i32`\n" #: src/fn/closures/closure_examples/iter_find.md:37 msgid "\"Find 2 in vec2: {:?}\"" msgstr "\"在 vec2 中查找 2：{:?}\"" #: src/fn/closures/closure_examples/iter_find.md:42 msgid "// `iter()` for arrays yields `&&i32`\n" msgstr "// 对数组使用 `iter()` 会产生 `&&i32`\n" #: src/fn/closures/closure_examples/iter_find.md:43 msgid "\"Find 2 in array1: {:?}\"" msgstr "\"在 array1 中查找 2：{:?}\"" #: src/fn/closures/closure_examples/iter_find.md:44 msgid "// `into_iter()` for arrays yields `&i32`\n" msgstr "// 对数组使用 `into_iter()` 会产生 `&i32`\n" #: src/fn/closures/closure_examples/iter_find.md:45 msgid "\"Find 2 in array2: {:?}\"" msgstr "\"在 array2 中查找 2：{:?}\"" #: src/fn/closures/closure_examples/iter_find.md:49 msgid "" "`Iterator::find` gives you a reference to the item. But if you want the " "_index_ of the item, use `Iterator::position`." msgstr "" "`Iterator::find` 返回元素的引用。如果需获取元素的**索引**，则使用 " "`Iterator::position`。" #: src/fn/closures/closure_examples/iter_find.md:56 msgid "" "// `iter()` for vecs yields `&i32` and `position()` does not take a " "reference, so\n" " // we have to destructure `&i32` to `i32`\n" msgstr "" "// 对 vec 使用 `iter()` 会产生 `&i32`，而 `position()` 不接受引用，所以\n" " // 我们必须将 `&i32` 解构为 `i32`\n" #: src/fn/closures/closure_examples/iter_find.md:61 msgid "" "// `into_iter()` for vecs yields `i32` and `position()` does not take a " "reference, so\n" " // we do not have to destructure\n" msgstr "" "// 对 vec 使用 `into_iter()` 会产生 `i32`，而 `position()` 不接受引用，所以\n" " // 我们不需要进行解构\n" #: src/fn/closures/closure_examples/iter_find.md:70 msgid "" "[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find)" msgstr "" "[`std::iter::Iterator::find`]\n" "\n" "[`std::iter::Iterator::find`]: https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find" #: src/fn/closures/closure_examples/iter_find.md:72 msgid "" "[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find_map)" msgstr "" "[`std::iter::Iterator::find_map`]\n" "\n" "[`std::iter::Iterator::find_map`]: https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.find_map" #: src/fn/closures/closure_examples/iter_find.md:74 msgid "" "[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.position)" msgstr "" "[`std::iter::Iterator::position`]\n" "\n" "[`std::iter::Iterator::position`]: https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.position" #: src/fn/closures/closure_examples/iter_find.md:76 msgid "" "[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.rposition)" msgstr "" "[`std::iter::Iterator::rposition`]\n" "\n" "[`std::iter::Iterator::rposition`]: https://doc.rust-lang.org/std/iter/" "trait.Iterator.html#method.rposition" #: src/fn/hof.md:3 msgid "" "Rust provides Higher Order Functions (HOF). These are functions that take " "one or more functions and/or produce a more useful function. HOFs and lazy " "iterators give Rust its functional flavor." msgstr "" "Rust 提供了高阶函数（Higher Order Functions，HOF）。这些函数接受一个或多个函" "数作为参数，并/或产生一个更有用的函数。HOF 和惰性迭代器赋予了 Rust 函数式编程" "的特性。" #: src/fn/hof.md:13 msgid "\"Find the sum of all the numbers with odd squares under 1000\"" msgstr "\"找出所有平方为奇数且小于 1000 的数字之和\"" #: src/fn/hof.md:16 msgid "" "// Imperative approach\n" " // Declare accumulator variable\n" msgstr "" "// 命令式方法\n" " // 声明累加器变量\n" #: src/fn/hof.md:19 msgid "// Iterate: 0, 1, 2, ... to infinity\n" msgstr "// 迭代：从 0, 1, 2, ... 到无穷大\n" #: src/fn/hof.md:21 msgid "// Square the number\n" msgstr "// 计算数字的平方\n" #: src/fn/hof.md:25 msgid "// Break loop if exceeded the upper limit\n" msgstr "// 如果超过上限则跳出循环\n" #: src/fn/hof.md:28 msgid "// Accumulate value, if it's odd\n" msgstr "// 如果是奇数，则累加值\n" #: src/fn/hof.md:32 msgid "\"imperative style: {}\"" msgstr "\"命令式风格：{}\"" #: src/fn/hof.md:34 msgid "// Functional approach\n" msgstr "// 函数式方法\n" #: src/fn/hof.md:36 msgid "// All natural numbers squared\n" msgstr "// 所有自然数的平方\n" #: src/fn/hof.md:37 msgid "// Below upper limit\n" msgstr "// 小于上限\n" #: src/fn/hof.md:38 msgid "// That are odd\n" msgstr "// 筛选奇数\n" #: src/fn/hof.md:39 msgid "// Sum them\n" msgstr "// 求和\n" #: src/fn/hof.md:40 msgid "\"functional style: {}\"" msgstr "\"函数式风格：{}\"" #: src/fn/hof.md:44 msgid "" "[Option](https://doc.rust-lang.org/core/option/enum.Option.html) and " "[Iterator](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "implement their fair share of HOFs." msgstr "" "[Option] 和 [Iterator] 实现了相当多的高阶函数。\n" "\n" "[Option]: https://doc.rust-lang.org/core/option/enum.Option.html\n" "[Iterator]: https://doc.rust-lang.org/core/iter/trait.Iterator.html" #: src/fn/diverging.md:3 msgid "" "Diverging functions never return. They are marked using `!`, which is an " "empty type." msgstr "发散函数永不返回。它们使用 `!` 标记，这是一个空类型。" #: src/fn/diverging.md:7 src/fn/diverging.md:35 msgid "\"This call never returns.\"" msgstr "\"此调用永不返回。\"" #: src/fn/diverging.md:11 msgid "" "As opposed to all the other types, this one cannot be instantiated, because " "the set of all possible values this type can have is empty. Note that, it is " "different from the `()` type, which has exactly one possible value." msgstr "" "与所有其他类型相反，这个类型不能被实例化，因为这个类型可能拥有的所有可能值的" "集合是空的。注意，它与 `()` 类型不同，后者恰好有一个可能的值。" #: src/fn/diverging.md:15 msgid "" "For example, this function returns as usual, although there is no " "information in the return value." msgstr "例如，这个函数像往常一样返回，尽管返回值中没有任何信息。" #: src/fn/diverging.md:25 msgid "\"This function returns and you can see this line.\"" msgstr "\"这个函数返回了，你可以看到这一行。\"" #: src/fn/diverging.md:29 msgid "" "As opposed to this function, which will never return the control back to the " "caller." msgstr "与之相对的是这个函数，它永远不会将控制权返回给调用者。" #: src/fn/diverging.md:36 msgid "\"You will never see this line!\"" msgstr "\"你永远不会看到这一行！\"" #: src/fn/diverging.md:40 msgid "" "Although this might seem like an abstract concept, it is actually very " "useful and often handy. The main advantage of this type is that it can be " "cast to any other type, making it versatile in situations where an exact " "type is required, such as in match branches. This flexibility allows us to " "write code like this:" msgstr "" "虽然这看起来像是一个抽象概念，但它实际上非常有用且经常派上用场。这种类型的主" "要优势是它可以被转换为任何其他类型，这使得它在需要精确类型的情况下非常灵活，" "比如在 match 分支中。这种灵活性允许我们编写如下代码：" #: src/fn/diverging.md:50 msgid "" "// Notice that the return type of this match expression must be u32\n" " // because of the type of the \"addition\" variable.\n" msgstr "" "// 注意这个 match 表达式的返回类型必须是 u32，\n" " // 因为 \"addition\" 变量的类型是 u32。\n" #: src/fn/diverging.md:53 msgid "// The \"i\" variable is of type u32, which is perfectly fine.\n" msgstr "// \"i\" 变量的类型是 u32，这完全没问题。\n" #: src/fn/diverging.md:55 msgid "" "// On the other hand, the \"continue\" expression does not return\n" " // u32, but it is still fine, because it never returns and " "therefore\n" " // does not violate the type requirements of the match " "expression.\n" msgstr "" "// 另一方面，\"continue\" 表达式不返回 u32，\n" " // 但这仍然可以，因为它永远不会返回，\n" " // 因此不违反 match 表达式的类型要求。\n" #: src/fn/diverging.md:64 msgid "\"Sum of odd numbers up to 9 (excluding): {}\"" msgstr "\"9 以下（不包括 9）的奇数之和：{}\"" #: src/fn/diverging.md:68 msgid "" "It is also the return type of functions that loop forever (e.g. `loop {}`) " "like network servers or functions that terminate the process (e.g. `exit()`)." msgstr "" "它也是永远循环的函数（例如 `loop {}`）的返回类型，比如网络服务器，或终止进程" "的函数（例如 `exit()`）。" #: src/mod.md:3 msgid "" "Rust provides a powerful module system that can be used to hierarchically " "split code in logical units (modules), and manage visibility (public/" "private) between them." msgstr "" "Rust 提供了一个强大的模块系统，可以用来将代码分层地拆分成逻辑单元（模块），并" "管理它们之间的可见性（公有/私有）。" #: src/mod.md:7 msgid "" "A module is a collection of items: functions, structs, traits, `impl` " "blocks, and even other modules." msgstr "" "一个模块是一系列项的集合：函数、结构体、trait、`impl` 块，甚至其他模块。" #: src/mod/visibility.md:3 msgid "" "By default, the items in a module have private visibility, but this can be " "overridden with the `pub` modifier. Only the public items of a module can be " "accessed from outside the module scope." msgstr "" "默认情况下，模块中的项具有私有可见性，但可以使用 `pub` 修饰符来覆盖这一默认行" "为。只有模块中的公有项可以从模块作用域外部访问。" #: src/mod/visibility.md:8 msgid "// A module named `my_mod`\n" msgstr "// 一个名为 `my_mod` 的模块\n" #: src/mod/visibility.md:10 msgid "// Items in modules default to private visibility.\n" msgstr "// 模块中的项默认为私有可见性。\n" #: src/mod/visibility.md:12 msgid "\"called `my_mod::private_function()`\"" msgstr "\"调用了 `my_mod::private_function()`\"" #: src/mod/visibility.md:15 msgid "// Use the `pub` modifier to override default visibility.\n" msgstr "// 使用 `pub` 修饰符来覆盖默认的可见性。\n" #: src/mod/visibility.md:17 msgid "\"called `my_mod::function()`\"" msgstr "\"调用了 `my_mod::function()`\"" #: src/mod/visibility.md:20 msgid "" "// Items can access other items in the same module,\n" " // even when private.\n" msgstr "" "// 同一模块中的项可以访问其他项，\n" " // 即使是私有的。\n" #: src/mod/visibility.md:23 msgid "\"called `my_mod::indirect_access()`, that\\n> \"" msgstr "\"调用了 `my_mod::indirect_access()`，它\\n> \"" #: src/mod/visibility.md:27 msgid "// Modules can also be nested\n" msgstr "// 模块也可以嵌套\n" #: src/mod/visibility.md:30 msgid "\"called `my_mod::nested::function()`\"" msgstr "\"调用了 `my_mod::nested::function()`\"" #: src/mod/visibility.md:35 msgid "\"called `my_mod::nested::private_function()`\"" msgstr "\"调用了 `my_mod::nested::private_function()`\"" #: src/mod/visibility.md:38 msgid "" "// Functions declared using `pub(in path)` syntax are only visible\n" " // within the given path. `path` must be a parent or ancestor " "module\n" msgstr "" "// 使用 `pub(in path)` 语法声明的函数只在给定的路径中可见。\n" " // `path` 必须是父模块或祖先模块\n" #: src/mod/visibility.md:41 msgid "\"called `my_mod::nested::public_function_in_my_mod()`, that\\n> \"" msgstr "\"调用了 `my_mod::nested::public_function_in_my_mod()`，它\\n> \"" #: src/mod/visibility.md:45 msgid "" "// Functions declared using `pub(self)` syntax are only visible within\n" " // the current module, which is the same as leaving them private\n" msgstr "" "// 使用 `pub(self)` 语法声明的函数只在当前模块中可见，\n" " // 这与将它们保持为私有是一样的\n" #: src/mod/visibility.md:48 msgid "\"called `my_mod::nested::public_function_in_nested()`\"" msgstr "\"调用了 `my_mod::nested::public_function_in_nested()`\"" #: src/mod/visibility.md:51 msgid "" "// Functions declared using `pub(super)` syntax are only visible within\n" " // the parent module\n" msgstr "" "// 使用 `pub(super)` 语法声明的函数仅在父模块中可见\n" " \n" #: src/mod/visibility.md:54 msgid "\"called `my_mod::nested::public_function_in_super_mod()`\"" msgstr "\"调用了 `my_mod::nested::public_function_in_super_mod()`\"" #: src/mod/visibility.md:59 msgid "\"called `my_mod::call_public_function_in_my_mod()`, that\\n> \"" msgstr "\"调用了 `my_mod::call_public_function_in_my_mod()`，它\\n> \"" #: src/mod/visibility.md:61 msgid "\"> \"" msgstr "\"> \"" #: src/mod/visibility.md:65 msgid "// pub(crate) makes functions visible only within the current crate\n" msgstr "// pub(crate) 使函数仅在当前 crate 内可见\n" #: src/mod/visibility.md:67 msgid "\"called `my_mod::public_function_in_crate()`\"" msgstr "\"调用了 `my_mod::public_function_in_crate()`\"" #: src/mod/visibility.md:70 msgid "// Nested modules follow the same rules for visibility\n" msgstr "// 嵌套模块遵循相同的可见性规则\n" #: src/mod/visibility.md:74 msgid "\"called `my_mod::private_nested::function()`\"" msgstr "\"调用了 `my_mod::private_nested::function()`\"" #: src/mod/visibility.md:77 msgid "" "// Private parent items will still restrict the visibility of a child item,\n" " // even if it is declared as visible within a bigger scope.\n" msgstr "" "// 私有父项仍会限制子项的可见性，\n" " // 即使子项被声明为在更大范围内可见。\n" #: src/mod/visibility.md:81 msgid "\"called `my_mod::private_nested::restricted_function()`\"" msgstr "\"调用了 `my_mod::private_nested::restricted_function()`\"" #: src/mod/visibility.md:87 src/mod/use.md:25 src/mod/super.md:8 #: src/mod/split.md:24 msgid "\"called `function()`\"" msgstr "\"调用了 `function()`\"" #: src/mod/visibility.md:91 msgid "" "// Modules allow disambiguation between items that have the same name.\n" msgstr "// 模块允许消除同名项之间的歧义。\n" #: src/mod/visibility.md:95 msgid "" "// Public items, including those inside nested modules, can be\n" " // accessed from outside the parent module.\n" msgstr "// 公有项（包括嵌套模块内的）可以从父模块外部访问。\n" #: src/mod/visibility.md:101 msgid "// pub(crate) items can be called from anywhere in the same crate\n" msgstr "// pub(crate) 项可以在同一个 crate 的任何地方调用\n" #: src/mod/visibility.md:104 msgid "" "// pub(in path) items can only be called from within the module specified\n" " // Error! function `public_function_in_my_mod` is private\n" " //my_mod::nested::public_function_in_my_mod();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// pub(in path) 项只能在指定的模块内调用\n" " // 错误！函数 `public_function_in_my_mod` 是私有的\n" " //my_mod::nested::public_function_in_my_mod();\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/visibility.md:109 msgid "" "// Private items of a module cannot be directly accessed, even if\n" " // nested in a public module:\n" msgstr "// 模块的私有项不能被直接访问，即使它们嵌套在公有模块中：\n" #: src/mod/visibility.md:112 msgid "" "// Error! `private_function` is private\n" " //my_mod::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`private_function` 是私有的\n" " //my_mod::private_function();\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/visibility.md:116 msgid "" "// Error! `private_function` is private\n" " //my_mod::nested::private_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`private_function` 是私有的\n" " //my_mod::nested::private_function();\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/visibility.md:120 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`private_nested` 是一个私有模块\n" " //my_mod::private_nested::function();\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/visibility.md:124 msgid "" "// Error! `private_nested` is a private module\n" " //my_mod::private_nested::restricted_function();\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`private_nested` 是一个私有模块\n" " //my_mod::private_nested::restricted_function();\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/struct_visibility.md:3 msgid "" "Structs have an extra level of visibility with their fields. The visibility " "defaults to private, and can be overridden with the `pub` modifier. This " "visibility only matters when a struct is accessed from outside the module " "where it is defined, and has the goal of hiding information (encapsulation)." msgstr "" "结构体的字段具有额外的可见性级别。字段默认为私有，可以使用 `pub` 修饰符来覆" "盖。这种可见性只在从结构体定义模块外部访问时才有意义，其目的是实现信息隐藏" "（封装）。" #: src/mod/struct_visibility.md:10 msgid "// A public struct with a public field of generic type `T`\n" msgstr "// 一个具有泛型类型 `T` 公有字段的公有结构体\n" #: src/mod/struct_visibility.md:15 msgid "// A public struct with a private field of generic type `T`\n" msgstr "// 一个具有泛型类型 `T` 私有字段的公有结构体\n" #: src/mod/struct_visibility.md:21 msgid "// A public constructor method\n" msgstr "// 一个公有的构造方法\n" #: src/mod/struct_visibility.md:31 msgid "// Public structs with public fields can be constructed as usual\n" msgstr "// 具有公有字段的公有结构体可以正常构造\n" #: src/mod/struct_visibility.md:32 msgid "\"public information\"" msgstr "\"公开信息\"" #: src/mod/struct_visibility.md:34 msgid "// and their fields can be normally accessed.\n" msgstr "// 且可以正常访问其字段。\n" #: src/mod/struct_visibility.md:35 msgid "\"The open box contains: {}\"" msgstr "\"打开的盒子包含：{}\"" #: src/mod/struct_visibility.md:37 msgid "" "// Public structs with private fields cannot be constructed using field " "names.\n" " // Error! `ClosedBox` has private fields\n" " //let closed_box = my::ClosedBox { contents: \"classified " "information\" };\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 具有私有字段的公有结构体不能使用字段名来构造。\n" " // 错误！`ClosedBox` 有私有字段\n" " //let closed_box = my::ClosedBox { contents: \"机密信息\" };\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/struct_visibility.md:42 msgid "" "// However, structs with private fields can be created using\n" " // public constructors\n" msgstr "// 然而，具有私有字段的结构体可以使用公有构造函数创建\n" #: src/mod/struct_visibility.md:44 msgid "\"classified information\"" msgstr "\"机密信息\"" #: src/mod/struct_visibility.md:46 msgid "" "// and the private fields of a public struct cannot be accessed.\n" " // Error! The `contents` field is private\n" " //println!(\"The closed box contains: {}\", _closed_box.contents);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 且无法访问公有结构体的私有字段。\n" " // 错误！`contents` 字段是私有的\n" " //println!(\"封闭的盒子包含：{}\", _closed_box.contents);\n" " // TODO ^ 尝试取消此行注释\n" #: src/mod/struct_visibility.md:55 msgid "[generics](../generics.md) and [methods](../fn/methods.md)" msgstr "[泛型](../generics.md)和[方法](../fn/methods.md)" #: src/mod/use.md:3 msgid "" "The `use` declaration can be used to bind a full path to a new name, for " "easier access. It is often used like this:" msgstr "" "`use` 声明可以将完整路径绑定到新名称，以便更轻松地访问。它通常这样使用：" #: src/mod/use.md:18 msgid "You can use the `as` keyword to bind imports to a different name:" msgstr "你可以使用 `as` 关键字将导入绑定到不同的名称：" #: src/mod/use.md:21 msgid "// Bind the `deeply::nested::function` path to `other_function`.\n" msgstr "// 将 `deeply::nested::function` 路径绑定到 `other_function`。\n" #: src/mod/use.md:31 msgid "\"called `deeply::nested::function()`\"" msgstr "\"调用了 `deeply::nested::function()`\"" #: src/mod/use.md:37 msgid "// Easier access to `deeply::nested::function`\n" msgstr "// 更方便地访问 `deeply::nested::function`\n" #: src/mod/use.md:40 msgid "\"Entering block\"" msgstr "\"进入代码块\"" #: src/mod/use.md:42 msgid "" "// This is equivalent to `use deeply::nested::function as function`.\n" " // This `function()` will shadow the outer one.\n" msgstr "" "// 这等同于 `use deeply::nested::function as function`。\n" " // 这个 `function()` 将遮蔽外部的同名函数。\n" #: src/mod/use.md:46 msgid "" "// `use` bindings have a local scope. In this case, the\n" " // shadowing of `function()` is only in this block.\n" msgstr "" "// `use` 绑定具有局部作用域。在这种情况下，\n" " // `function()` 的遮蔽仅在此代码块内有效。\n" #: src/mod/use.md:50 msgid "\"Leaving block\"" msgstr "\"离开代码块\"" #: src/mod/super.md:3 msgid "" "The `super` and `self` keywords can be used in the path to remove ambiguity " "when accessing items and to prevent unnecessary hardcoding of paths." msgstr "" "`super` 和 `self` 关键字可以在路径中使用，以消除访问项目时的歧义，并避免不必" "要的路径硬编码。" #: src/mod/super.md:13 msgid "\"called `cool::function()`\"" msgstr "\"调用了 `cool::function()`\"" #: src/mod/super.md:19 src/mod/split.md:49 msgid "\"called `my::function()`\"" msgstr "\"调用了 `my::function()`\"" #: src/mod/super.md:24 msgid "\"called `my::cool::function()`\"" msgstr "\"调用了 `my::cool::function()`\"" #: src/mod/super.md:29 msgid "// Let's access all the functions named `function` from this scope!\n" msgstr "// 让我们从这个作用域访问所有名为 `function` 的函数！\n" #: src/mod/super.md:30 msgid "\"called `my::indirect_call()`, that\\n> \"" msgstr "\"调用了 `my::indirect_call()`，它\\n> \"" #: src/mod/super.md:32 msgid "" "// The `self` keyword refers to the current module scope - in this case " "`my`.\n" " // Calling `self::function()` and calling `function()` directly both " "give\n" " // the same result, because they refer to the same function.\n" msgstr "" "// `self` 关键字指的是当前模块作用域 - 在这里是 `my`。\n" " // 调用 `self::function()` 和直接调用 `function()` 都会\n" " // 得到相同的结果，因为它们指向同一个函数。\n" #: src/mod/super.md:38 msgid "// We can also use `self` to access another module inside `my`:\n" msgstr "// 我们也可以使用 `self` 来访问 `my` 内的另一个模块：\n" #: src/mod/super.md:41 msgid "" "// The `super` keyword refers to the parent scope (outside the `my` " "module).\n" msgstr "// `super` 关键字指的是父作用域（`my` 模块之外）。\n" #: src/mod/super.md:44 msgid "" "// This will bind to the `cool::function` in the *crate* scope.\n" " // In this case the crate scope is the outermost scope.\n" msgstr "" "// 这将绑定到 *crate* 作用域中的 `cool::function`。\n" " // 在这种情况下，crate 作用域是最外层作用域。\n" #: src/mod/split.md:3 msgid "" "Modules can be mapped to a file/directory hierarchy. Let's break down the " "[visibility example](visibility.md) in files:" msgstr "" "模块可以映射到文件/目录层次结构。让我们将[可见性示例](visibility.md)拆分成多" "个文件：" #: src/mod/split.md:16 msgid "In `split.rs`:" msgstr "在 `split.rs` 文件中：" #: src/mod/split.md:19 msgid "" "// This declaration will look for a file named `my.rs` and will\n" "// insert its contents inside a module named `my` under this scope\n" msgstr "" "// 这个声明会查找名为 `my.rs` 的文件，并将其内容\n" "// 插入到当前作用域下名为 `my` 的模块中\n" #: src/mod/split.md:39 msgid "In `my.rs`:" msgstr "在 `my.rs` 文件中：" #: src/mod/split.md:42 msgid "" "// Similarly `mod inaccessible` and `mod nested` will locate the " "`nested.rs`\n" "// and `inaccessible.rs` files and insert them here under their respective\n" "// modules\n" msgstr "" "// 同样，`mod inaccessible` 和 `mod nested` 会分别定位到\n" "// `nested.rs` 和 `inaccessible.rs` 文件，\n" "// 并将它们的内容插入到这里对应的模块中\n" #: src/mod/split.md:53 msgid "\"called `my::private_function()`\"" msgstr "\"调用了 `my::private_function()`\"" #: src/mod/split.md:57 msgid "\"called `my::indirect_access()`, that\\n> \"" msgstr "\"调用了 `my::indirect_access()`，它\\n> \"" #: src/mod/split.md:63 msgid "In `my/nested.rs`:" msgstr "在 `my/nested.rs` 文件中：" #: src/mod/split.md:67 msgid "\"called `my::nested::function()`\"" msgstr "\"调用了 `my::nested::function()`\"" #: src/mod/split.md:72 msgid "\"called `my::nested::private_function()`\"" msgstr "\"调用了 `my::nested::private_function()`\"" #: src/mod/split.md:76 msgid "In `my/inaccessible.rs`:" msgstr "在 `my/inaccessible.rs` 文件中：" #: src/mod/split.md:81 msgid "\"called `my::inaccessible::public_function()`\"" msgstr "\"调用了 `my::inaccessible::public_function()`\"" #: src/mod/split.md:85 msgid "Let's check that things still work as before:" msgstr "让我们检查一下是否一切仍然如之前一样正常运行：" #: src/crates.md:3 msgid "" "A crate is a compilation unit in Rust. Whenever `rustc some_file.rs` is " "called, `some_file.rs` is treated as the _crate file_. If `some_file.rs` has " "`mod` declarations in it, then the contents of the module files would be " "inserted in places where `mod` declarations in the crate file are found, " "_before_ running the compiler over it. In other words, modules do _not_ get " "compiled individually, only crates get compiled." msgstr "" "在 Rust 中，crate 是一个编译单元。每当执行 `rustc some_file.rs` 时，" "`some_file.rs` 就被视为**crate 文件**。如果 `some_file.rs` 中包含 `mod` 声" "明，那么模块文件的内容会在编译器处理之前被插入到 crate 文件中 `mod` 声明的位" "置。换句话说，模块**不会**被单独编译，只有 crate 才会被编译。" #: src/crates.md:10 msgid "" "A crate can be compiled into a binary or into a library. By default, `rustc` " "will produce a binary from a crate. This behavior can be overridden by " "passing the `--crate-type` flag to `lib`." msgstr "" "一个 crate 可以被编译成二进制文件或库。默认情况下，`rustc` 会将 crate 编译成" "二进制文件。通过向 `rustc` 传递 `--crate-type` 标志并指定 `lib`，可以改变这一" "默认行为。" #: src/crates/lib.md:3 msgid "Let's create a library, and then see how to link it to another crate." msgstr "让我们创建一个库，然后看看如何将它链接到另一个 crate。" #: src/crates/lib.md:5 msgid "In `rary.rs`:" msgstr "在 `rary.rs` 文件中：" #: src/crates/lib.md:9 src/attribute/crate.md:19 msgid "\"called rary's `public_function()`\"" msgstr "\"调用了 rary 的 `public_function()`\"" #: src/crates/lib.md:13 src/attribute/crate.md:23 msgid "\"called rary's `private_function()`\"" msgstr "\"调用了 rary 的 `private_function()`\"" #: src/crates/lib.md:17 src/attribute/crate.md:27 msgid "\"called rary's `indirect_access()`, that\\n> \"" msgstr "\"调用了 rary 的 `indirect_access()`，它\\n> \"" #: src/crates/lib.md:29 msgid "" "Libraries get prefixed with \"lib\", and by default they get named after " "their crate file, but this default name can be overridden by passing the `--" "crate-name` option to `rustc` or by using the [`crate_name` attribute](../" "attribute/crate.md)." msgstr "" "库文件名会自动添加 \"lib\" 前缀，默认使用 crate 文件的名称。但可以通过向 " "`rustc` 传递 `--crate-name` 选项或使用 [`crate_name` 属性](../attribute/" "crate.md) 来覆盖这个默认名称。" #: src/crates/using_lib.md:3 msgid "" "To link a crate to this new library you may use `rustc`'s `--extern` flag. " "All of its items will then be imported under a module named the same as the " "library. This module generally behaves the same way as any other module." msgstr "" "要将 crate 链接到这个新库，可以使用 `rustc` 的 `--extern` 标志。库中的所有项" "目都会被导入到一个与库同名的模块下。这个模块的行为通常与其他模块相同。" #: src/crates/using_lib.md:8 msgid "" "// extern crate rary; // May be required for Rust 2015 edition or earlier\n" msgstr "// extern crate rary; // Rust 2015 版本或更早版本可能需要此声明\n" #: src/crates/using_lib.md:13 msgid "" "// Error! `private_function` is private\n" " //rary::private_function();\n" msgstr "" "// 错误！`private_function` 是私有的\n" " //rary::private_function();\n" #: src/cargo.md:3 msgid "" "`cargo` is the official Rust package management tool. It has lots of really " "useful features to improve code quality and developer velocity! These include" msgstr "" "`cargo` 是 Rust 的官方包管理工具。它提供了许多非常有用的功能，可以提高代码质" "量和开发效率！这些功能包括：" #: src/cargo.md:6 msgid "" "Dependency management and integration with [crates.io](https://crates.io) " "(the official Rust package registry)" msgstr "" "依赖管理和与 [crates.io](https://crates.io)（Rust 官方包注册中心）的集成" #: src/cargo.md:8 msgid "Awareness of unit tests" msgstr "支持单元测试" #: src/cargo.md:9 msgid "Awareness of benchmarks" msgstr "支持基准测试" #: src/cargo.md:11 msgid "" "This chapter will go through some quick basics, but you can find the " "comprehensive docs in [The Cargo Book](https://doc.rust-lang.org/cargo/)." msgstr "" "本章将快速介绍一些基础知识，更全面的文档可以在 [Cargo 手册](https://doc.rust-" "lang.org/cargo/) 中找到。" #: src/cargo/deps.md:3 msgid "" "Most programs have dependencies on some libraries. If you have ever managed " "dependencies by hand, you know how much of a pain this can be. Luckily, the " "Rust ecosystem comes standard with `cargo`! `cargo` can manage dependencies " "for a project." msgstr "" "大多数程序都依赖于一些库。如果你曾经手动管理过依赖，你就知道这有多么痛苦。幸" "运的是，Rust 生态系统标配了 `cargo`！`cargo` 可以为项目管理依赖。" #: src/cargo/deps.md:8 msgid "To create a new Rust project," msgstr "要创建一个新的 Rust 项目，可以使用以下命令：" #: src/cargo/deps.md:11 msgid "# A binary\n" msgstr "# 创建二进制项目\n" #: src/cargo/deps.md:13 msgid "# A library\n" msgstr "# 创建库项目\n" #: src/cargo/deps.md:18 msgid "" "For the rest of this chapter, let's assume we are making a binary, rather " "than a library, but all of the concepts are the same." msgstr "" "在本章的剩余部分，我们假设我们正在创建一个二进制项目，而不是一个库项目，但所" "有的概念都是相同的。" #: src/cargo/deps.md:21 msgid "After the above commands, you should see a file hierarchy like this:" msgstr "执行上述命令后，你应该会看到如下的文件结构：" #: src/cargo/deps.md:35 msgid "" "The `main.rs` is the root source file for your new `foo` project -- nothing " "new there. The `Cargo.toml` is the config file for `cargo` for this project. " "If you look inside it, you should see something like this:" msgstr "" "`main.rs` 是你新建的 `foo` 项目的主源文件 —— 这一点没什么新鲜的。" "`Cargo.toml` 则是这个项目的 `cargo` 配置文件。如果你查看它的内容，应该会看到" "类似这样的内容：" #: src/cargo/deps.md:39 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "```" msgstr "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "```" #: src/cargo/deps.md:48 msgid "" "The `name` field under `[package]` determines the name of the project. This " "is used by `crates.io` if you publish the crate (more later). It is also the " "name of the output binary when you compile." msgstr "" "`[package]` 下的 `name` 字段决定了项目的名称。如果你将 crate 发布到 " "`crates.io`（稍后会详细介绍），这个名称将被使用。同时，它也是编译时生成的二进" "制文件的名称。" #: src/cargo/deps.md:52 msgid "" "The `version` field is a crate version number using [Semantic Versioning]" "(http://semver.org/)." msgstr "" "`version` 字段是使用[语义化版本控制](http://semver.org/)的 crate 版本号。" #: src/cargo/deps.md:55 msgid "" "The `authors` field is a list of authors used when publishing the crate." msgstr "`authors` 字段是发布 crate 时使用的作者列表。" #: src/cargo/deps.md:57 msgid "" "The `[dependencies]` section lets you add dependencies for your project." msgstr "`[dependencies]` 部分允许你为项目添加依赖。" #: src/cargo/deps.md:59 msgid "" "For example, suppose that we want our program to have a great CLI. You can " "find lots of great packages on [crates.io](https://crates.io) (the official " "Rust package registry). One popular choice is [clap](https://crates.io/" "crates/clap). As of this writing, the most recent published version of " "`clap` is `2.27.1`. To add a dependency to our program, we can simply add " "the following to our `Cargo.toml` under `[dependencies]`: `clap = " "\"2.27.1\"`. And that's it! You can start using `clap` in your program." msgstr "" "举个例子，假设我们想让程序拥有一个出色的命令行界面（CLI）。你可以在 " "[crates.io](https://crates.io)（Rust 官方包注册中心）上找到许多优秀的包。其" "中，[clap](https://crates.io/crates/clap) 是一个广受欢迎的选择。在撰写本文" "时，`clap` 的最新发布版本是 `2.27.1`。要在我们的程序中添加这个依赖，只需在 " "`Cargo.toml` 的 `[dependencies]` 下添加：`clap = \"2.27.1\"`。就这么简单！现" "在你就可以在程序中使用 `clap` 了。" #: src/cargo/deps.md:67 msgid "" "`cargo` also supports [other types of dependencies](https://doc.rust-" "lang.org/cargo/reference/specifying-dependencies.html). Here is just a small " "sampling:" msgstr "" "`cargo` 还支持[其他类型的依赖](https://doc.rust-lang.org/cargo/reference/" "specifying-dependencies.html)。这里给出一个简单的示例：" #: src/cargo/deps.md:70 msgid "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "clap = \"2.27.1\" # from crates.io\n" "rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # from online " "repo\n" "bar = { path = \"../bar\" } # from a path in the local filesystem\n" "```" msgstr "" "```toml\n" "[package]\n" "name = \"foo\"\n" "version = \"0.1.0\"\n" "authors = [\"mark\"]\n" "\n" "[dependencies]\n" "clap = \"2.27.1\" # 来自 crates.io\n" "rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # 来自在线仓" "库\n" "bar = { path = \"../bar\" } # 来自本地文件系统的路径\n" "```" #: src/cargo/deps.md:82 msgid "" "`cargo` is more than a dependency manager. All of the available " "configuration options are listed in the [format specification](https://" "doc.rust-lang.org/cargo/reference/manifest.html) of `Cargo.toml`." msgstr "" "`cargo` 不仅仅是一个依赖管理器。`Cargo.toml` 的[格式规范](https://doc.rust-" "lang.org/cargo/reference/manifest.html)中列出了所有可用的配置选项。" #: src/cargo/deps.md:86 msgid "" "To build our project we can execute `cargo build` anywhere in the project " "directory (including subdirectories!). We can also do `cargo run` to build " "and run. Notice that these commands will resolve all dependencies, download " "crates if needed, and build everything, including your crate. (Note that it " "only rebuilds what it has not already built, similar to `make`)." msgstr "" "我们可以在项目目录的任何位置（包括子目录！）执行 `cargo build` 来构建项目。也" "可以使用 `cargo run` 来构建并运行。请注意，这些命令会解析所有依赖，必要时下" "载 crate，并构建所有内容，包括你的 crate。（值得一提的是，它只会重新构建尚未" "构建的部分，类似于 `make`）。" #: src/cargo/deps.md:92 msgid "Voila! That's all there is to it!" msgstr "瞧！就是这么简单！" #: src/cargo/conventions.md:3 msgid "In the previous chapter, we saw the following directory hierarchy:" msgstr "在上一章中，我们看到了如下目录结构：" #: src/cargo/conventions.md:12 msgid "" "Suppose that we wanted to have two binaries in the same project, though. " "What then?" msgstr "那么，如果我们想在同一个项目中包含两个二进制文件，该怎么办呢？" #: src/cargo/conventions.md:15 msgid "" "It turns out that `cargo` supports this. The default binary name is `main`, " "as we saw before, but you can add additional binaries by placing them in a " "`bin/` directory:" msgstr "" "`cargo` 实际上支持这种需求。如我们之前所见，默认的二进制文件名是 `main`，但你" "可以通过在 `bin/` 目录中放置额外的文件来添加其他二进制文件：" #: src/cargo/conventions.md:28 msgid "" "To tell `cargo` to only compile or run this binary, we just pass `cargo` the " "`--bin my_other_bin` flag, where `my_other_bin` is the name of the binary we " "want to work with." msgstr "" "如果要指示 `cargo` 只编译或运行特定的二进制文件，只需传递 `--bin " "my_other_bin` 标志，其中 `my_other_bin` 是我们想要处理的二进制文件的名称。" #: src/cargo/conventions.md:32 msgid "" "In addition to extra binaries, `cargo` supports [more features](https://" "doc.rust-lang.org/cargo/guide/project-layout.html) such as benchmarks, " "tests, and examples." msgstr "" "除了额外的二进制文件，`cargo` 还支持[更多功能](https://doc.rust-lang.org/" "cargo/guide/project-layout.html)，如基准测试、测试和示例。" #: src/cargo/conventions.md:35 msgid "In the next chapter, we will look more closely at tests." msgstr "在下一章中，我们将更详细地探讨测试。" #: src/cargo/test.md:3 msgid "" "As we know testing is integral to any piece of software! Rust has first-" "class support for unit and integration testing ([see this chapter](https://" "doc.rust-lang.org/book/ch11-00-testing.html) in TRPL)." msgstr "" "众所周知，测试是任何软件不可或缺的一部分！Rust 为单元测试和集成测试提供了一流" "的支持（参见《Rust 程序设计语言》中的[这一章](https://doc.rust-lang.org/book/" "ch11-00-testing.html)）。" #: src/cargo/test.md:7 msgid "" "From the testing chapters linked above, we see how to write unit tests and " "integration tests. Organizationally, we can place unit tests in the modules " "they test and integration tests in their own `tests/` directory:" msgstr "" "从上面链接的测试章节中，我们了解了如何编写单元测试和集成测试。在组织结构上，" "我们可以将单元测试放在它们所测试的模块中，而将集成测试放在专门的 `tests/` 目" "录中：" #: src/cargo/test.md:22 msgid "" "Each file in `tests` is a separate [integration test](https://doc.rust-" "lang.org/book/ch11-03-test-organization.html#integration-tests), i.e. a test " "that is meant to test your library as if it were being called from a " "dependent crate." msgstr "" "`tests` 目录中的每个文件都是一个独立的[集成测试](https://doc.rust-lang.org/" "book/ch11-03-test-organization.html#integration-tests)，即旨在测试你的库，就" "像它被依赖的 crate 调用一样。" #: src/cargo/test.md:27 msgid "" "The [Testing](../testing.md) chapter elaborates on the three different " "testing styles: [Unit](../testing/unit_testing.md), [Doc](../testing/" "doc_testing.md), and [Integration](../testing/integration_testing.md)." msgstr "" "[测试](../testing.md)章节详细阐述了三种不同的测试风格：[单元测试](../testing/" "unit_testing.md)、[文档测试](../testing/doc_testing.md)和[集成测试](../" "testing/integration_testing.md)。" #: src/cargo/test.md:30 msgid "`cargo` naturally provides an easy way to run all of your tests!" msgstr "`cargo` 自然提供了一种简便的方式来运行所有测试！" #: src/cargo/test.md:36 msgid "You should see output like this:" msgstr "你将看到类似这样的输出：" #: src/cargo/test.md:38 msgid "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" msgstr "" "```shell\n" "$ cargo test\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 4 tests\n" "test test_bar ... ok\n" "test test_baz ... ok\n" "test test_foo_bar ... ok\n" "test test_foo ... ok\n" "\n" "test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n" "```" #: src/cargo/test.md:53 msgid "You can also run tests whose name matches a pattern:" msgstr "你还可以运行名称匹配特定模式的测试：" #: src/cargo/test.md:59 msgid "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" msgstr "" "```shell\n" "$ cargo test test_foo\n" " Compiling blah v0.1.0 (file:///nobackup/blah)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n" " Running target/debug/deps/blah-d3b32b97275ec472\n" "\n" "running 2 tests\n" "test test_foo ... ok\n" "test test_foo_bar ... ok\n" "\n" "test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n" "```" #: src/cargo/test.md:72 msgid "" "One word of caution: Cargo may run multiple tests concurrently, so make sure " "that they don't race with each other." msgstr "" "需要注意：Cargo 可能会并发运行多个测试，因此请确保它们之间不会产生竞态条件。" #: src/cargo/test.md:75 msgid "" "One example of this concurrency causing issues is if two tests output to a " "file, such as below:" msgstr "" "并发可能导致问题的一个例子是，如果两个测试同时输出到同一个文件，如下所示：" #: src/cargo/test.md:81 msgid "// Import the necessary modules\n" msgstr "// 导入必要的模块\n" #: src/cargo/test.md:85 msgid "// This test writes to a file\n" msgstr "// 这个测试向文件写入内容\n" #: src/cargo/test.md:88 src/cargo/test.md:105 msgid "// Opens the file ferris.txt or creates one if it doesn't exist.\n" msgstr "// 打开 ferris.txt 文件，如果不存在则创建一个\n" #: src/cargo/test.md:92 src/cargo/test.md:109 msgid "\"ferris.txt\"" msgstr "\"ferris.txt\"" #: src/cargo/test.md:93 src/cargo/test.md:110 msgid "\"Failed to open ferris.txt\"" msgstr "\"无法打开 ferris.txt\"" #: src/cargo/test.md:95 msgid "// Print \"Ferris\" 5 times.\n" msgstr "// 循环打印 \"Ferris\" 5 次\n" #: src/cargo/test.md:97 msgid "\"Ferris\\n\"" msgstr "\"Ferris\\n\"" #: src/cargo/test.md:98 src/cargo/test.md:115 msgid "\"Could not write to ferris.txt\"" msgstr "\"无法写入 ferris.txt\"" #: src/cargo/test.md:102 msgid "// This test tries to write to the same file\n" msgstr "// 这个测试尝试写入同一个文件\n" #: src/cargo/test.md:112 msgid "// Print \"Corro\" 5 times.\n" msgstr "// 循环打印 \"Corro\" 5 次\n" #: src/cargo/test.md:114 msgid "\"Corro\\n\"" msgstr "\"Corro\\n\"" #: src/cargo/test.md:121 msgid "Although the intent is to get the following:" msgstr "尽管预期结果应该是：" #: src/cargo/test.md:137 msgid "What actually gets put into `ferris.txt` is this:" msgstr "但实际写入 `ferris.txt` 的内容可能是这样的：" #: src/cargo/build_scripts.md:3 msgid "" "Sometimes a normal build from `cargo` is not enough. Perhaps your crate " "needs some pre-requisites before `cargo` will successfully compile, things " "like code generation, or some native code that needs to be compiled. To " "solve this problem we have build scripts that Cargo can run." msgstr "" "有时候，`cargo` 的常规构建可能不足以满足需求。你的 crate 可能在 `cargo` 成功" "编译之前需要一些先决条件，比如代码生成，或者需要编译一些本地代码。为了解决这" "个问题，我们可以使用 Cargo 能够运行的构建脚本。" #: src/cargo/build_scripts.md:8 msgid "" "To add a build script to your package it can either be specified in the " "`Cargo.toml` as follows:" msgstr "要为你的包添加构建脚本，可以在 `Cargo.toml` 中指定，如下所示：" #: src/cargo/build_scripts.md:11 msgid "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" msgstr "" "```toml\n" "[package]\n" "...\n" "build = \"build.rs\"\n" "```" #: src/cargo/build_scripts.md:17 msgid "" "Otherwise Cargo will look for a `build.rs` file in the project directory by " "default." msgstr "如果没有指定，Cargo 默认会在项目目录中查找 `build.rs` 文件。" #: src/cargo/build_scripts.md:20 msgid "How to use a build script" msgstr "如何使用构建脚本" #: src/cargo/build_scripts.md:22 msgid "" "The build script is simply another Rust file that will be compiled and " "invoked prior to compiling anything else in the package. Hence it can be " "used to fulfill pre-requisites of your crate." msgstr "" "构建脚本只是另一个 Rust 文件，它会在编译包中的其他内容之前被编译和调用。因" "此，它可以用来满足你的 crate 的先决条件。" #: src/cargo/build_scripts.md:26 msgid "" "Cargo provides the script with inputs via environment variables [specified " "here](https://doc.rust-lang.org/cargo/reference/environment-" "variables.html#environment-variables-cargo-sets-for-build-scripts) that can " "be used." msgstr "" "Cargo 通过环境变量为脚本提供输入，这些环境变量可以被使用。具体参见[这里的说" "明](https://doc.rust-lang.org/cargo/reference/environment-" "variables.html#environment-variables-cargo-sets-for-build-scripts)。" #: src/cargo/build_scripts.md:29 msgid "" "The script provides output via stdout. All lines printed are written to " "`target/debug/build//output`. Further, lines prefixed with `cargo:` " "will be interpreted by Cargo directly and hence can be used to define " "parameters for the package's compilation." msgstr "" "脚本通过标准输出提供输出。所有打印的行都会被写入 `target/debug/build//" "output`。此外，以 `cargo:` 为前缀的行会被 Cargo 直接解释，因此可以用来为包的" "编译定义参数。" #: src/cargo/build_scripts.md:34 msgid "" "For further specification and examples have a read of the [Cargo " "specification](https://doc.rust-lang.org/cargo/reference/build-scripts.html)." msgstr "" "如需了解更多详细规范和示例，请参阅 [Cargo 构建脚本规范](https://doc.rust-" "lang.org/cargo/reference/build-scripts.html)。" #: src/attribute.md:3 msgid "" "An attribute is metadata applied to some module, crate or item. This " "metadata can be used to/for:" msgstr "属性是应用于模块、crate 或条目的元数据。这些元数据可用于以下目的：" #: src/attribute.md:8 msgid "[conditional compilation of code](attribute/cfg.md)" msgstr "[代码的条件编译](attribute/cfg.md)" #: src/attribute.md:9 msgid "" "[set crate name, version and type (binary or library)](attribute/crate.md)" msgstr "[设置 crate 的名称、版本和类型（二进制或库）](attribute/crate.md)" #: src/attribute.md:10 msgid "" "disable [lints](https://en.wikipedia.org/wiki/Lint_%28software%29) (warnings)" msgstr "" "禁用 [代码检查](https://en.wikipedia.org/wiki/Lint_%28software%29)（警告）" #: src/attribute.md:11 msgid "enable compiler features (macros, glob imports, etc.)" msgstr "启用编译器特性（如宏、全局导入等）" #: src/attribute.md:12 msgid "link to a foreign library" msgstr "链接外部库" #: src/attribute.md:13 msgid "mark functions as unit tests" msgstr "将函数标记为单元测试" #: src/attribute.md:14 msgid "mark functions that will be part of a benchmark" msgstr "将函数标记为基准测试的一部分" #: src/attribute.md:15 msgid "" "[attribute like macros](https://doc.rust-lang.org/book/ch19-06-" "macros.html#attribute-like-macros)" msgstr "" "[类属性宏](https://doc.rust-lang.org/book/ch19-06-macros.html#attribute-like-" "macros)" #: src/attribute.md:17 msgid "" "Attributes look like `#[outer_attribute]` or `#![inner_attribute]`, with the " "difference between them being where they apply." msgstr "" "属性的形式为 `#[outer_attribute]`（外部属性）或 `#![inner_attribute]`（内部属" "性），它们的区别在于应用的位置。" #: src/attribute.md:20 msgid "" "`#[outer_attribute]` applies to the [item](https://doc.rust-lang.org/stable/" "reference/items.html) immediately following it. Some examples of items are: " "a function, a module declaration, a constant, a structure, an enum. Here is " "an example where attribute `#[derive(Debug)]` applies to the struct " "`Rectangle`:" msgstr "" "`#[outer_attribute]` 应用于紧随其后的[条目](https://doc.rust-lang.org/stable/" "reference/items.html)。条目的例子包括：函数、模块声明、常量、结构体、枚举等。" "以下是一个示例，其中属性 `#[derive(Debug)]` 应用于结构体 `Rectangle`：" #: src/attribute.md:34 msgid "" "`#![inner_attribute]` applies to the enclosing [item](https://doc.rust-" "lang.org/stable/reference/items.html) (typically a module or a crate). In " "other words, this attribute is interpreted as applying to the entire scope " "in which it's placed. Here is an example where `#![allow(unused_variables)]` " "applies to the whole crate (if placed in `main.rs`):" msgstr "" "`#![inner_attribute]` 应用于包含它的[条目](https://doc.rust-lang.org/stable/" "reference/items.html)（通常是模块或 crate）。换句话说，这种属性被解释为应用于" "它所在的整个作用域。以下是一个示例，其中 `#![allow(unused_variables)]` 应用于" "整个 crate（如果放置在 `main.rs` 中）：" #: src/attribute.md:44 msgid "// This would normally warn about an unused variable.\n" msgstr "// 这通常会警告未使用的变量。\n" #: src/attribute.md:48 msgid "Attributes can take arguments with different syntaxes:" msgstr "属性可以使用不同的语法接受参数：" #: src/attribute.md:50 msgid "`#[attribute = \"value\"]`" msgstr "`#[attribute = \"value\"]`" #: src/attribute.md:51 msgid "`#[attribute(key = \"value\")]`" msgstr "`#[attribute(key = \"value\")]`" #: src/attribute.md:52 msgid "`#[attribute(value)]`" msgstr "`#[attribute(value)]`" #: src/attribute.md:54 msgid "" "Attributes can have multiple values and can be separated over multiple " "lines, too:" msgstr "属性可以有多个值，也可以跨多行分隔：" #: src/attribute/unused.md:3 msgid "" "The compiler provides a `dead_code` [_lint_](https://en.wikipedia.org/wiki/" "Lint_%28software%29) that will warn about unused functions. An _attribute_ " "can be used to disable the lint." msgstr "" "编译器提供了一个 `dead_code` [lint](https://en.wikipedia.org/wiki/" "Lint_%28software%29)，用于警告未使用的函数。可以使用**属性**来禁用这个 lint。" #: src/attribute/unused.md:9 msgid "" "// `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint\n" msgstr "// `#[allow(dead_code)]` 是一个用于禁用 `dead_code` lint 的属性\n" #: src/attribute/unused.md:14 msgid "// FIXME ^ Add an attribute to suppress the warning\n" msgstr "// FIXME ^ 添加一个属性来抑制警告\n" #: src/attribute/unused.md:22 msgid "" "Note that in real programs, you should eliminate dead code. In these " "examples we'll allow dead code in some places because of the interactive " "nature of the examples." msgstr "" "注意，在实际程序中，你应该消除无用代码。在这些示例中，我们会在某些地方允许存" "在无用代码，这是因为这些示例具有交互性质。" #: src/attribute/crate.md:3 msgid "" "The `crate_type` attribute can be used to tell the compiler whether a crate " "is a binary or a library (and even which type of library), and the " "`crate_name` attribute can be used to set the name of the crate." msgstr "" "`crate_type` 属性可用于告诉编译器一个 crate 是二进制文件还是库（甚至是哪种类" "型的库），而 `crate_name` 属性可用于设置 crate 的名称。" #: src/attribute/crate.md:7 msgid "" "However, it is important to note that both the `crate_type` and `crate_name` " "attributes have **no** effect whatsoever when using Cargo, the Rust package " "manager. Since Cargo is used for the majority of Rust projects, this means " "real-world uses of `crate_type` and `crate_name` are relatively limited." msgstr "" "然而，需要注意的是，当使用 Rust 的包管理器 Cargo 时，`crate_type` 和 " "`crate_name` 属性**完全不起作用**。由于大多数 Rust 项目都使用 Cargo，这意味" "着 `crate_type` 和 `crate_name` 在实际使用中的应用相对有限。" #: src/attribute/crate.md:13 msgid "// This crate is a library\n" msgstr "// 这个 crate 是一个库\n" #: src/attribute/crate.md:14 msgid "\"lib\"" msgstr "\"lib\"" #: src/attribute/crate.md:14 msgid "// The library is named \"rary\"\n" msgstr "// 这个库的名称是 \"rary\"\n" #: src/attribute/crate.md:16 msgid "\"rary\"" msgstr "\"rary\"" #: src/attribute/crate.md:33 msgid "" "When the `crate_type` attribute is used, we no longer need to pass the `--" "crate-type` flag to `rustc`." msgstr "" "当使用 `crate_type` 属性时，我们就不再需要向 `rustc` 传递 `--crate-type` 标" "志。" #: src/attribute/cfg.md:3 msgid "" "Configuration conditional checks are possible through two different " "operators:" msgstr "配置条件检查可以通过两种不同的操作符实现：" #: src/attribute/cfg.md:5 msgid "the `cfg` attribute: `#[cfg(...)]` in attribute position" msgstr "`cfg` 属性：在属性位置使用 `#[cfg(...)]`" #: src/attribute/cfg.md:6 msgid "the `cfg!` macro: `cfg!(...)` in boolean expressions" msgstr "`cfg!` 宏：在布尔表达式中使用 `cfg!(...)`" #: src/attribute/cfg.md:8 msgid "" "While the former enables conditional compilation, the latter conditionally " "evaluates to `true` or `false` literals allowing for checks at run-time. " "Both utilize identical argument syntax." msgstr "" "前者启用条件编译，后者在运行时条件性地求值为 `true` 或 `false` 字面量，允许在" "运行时进行检查。两者使用相同的参数语法。" #: src/attribute/cfg.md:12 msgid "" "`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true " "or false. For example, all blocks in an if/else expression need to be valid " "when `cfg!` is used for the condition, regardless of what `cfg!` is " "evaluating." msgstr "" "`cfg!` 与 `#[cfg]` 不同，它不会移除任何代码，只会求值为 true 或 false。例如，" "当 `cfg!` 用于条件时，if/else 表达式中的所有代码块都需要是有效的，无论 `cfg!" "` 正在评估什么。" #: src/attribute/cfg.md:15 msgid "// This function only gets compiled if the target OS is linux\n" msgstr "// 这个函数只有在目标操作系统是 linux 时才会被编译\n" #: src/attribute/cfg.md:16 src/attribute/cfg.md:22 src/attribute/cfg.md:31 msgid "\"linux\"" msgstr "\"linux\"" #: src/attribute/cfg.md:18 msgid "\"You are running linux!\"" msgstr "\"你正在运行 Linux！\"" #: src/attribute/cfg.md:20 msgid "" "// And this function only gets compiled if the target OS is *not* linux\n" msgstr "// 而这个函数只有在目标操作系统**不是** Linux 时才会被编译\n" #: src/attribute/cfg.md:24 msgid "\"You are *not* running linux!\"" msgstr "\"你**不是**在运行 Linux！\"" #: src/attribute/cfg.md:30 msgid "\"Are you sure?\"" msgstr "\"你确定吗？\"" #: src/attribute/cfg.md:32 msgid "\"Yes. It's definitely linux!\"" msgstr "\"是的，这绝对是 Linux！\"" #: src/attribute/cfg.md:34 msgid "\"Yes. It's definitely *not* linux!\"" msgstr "\"是的，这绝对**不是** Linux！\"" #: src/attribute/cfg.md:41 msgid "" "[the reference](https://doc.rust-lang.org/reference/" "attributes.html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/" "std/macro.cfg!.html), and [macros](../macros.md)." msgstr "" "[参考文档](https://doc.rust-lang.org/reference/attributes.html#conditional-" "compilation)、[`cfg!` 宏](https://doc.rust-lang.org/std/macro.cfg!.html)和" "[宏](../macros.md)。" #: src/attribute/cfg/custom.md:3 msgid "" "Some conditionals like `target_os` are implicitly provided by `rustc`, but " "custom conditionals must be passed to `rustc` using the `--cfg` flag." msgstr "" "一些条件（如 `target_os`）是由 `rustc` 隐式提供的，但自定义条件必须通过 `--" "cfg` 标志传递给 `rustc`。" #: src/attribute/cfg/custom.md:9 msgid "\"condition met!\"" msgstr "\"条件满足！\"" #: src/attribute/cfg/custom.md:17 msgid "Try to run this to see what happens without the custom `cfg` flag." msgstr "尝试运行这段代码，看看没有自定义 `cfg` 标志会发生什么。" #: src/attribute/cfg/custom.md:19 msgid "With the custom `cfg` flag:" msgstr "使用自定义 `cfg` 标志：" #: src/generics.md:3 msgid "" "_Generics_ is the topic of generalizing types and functionalities to broader " "cases. This is extremely useful for reducing code duplication in many ways, " "but can call for rather involved syntax. Namely, being generic requires " "taking great care to specify over which types a generic type is actually " "considered valid. The simplest and most common use of generics is for type " "parameters." msgstr "" "**泛型**是一个关于将类型和功能泛化以适用于更广泛情况的主题。这在多方面都非常" "有用，可以大大减少代码重复，但可能需要相对复杂的语法。具体来说，使用泛型需要" "非常谨慎地指定泛型类型在哪些类型上是有效的。泛型最简单和最常见的用途是类型参" "数。" #: src/generics.md:10 msgid "" "A type parameter is specified as generic by the use of angle brackets and " "upper [camel case](https://en.wikipedia.org/wiki/CamelCase): ``. \"Generic type parameters\" are typically represented as ``. " "In Rust, \"generic\" also describes anything that accepts one or more " "generic type parameters ``. Any type specified as a generic type " "parameter is generic, and everything else is concrete (non-generic)." msgstr "" "类型参数通过使用尖括号和大写[驼峰命名法](https://en.wikipedia.org/wiki/" "CamelCase)来指定为泛型：``。\"泛型类型参数\"通常表示为 ``。" "在 Rust 中，\"泛型\"也用来描述任何接受一个或多个泛型类型参数 `` 的东西。任" "何被指定为泛型类型参数的类型都是泛型的，而其他所有类型都是具体的（非泛型）。" #: src/generics.md:16 msgid "" "For example, defining a _generic function_ named `foo` that takes an " "argument `T` of any type:" msgstr "" "例如，定义一个名为 `foo` 的**泛型函数**，它接受一个任意类型的参数 `T`：" #: src/generics.md:23 msgid "" "Because `T` has been specified as a generic type parameter using ``, it " "is considered generic when used here as `(arg: T)`. This is the case even if " "`T` has previously been defined as a `struct`." msgstr "" "因为 `T` 已经使用 `` 指定为泛型类型参数，所以在这里用作 `(arg: T)` 时被视" "为泛型。即使 `T` 之前已被定义为一个 `struct`，这种情况也成立。" #: src/generics.md:27 msgid "This example shows some of the syntax in action:" msgstr "下面的例子展示了一些泛型语法的实际应用：" #: src/generics.md:30 msgid "// A concrete type `A`.\n" msgstr "// 具体类型 `A`\n" #: src/generics.md:32 msgid "" "// In defining the type `Single`, the first use of `A` is not preceded by " "``.\n" "// Therefore, `Single` is a concrete type, and `A` is defined as above.\n" msgstr "" "// 定义 `Single` 类型时，首次使用 `A` 前没有 ``\n" "// 因此，`Single` 是具体类型，`A` 即上面定义的类型\n" #: src/generics.md:35 msgid "// ^ Here is `Single`s first use of the type `A`.\n" msgstr "// ^ 这里是 `Single` 首次使用 `A` 类型\n" #: src/generics.md:37 msgid "" "// Here, `` precedes the first use of `T`, so `SingleGen` is a generic " "type.\n" "// Because the type parameter `T` is generic, it could be anything, " "including\n" "// the concrete type `A` defined at the top.\n" msgstr "" "// 这里 `` 在首次使用 `T` 之前，所以 `SingleGen` 是泛型\n" "// 由于类型参数 `T` 是泛型，它可以是任何类型\n" "// 包括上面定义的具体类型 `A`\n" #: src/generics.md:44 msgid "// `Single` is concrete and explicitly takes `A`.\n" msgstr "// `Single` 是具体类型，明确接受 `A`\n" #: src/generics.md:47 msgid "" "// Create a variable `_char` of type `SingleGen`\n" " // and give it the value `SingleGen('a')`.\n" " // Here, `SingleGen` has a type parameter explicitly specified.\n" msgstr "" "// 创建 `SingleGen` 类型的变量 `_char`\n" " // 并赋值为 `SingleGen('a')`\n" " // 这里 `SingleGen` 明确指定了类型参数\n" #: src/generics.md:52 msgid "// `SingleGen` can also have a type parameter implicitly specified:\n" msgstr "// `SingleGen` 也可以隐式指定类型参数：\n" #: src/generics.md:53 msgid "// Uses `A` defined at the top.\n" msgstr "// 使用上面定义的 `A`\n" #: src/generics.md:54 msgid "// Uses `i32`.\n" msgstr "// 使用 `i32`\n" #: src/generics.md:55 msgid "// Uses `char`.\n" msgstr "// 使用 `char`\n" #: src/generics.md:61 msgid "[`structs`](custom_types/structs.md)" msgstr "[`结构体`](custom_types/structs.md)" #: src/generics/gen_fn.md:3 msgid "" "The same set of rules can be applied to functions: a type `T` becomes " "generic when preceded by ``." msgstr "同样的规则也适用于函数：当类型 `T` 前面加上 `` 时，它就变成了泛型。" #: src/generics/gen_fn.md:6 msgid "" "Using generic functions sometimes requires explicitly specifying type " "parameters. This may be the case if the function is called where the return " "type is generic, or if the compiler doesn't have enough information to infer " "the necessary type parameters." msgstr "" "使用泛型函数有时需要明确指定类型参数。这种情况可能出现在函数返回类型是泛型" "时，或者编译器没有足够信息推断必要的类型参数时。" #: src/generics/gen_fn.md:11 msgid "" "A function call with explicitly specified type parameters looks like: `fun::" "()`." msgstr "明确指定类型参数的函数调用看起来像这样：`fun::()`。" #: src/generics/gen_fn.md:15 msgid "// Concrete type `A`.\n" msgstr "// 具体类型 `A`\n" #: src/generics/gen_fn.md:16 msgid "// Concrete type `S`.\n" msgstr "// 具体类型 `S`\n" #: src/generics/gen_fn.md:17 msgid "// Generic type `SGen`.\n" msgstr "// 泛型 `SGen`\n" #: src/generics/gen_fn.md:18 msgid "" "// The following functions all take ownership of the variable passed into\n" "// them and immediately go out of scope, freeing the variable.\n" msgstr "" "// 以下函数都获取传入变量的所有权\n" "// 并立即离开作用域，释放该变量\n" #: src/generics/gen_fn.md:21 msgid "" "// Define a function `reg_fn` that takes an argument `_s` of type `S`.\n" "// This has no `` so this is not a generic function.\n" msgstr "" "// 定义函数 `reg_fn`，接受一个 `S` 类型的参数 `_s`\n" "// 由于没有 ``，所以这不是泛型函数\n" #: src/generics/gen_fn.md:25 msgid "" "// Define a function `gen_spec_t` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `A`, but because `A` has " "not\n" "// been specified as a generic type parameter for `gen_spec_t`, it is not " "generic.\n" msgstr "" "// 定义函数 `gen_spec_t`，接受一个 `SGen` 类型的参数 `_s`\n" "// 虽然明确给定了类型参数 `A`，但因为 `A` 并未被指定为\n" "// `gen_spec_t` 的泛型类型参数，所以这个函数不是泛型的\n" #: src/generics/gen_fn.md:30 msgid "" "// Define a function `gen_spec_i32` that takes an argument `_s` of type " "`SGen`.\n" "// It has been explicitly given the type parameter `i32`, which is a " "specific type.\n" "// Because `i32` is not a generic type, this function is also not generic.\n" msgstr "" "// 定义函数 `gen_spec_i32`，接受一个 `SGen` 类型的参数 `_s`\n" "// 明确指定了类型参数 `i32`，这是一个具体类型\n" "// 由于 `i32` 不是泛型类型，所以这个函数也不是泛型的\n" #: src/generics/gen_fn.md:35 msgid "" "// Define a function `generic` that takes an argument `_s` of type " "`SGen`.\n" "// Because `SGen` is preceded by ``, this function is generic over " "`T`.\n" msgstr "" "// 定义函数 `generic`，接受一个 `SGen` 类型的参数 `_s`\n" "// 由于 `SGen` 前面有 ``，所以这个函数是关于 `T` 的泛型函数\n" #: src/generics/gen_fn.md:41 msgid "// Using the non-generic functions\n" msgstr "// 使用非泛型函数\n" #: src/generics/gen_fn.md:42 msgid "// Concrete type.\n" msgstr "// 具体类型\n" #: src/generics/gen_fn.md:43 msgid "// Implicitly specified type parameter `A`.\n" msgstr "// 隐式指定类型参数 `A`\n" #: src/generics/gen_fn.md:44 msgid "// Implicitly specified type parameter `i32`.\n" msgstr "// 隐式指定类型参数 `i32`\n" #: src/generics/gen_fn.md:46 msgid "// Explicitly specified type parameter `char` to `generic()`.\n" msgstr "// 为 `generic()` 显式指定类型参数 `char`\n" #: src/generics/gen_fn.md:49 msgid "// Implicitly specified type parameter `char` to `generic()`.\n" msgstr "// 为 `generic()` 隐式指定类型参数 `char`\n" #: src/generics/gen_fn.md:50 msgid "'c'" msgstr "'c'" #: src/generics/gen_fn.md:56 msgid "[functions](../fn.md) and [`struct`s](../custom_types/structs.md)" msgstr "[函数](../fn.md)和[`结构体`](../custom_types/structs.md)" #: src/generics/impl.md:3 msgid "Similar to functions, implementations require care to remain generic." msgstr "与函数类似，实现（`impl`）在涉及泛型时也需要谨慎处理。" #: src/generics/impl.md:6 msgid "// Concrete type `S`\n" msgstr "// 具体类型 `S`\n" #: src/generics/impl.md:7 msgid "// Generic type `GenericVal`\n" msgstr "// 泛型类型 `GenericVal`\n" #: src/generics/impl.md:8 msgid "// impl of GenericVal where we explicitly specify type parameters:\n" msgstr "// GenericVal 的实现，这里我们显式指定类型参数：\n" #: src/generics/impl.md:10 msgid "// Specify `f32`\n" msgstr "// 指定 `f32`\n" #: src/generics/impl.md:11 msgid "// Specify `S` as defined above\n" msgstr "// 指定上面定义的 `S`\n" #: src/generics/impl.md:12 msgid "// `` Must precede the type to remain generic\n" msgstr "// `` 必须放在类型前面以保持泛型\n" #: src/generics/impl.md:25 msgid "// impl of Val\n" msgstr "// Val 的实现\n" #: src/generics/impl.md:32 msgid "// impl of GenVal for a generic type `T`\n" msgstr "// 为泛型类型 `T` 实现 GenVal\n" #: src/generics/impl.md:50 msgid "" "[functions returning references](../scope/lifetime/fn.md), [`impl`](../fn/" "methods.md), and [`struct`](../custom_types/structs.md)" msgstr "" "[返回引用的函数](../scope/lifetime/fn.md)、[`impl`](../fn/methods.md) 和[结构" "体](../custom_types/structs.md)" #: src/generics/gen_trait.md:3 msgid "" "Of course `trait`s can also be generic. Here we define one which " "reimplements the `Drop` `trait` as a generic method to `drop` itself and an " "input." msgstr "" "当然，`trait` 也可以是泛型的。这里我们定义了一个泛型 trait，它重新实现了 " "`Drop` trait，用于释放自身和一个输入参数。" #: src/generics/gen_trait.md:7 msgid "// Non-copyable types.\n" msgstr "// 不可复制的类型。\n" #: src/generics/gen_trait.md:10 msgid "// A trait generic over `T`.\n" msgstr "// 一个泛型 trait，使用类型参数 `T`。\n" #: src/generics/gen_trait.md:13 msgid "" "// Define a method on the caller type which takes an\n" " // additional single parameter `T` and does nothing with it.\n" msgstr "" "// 在调用者类型上定义一个方法，该方法接受一个\n" " // 额外的类型为 `T` 的参数，但不对其进行任何操作。\n" #: src/generics/gen_trait.md:17 msgid "" "// Implement `DoubleDrop` for any generic parameter `T` and\n" "// caller `U`.\n" msgstr "// 为任意泛型参数 `T` 和调用者 `U` 实现 `DoubleDrop`。\n" #: src/generics/gen_trait.md:21 msgid "" "// This method takes ownership of both passed arguments,\n" " // deallocating both.\n" msgstr "" "// 此方法获取两个传入参数的所有权，\n" " // 并释放它们的内存。\n" #: src/generics/gen_trait.md:30 msgid "// Deallocate `empty` and `null`.\n" msgstr "// 释放 `empty` 和 `null` 的内存。\n" #: src/generics/gen_trait.md:33 msgid "" "//empty;\n" " //null;\n" " // ^ TODO: Try uncommenting these lines.\n" msgstr "" "//empty;\n" " //null;\n" " // ^ TODO：尝试取消这些行的注释。\n" #: src/generics/gen_trait.md:41 msgid "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`struct`](../" "custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html)、[`struct`](../" "custom_types/structs.md) 和 [`trait`](../trait.md)" #: src/generics/bounds.md:3 msgid "" "When working with generics, the type parameters often must use traits as " "_bounds_ to stipulate what functionality a type implements. For example, the " "following example uses the trait `Display` to print and so it requires `T` " "to be bound by `Display`; that is, `T` _must_ implement `Display`." msgstr "" "在使用泛型时，类型参数通常需要使用 trait 作为**约束**，以规定类型应实现哪些功" "能。例如，下面的示例使用 `Display` trait 来打印，因此它要求 `T` 必须受 " "`Display` 约束；换句话说，`T` **必须**实现 `Display`。" #: src/generics/bounds.md:9 msgid "" "// Define a function `printer` that takes a generic type `T` which\n" "// must implement trait `Display`.\n" msgstr "" "// 定义一个函数 `printer`，它接受一个泛型类型 `T`，\n" "// 该类型必须实现 `Display` trait。\n" #: src/generics/bounds.md:16 msgid "" "Bounding restricts the generic to types that conform to the bounds. That is:" msgstr "约束将泛型限制为符合约束条件的类型。也就是说：" #: src/generics/bounds.md:20 msgid "" "// Error! `Vec` does not implement `Display`. This\n" "// specialization will fail.\n" msgstr "" "// 错误！`Vec` 没有实现 `Display`。\n" "// 这个特化将会失败。\n" #: src/generics/bounds.md:26 msgid "" "Another effect of bounding is that generic instances are allowed to access " "the [methods](../fn/methods.md) of traits specified in the bounds. For " "example:" msgstr "" "约束的另一个作用是允许泛型实例访问约束中指定的 trait 的[方法](../fn/" "methods.md)。例如：" #: src/generics/bounds.md:30 msgid "// A trait which implements the print marker: `{:?}`.\n" msgstr "// 实现打印标记 `{:?}` 的 trait。\n" #: src/generics/bounds.md:45 msgid "" "// The generic `T` must implement `Debug`. Regardless\n" "// of the type, this will work properly.\n" msgstr "" "// 泛型 `T` 必须实现 `Debug`。无论 `T` 是什么类型，\n" "// 这个函数都能正常工作。\n" #: src/generics/bounds.md:51 msgid "" "// `T` must implement `HasArea`. Any type which meets\n" "// the bound can access `HasArea`'s function `area`.\n" msgstr "" "// `T` 必须实现 `HasArea`。任何满足这个约束的类型\n" "// 都可以访问 `HasArea` 的 `area` 方法。\n" #: src/generics/bounds.md:61 msgid "\"Area: {}\"" msgstr "\"面积：{}\"" #: src/generics/bounds.md:63 msgid "" "//print_debug(&_triangle);\n" " //println!(\"Area: {}\", area(&_triangle));\n" " // ^ TODO: Try uncommenting these.\n" " // | Error: Does not implement either `Debug` or `HasArea`.\n" msgstr "" "//print_debug(&_triangle);\n" " //println!(\"面积：{}\", area(&_triangle));\n" " // ^ TODO：尝试取消这些注释。\n" " // | 错误：未实现 `Debug` 或 `HasArea`。\n" #: src/generics/bounds.md:70 msgid "" "As an additional note, [`where`](../generics/where.md) clauses can also be " "used to apply bounds in some cases to be more expressive." msgstr "" "另外值得注意的是，在某些情况下可以使用 [`where`](../generics/where.md) 子句来" "应用约束，以使表达更加清晰。" #: src/generics/bounds.md:75 msgid "" "[`std::fmt`](../hello/print.md), [`struct`s](../custom_types/structs.md), " "and [`trait`s](../trait.md)" msgstr "" "[`std::fmt`](../hello/print.md)、[`struct`](../custom_types/structs.md)和 " "[`trait`](../trait.md)" #: src/generics/bounds/testcase_empty.md:3 msgid "" "A consequence of how bounds work is that even if a `trait` doesn't include " "any functionality, you can still use it as a bound. `Eq` and `Copy` are " "examples of such `trait`s from the `std` library." msgstr "" "约束的工作机制导致即使一个 `trait` 不包含任何功能，你仍然可以将其用作约束。" "`std` 库中的 `Eq` 和 `Copy` 就是这种 `trait` 的例子。" #: src/generics/bounds/testcase_empty.md:17 msgid "" "// These functions are only valid for types which implement these\n" "// traits. The fact that the traits are empty is irrelevant.\n" msgstr "" "// 这些函数只对实现了这些 trait 的类型有效。\n" "// 这些 trait 是否为空并不重要。\n" #: src/generics/bounds/testcase_empty.md:20 msgid "\"red\"" msgstr "\"红色\"" #: src/generics/bounds/testcase_empty.md:21 msgid "\"blue\"" msgstr "\"蓝色\"" #: src/generics/bounds/testcase_empty.md:28 msgid "" "// `red()` won't work on a blue jay nor vice versa\n" " // because of the bounds.\n" msgstr "// 由于约束的存在，`red()` 不能用于蓝松鸟，反之亦然。\n" #: src/generics/bounds/testcase_empty.md:30 msgid "\"A cardinal is {}\"" msgstr "\"红雀是{}\"" #: src/generics/bounds/testcase_empty.md:31 msgid "\"A blue jay is {}\"" msgstr "\"蓝松鸟是{}\"" #: src/generics/bounds/testcase_empty.md:32 msgid "" "//println!(\"A turkey is {}\", red(&_turkey));\n" " // ^ TODO: Try uncommenting this line.\n" msgstr "" "//println!(\"火鸡是{}\", red(&_turkey));\n" " // ^ TODO：尝试取消这行的注释。\n" #: src/generics/bounds/testcase_empty.md:39 msgid "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`std::marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), " "and [`trait`s](../../trait.md)" msgstr "" "[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html)、" "[`std::marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html) " "和 [`trait`](../../trait.md)" #: src/generics/multi_bounds.md:3 msgid "" "Multiple bounds for a single type can be applied with a `+`. Like normal, " "different types are separated with `,`." msgstr "可以使用 `+` 为单个类型指定多个约束。按照惯例，不同的类型用 `,` 分隔。" #: src/generics/multi_bounds.md:10 msgid "\"Debug: `{:?}`\"" msgstr "\"Debug：`{:?}`\"" #: src/generics/multi_bounds.md:11 msgid "\"Display: `{}`\"" msgstr "\"Display：`{}`\"" #: src/generics/multi_bounds.md:15 msgid "\"t: `{:?}`\"" msgstr "\"t：`{:?}`\"" #: src/generics/multi_bounds.md:16 msgid "\"u: `{:?}`\"" msgstr "\"u：`{:?}`\"" #: src/generics/multi_bounds.md:20 msgid "\"words\"" msgstr "\"words\"" #: src/generics/multi_bounds.md:25 msgid "" "//compare_prints(&array);\n" " // TODO ^ Try uncommenting this.\n" msgstr "" "//compare_prints(&array);\n" " // TODO：尝试取消此行注释。\n" #: src/generics/multi_bounds.md:34 msgid "[`std::fmt`](../hello/print.md) and [`trait`s](../trait.md)" msgstr "[`std::fmt`](../hello/print.md) 和 [`trait`](../trait.md)" #: src/generics/where.md:3 msgid "" "A bound can also be expressed using a `where` clause immediately before the " "opening `{`, rather than at the type's first mention. Additionally, `where` " "clauses can apply bounds to arbitrary types, rather than just to type " "parameters." msgstr "" "约束也可以使用 `where` 子句来表达，它位于开括号 `{` 之前，而不是在类型首次提" "及时。此外，`where` 子句可以将约束应用于任意类型，而不仅限于类型参数。" #: src/generics/where.md:8 msgid "Some cases that a `where` clause is useful:" msgstr "`where` 子句在以下情况下特别有用：" #: src/generics/where.md:10 msgid "When specifying generic types and bounds separately is clearer:" msgstr "当单独指定泛型类型和约束更清晰时：" #: src/generics/where.md:14 msgid "// Expressing bounds with a `where` clause\n" msgstr "// 使用 `where` 子句表达约束\n" #: src/generics/where.md:21 msgid "" "When using a `where` clause is more expressive than using normal syntax. The " "`impl` in this example cannot be directly expressed without a `where` clause:" msgstr "" "当使用 `where` 子句比使用普通语法更具表现力时。这个例子中的 `impl` 如果不使" "用 `where` 子句就无法直接表达：" #: src/generics/where.md:30 msgid "" "// Because we would otherwise have to express this as `T: Debug` or\n" "// use another method of indirect approach, this requires a `where` clause:\n" msgstr "" "// 这里需要一个 `where` 子句：否则就必须将其表达为 `T: Debug` 或\n" "// 使用另一种间接方法，\n" #: src/generics/where.md:35 msgid "" "// We want `Option: Debug` as our bound because that is what's\n" " // being printed. Doing otherwise would be using the wrong bound.\n" msgstr "" "// 我们需要 `Option: Debug` 作为我们的约束，因为这是\n" " // 正在被打印的内容。否则就会使用错误的约束。\n" #: src/generics/where.md:51 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), " "[`struct`](../custom_types/structs.md), and [`trait`](../trait.md)" msgstr "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md)、" "[`struct`](../custom_types/structs.md) 和 [`trait`](../trait.md)" #: src/generics/new_types.md:3 msgid "" "The `newtype` idiom gives compile time guarantees that the right type of " "value is supplied to a program." msgstr "`newtype` 模式在编译时保证了程序接收到正确类型的值。" #: src/generics/new_types.md:6 msgid "" "For example, an age verification function that checks age in years, _must_ " "be given a value of type `Years`." msgstr "" "例如，一个检查年龄（以年为单位）的年龄验证函数，**必须**接收 `Years` 类型的" "值。" #: src/generics/new_types.md:21 msgid "/// truncates partial years\n" msgstr "/// 截断不足一年的部分\n" #: src/generics/new_types.md:34 src/generics/new_types.md:35 msgid "\"Is an adult? {}\"" msgstr "\"是否成年？{}\"" #: src/generics/new_types.md:36 msgid "// println!(\"Is an adult? {}\", is_adult(&age_days));\n" msgstr "// println!(\"是否成年？{}\", is_adult(&age_days));\n" #: src/generics/new_types.md:40 msgid "" "Uncomment the last print statement to observe that the type supplied must be " "`Years`." msgstr "取消最后一个 print 语句的注释，你会发现所提供的类型必须是 `Years`。" #: src/generics/new_types.md:42 msgid "" "To obtain the `newtype`'s value as the base type, you may use the tuple or " "destructuring syntax like so:" msgstr "" "要获取 `newtype` 的基本类型值，你可以使用元组语法或解构语法，如下所示：" #: src/generics/new_types.md:49 msgid "// Tuple\n" msgstr "// 元组语法\n" #: src/generics/new_types.md:50 msgid "// Destructuring\n" msgstr "// 解构语法\n" #: src/generics/new_types.md:56 msgid "[`structs`](../custom_types/structs.md)" msgstr "[`struct`](../custom_types/structs.md)" #: src/generics/assoc_items.md:3 msgid "" "\"Associated Items\" refers to a set of rules pertaining to [`item`](https://" "doc.rust-lang.org/reference/items.html)s of various types. It is an " "extension to `trait` generics, and allows `trait`s to internally define new " "items." msgstr "" "\"关联项\"是指与各种类型的[`项`](https://doc.rust-lang.org/reference/" "items.html)相关的一组规则。它是 `trait` 泛型的扩展，允许 `trait` 在内部定义新" "的项。" #: src/generics/assoc_items.md:7 msgid "" "One such item is called an _associated type_, providing simpler usage " "patterns when the `trait` is generic over its container type." msgstr "" "其中一种项被称为**关联类型**，当 `trait` 对其容器类型是泛型时，它提供了更简洁" "的使用模式。" #: src/generics/assoc_items.md:12 msgid "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" msgstr "" "[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-" "items.md)" #: src/generics/assoc_items/the_problem.md:3 msgid "" "A `trait` that is generic over its container type has type specification " "requirements - users of the `trait` _must_ specify all of its generic types." msgstr "" "对于容器类型是泛型的 `trait`，有类型规范要求 —— `trait` 的使用者**必须**指定" "所有的泛型类型。" #: src/generics/assoc_items/the_problem.md:6 msgid "" "In the example below, the `Contains` `trait` allows the use of the generic " "types `A` and `B`. The trait is then implemented for the `Container` type, " "specifying `i32` for `A` and `B` so that it can be used with `fn " "difference()`." msgstr "" "在下面的例子中，`Contains` trait 允许使用泛型类型 `A` 和 `B`。然后为 " "`Container` 类型实现该 trait，将 `A` 和 `B` 指定为 `i32`，以便与 `fn " "difference()` 一起使用。" #: src/generics/assoc_items/the_problem.md:10 msgid "" "Because `Contains` is generic, we are forced to explicitly state _all_ of " "the generic types for `fn difference()`. In practice, we want a way to " "express that `A` and `B` are determined by the _input_ `C`. As you will see " "in the next section, associated types provide exactly that capability." msgstr "" "由于 `Contains` 是泛型的，我们不得不为 `fn difference()` 显式声明**所有**泛型" "类型。实际上，我们希望有一种方法来表达 `A` 和 `B` 是由**输入** `C` 决定的。正" "如你将在下一节中看到的，关联类型恰好提供了这种能力。" #: src/generics/assoc_items/the_problem.md:17 #: src/generics/assoc_items/types.md:36 msgid "" "// A trait which checks if 2 items are stored inside of container.\n" "// Also retrieves first or last value.\n" msgstr "" "// 一个检查容器内是否存储了两个项的 trait。\n" "// 同时可以检索第一个或最后一个值。\n" #: src/generics/assoc_items/the_problem.md:21 msgid "// Explicitly requires `A` and `B`.\n" msgstr "// 显式要求 `A` 和 `B`\n" #: src/generics/assoc_items/the_problem.md:22 #: src/generics/assoc_items/the_problem.md:23 msgid "// Doesn't explicitly require `A` or `B`.\n" msgstr "// 不需要显式指定 `A` 或 `B`\n" #: src/generics/assoc_items/the_problem.md:27 msgid "// True if the numbers stored are equal.\n" msgstr "// 如果存储的数字相等则返回 true\n" #: src/generics/assoc_items/the_problem.md:32 #: src/generics/assoc_items/types.md:60 msgid "// Grab the first number.\n" msgstr "// 获取第一个数字\n" #: src/generics/assoc_items/the_problem.md:35 #: src/generics/assoc_items/types.md:63 msgid "// Grab the last number.\n" msgstr "// 获取最后一个数字\n" #: src/generics/assoc_items/the_problem.md:38 msgid "" "// `C` contains `A` and `B`. In light of that, having to express `A` and\n" "// `B` again is a nuisance.\n" msgstr "" "// `C` 已经包含了 `A` 和 `B`。考虑到这一点，\n" "// 再次指定 `A` 和 `B` 就显得多余且麻烦。\n" #: src/generics/assoc_items/the_problem.md:52 #: src/generics/assoc_items/types.md:77 msgid "\"Does container contain {} and {}: {}\"" msgstr "\"容器是否包含 {} 和 {}：{}\"" #: src/generics/assoc_items/the_problem.md:55 #: src/generics/assoc_items/types.md:80 msgid "\"First number: {}\"" msgstr "\"第一个数字：{}\"" #: src/generics/assoc_items/the_problem.md:56 #: src/generics/assoc_items/types.md:81 msgid "\"Last number: {}\"" msgstr "\"最后一个数字：{}\"" #: src/generics/assoc_items/the_problem.md:58 #: src/generics/assoc_items/types.md:83 msgid "\"The difference is: {}\"" msgstr "\"差值为：{}\"" #: src/generics/assoc_items/the_problem.md:64 msgid "" "[`struct`s](../../custom_types/structs.md), and [`trait`s](../../trait.md)" msgstr "[`struct`](../../custom_types/structs.md) 和 [`trait`](../../trait.md)" #: src/generics/assoc_items/types.md:3 msgid "" "The use of \"Associated types\" improves the overall readability of code by " "moving inner types locally into a trait as _output_ types. Syntax for the " "`trait` definition is as follows:" msgstr "" "使用\"关联类型\"通过将内部类型局部移动到 trait 中作为**输出**类型，提高了代码" "的整体可读性。trait 定义的语法如下：" #: src/generics/assoc_items/types.md:8 msgid "" "// `A` and `B` are defined in the trait via the `type` keyword.\n" "// (Note: `type` in this context is different from `type` when used for\n" "// aliases).\n" msgstr "" "// `A` 和 `B` 在 trait 中通过 `type` 关键字定义。\n" "// （注意：这里的 `type` 与用于类型别名的 `type` 不同）\n" #: src/generics/assoc_items/types.md:15 msgid "// Updated syntax to refer to these new types generically.\n" msgstr "// 更新后的语法，用于泛型地引用这些新类型\n" #: src/generics/assoc_items/types.md:20 msgid "" "Note that functions that use the `trait` `Contains` are no longer required " "to express `A` or `B` at all:" msgstr "注意，使用 `Contains` trait 的函数不再需要显式指定 `A` 或 `B`：" #: src/generics/assoc_items/types.md:24 msgid "// Without using associated types\n" msgstr "// 不使用关联类型\n" #: src/generics/assoc_items/types.md:27 msgid "// Using associated types\n" msgstr "// 使用关联类型\n" #: src/generics/assoc_items/types.md:32 msgid "" "Let's rewrite the example from the previous section using associated types:" msgstr "让我们使用关联类型重写上一节的示例：" #: src/generics/assoc_items/types.md:40 msgid "// Define generic types here which methods will be able to utilize.\n" msgstr "// 在此定义泛型类型，方法将能够使用这些类型\n" #: src/generics/assoc_items/types.md:50 msgid "" "// Specify what types `A` and `B` are. If the `input` type\n" " // is `Container(i32, i32)`, the `output` types are determined\n" " // as `i32` and `i32`.\n" msgstr "" "// 指定 `A` 和 `B` 的具体类型。如果 `input` 类型\n" " // 是 `Container(i32, i32)`，那么 `output` 类型\n" " // 就被确定为 `i32` 和 `i32`\n" #: src/generics/assoc_items/types.md:56 msgid "// `&Self::A` and `&Self::B` are also valid here.\n" msgstr "// 在这里使用 `&Self::A` 和 `&Self::B` 也是有效的。\n" #: src/generics/phantom.md:3 msgid "" "A phantom type parameter is one that doesn't show up at runtime, but is " "checked statically (and only) at compile time." msgstr "虚类型参数是一种在运行时不会出现，但在编译时会进行静态检查的类型参数。" #: src/generics/phantom.md:6 msgid "" "Data types can use extra generic type parameters to act as markers or to " "perform type checking at compile time. These extra parameters hold no " "storage values, and have no runtime behavior." msgstr "" "数据类型可以使用额外的泛型类型参数作为标记，或在编译时进行类型检查。这些额外" "的参数不占用存储空间，也没有运行时行为。" #: src/generics/phantom.md:10 msgid "" "In the following example, we combine [std::marker::PhantomData](https://" "doc.rust-lang.org/std/marker/struct.PhantomData.html) with the phantom type " "parameter concept to create tuples containing different data types." msgstr "" "在下面的示例中，我们将 [`std::marker::PhantomData`](https://doc.rust-" "lang.org/std/marker/struct.PhantomData.html) 与虚类型参数的概念结合，创建包含" "不同数据类型的元组。" #: src/generics/phantom.md:16 msgid "" "// A phantom tuple struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "// 一个虚元组结构体，它在 `A` 上是泛型的，带有隐藏参数 `B`。\n" #: src/generics/phantom.md:18 src/generics/phantom.md:22 msgid "// Allow equality test for this type.\n" msgstr "// 允许对此类型进行相等性测试。\n" #: src/generics/phantom.md:20 msgid "" "// A phantom type struct which is generic over `A` with hidden parameter " "`B`.\n" msgstr "// 一个虚类型结构体，它在 `A` 上是泛型的，带有隐藏参数 `B`。\n" #: src/generics/phantom.md:24 msgid "" "// Note: Storage is allocated for generic type `A`, but not for `B`.\n" "// Therefore, `B` cannot be used in computations.\n" msgstr "" "// 注意：为泛型类型 `A` 分配了存储空间，但没有为 `B` 分配。\n" "// 因此，`B` 不能用于计算。\n" #: src/generics/phantom.md:29 msgid "" "// Here, `f32` and `f64` are the hidden parameters.\n" " // PhantomTuple type specified as ``.\n" msgstr "" "// 这里，`f32` 和 `f64` 是隐藏参数。\n" " // PhantomTuple 类型指定为 ``。\n" #: src/generics/phantom.md:31 src/generics/phantom.md:33 #: src/generics/phantom.md:37 src/generics/phantom.md:42 #: src/scope/borrow/ref.md:12 msgid "'Q'" msgstr "'Q'" #: src/generics/phantom.md:32 msgid "// PhantomTuple type specified as ``.\n" msgstr "// PhantomTuple 类型指定为 ``。\n" #: src/generics/phantom.md:35 msgid "// Type specified as ``.\n" msgstr "// 类型指定为 ``。\n" #: src/generics/phantom.md:40 msgid "// Type specified as ``.\n" msgstr "// 类型指定为 ``。\n" #: src/generics/phantom.md:46 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_tuple1 == _tuple2 yields: {}\",\n" " // _tuple1 == _tuple2);\n" msgstr "" "// 编译时错误！类型不匹配，无法比较：\n" " // println!(\"_tuple1 == _tuple2 的结果是：{}\",\n" " // _tuple1 == _tuple2);\n" #: src/generics/phantom.md:50 msgid "" "// Compile-time Error! Type mismatch so these cannot be compared:\n" " // println!(\"_struct1 == _struct2 yields: {}\",\n" " // _struct1 == _struct2);\n" msgstr "" "// 编译时错误！类型不匹配，无法比较：\n" " // println!(\"_struct1 == _struct2 的结果是：{}\",\n" " // _struct1 == _struct2);\n" #: src/generics/phantom.md:58 msgid "" "[Derive](../trait/derive.md), [struct](../custom_types/structs.md), and " "[TupleStructs](../custom_types/structs.md)" msgstr "" "[派生（Derive）](../trait/derive.md)、[结构体（struct）](../custom_types/" "structs.md)和[元组结构体（TupleStructs）](../custom_types/structs.md)" #: src/generics/phantom/testcase_units.md:3 msgid "" "A useful method of unit conversions can be examined by implementing `Add` " "with a phantom type parameter. The `Add` `trait` is examined below:" msgstr "" "通过使用虚类型参数实现 `Add` trait，我们可以探索一种有用的单位转换方法。下面" "我们来看看 `Add` trait：" #: src/generics/phantom/testcase_units.md:7 msgid "" "// This construction would impose: `Self + RHS = Output`\n" "// where RHS defaults to Self if not specified in the implementation.\n" msgstr "" "// 这个结构会强制要求：`Self + RHS = Output`\n" "// 其中，如果在实现中未指定 RHS，它将默认为 Self。\n" #: src/generics/phantom/testcase_units.md:14 msgid "// `Output` must be `T` so that `T + T = T`.\n" msgstr "// `Output` 必须是 `T`，以确保 `T + T = T`。\n" #: src/generics/phantom/testcase_units.md:22 msgid "The whole implementation:" msgstr "完整实现如下：" #: src/generics/phantom/testcase_units.md:27 msgid "/// Create void enumerations to define unit types.\n" msgstr "/// 创建空枚举以定义单位类型。\n" #: src/generics/phantom/testcase_units.md:33 msgid "" "/// `Length` is a type with phantom type parameter `Unit`,\n" "/// and is not generic over the length type (that is `f64`).\n" "///\n" "/// `f64` already implements the `Clone` and `Copy` traits.\n" msgstr "" "/// `Length` 是一个带有虚类型参数 `Unit` 的类型，\n" "/// 它不是长度类型（即 `f64`）的泛型。\n" "///\n" "/// `f64` 已经实现了 `Clone` 和 `Copy` trait。\n" #: src/generics/phantom/testcase_units.md:40 msgid "/// The `Add` trait defines the behavior of the `+` operator.\n" msgstr "/// `Add` trait 定义了 `+` 运算符的行为。\n" #: src/generics/phantom/testcase_units.md:45 msgid "// add() returns a new `Length` struct containing the sum.\n" msgstr "// add() 返回一个包含和的新 `Length` 结构体。\n" #: src/generics/phantom/testcase_units.md:47 msgid "// `+` calls the `Add` implementation for `f64`.\n" msgstr "// `+` 调用 `f64` 的 `Add` 实现。\n" #: src/generics/phantom/testcase_units.md:53 msgid "// Specifies `one_foot` to have phantom type parameter `Inch`.\n" msgstr "// 指定 `one_foot` 具有虚类型参数 `Inch`。\n" #: src/generics/phantom/testcase_units.md:55 msgid "// `one_meter` has phantom type parameter `Mm`.\n" msgstr "// `one_meter` 具有虚类型参数 `Mm`。\n" #: src/generics/phantom/testcase_units.md:58 msgid "" "// `+` calls the `add()` method we implemented for `Length`.\n" " //\n" " // Since `Length` implements `Copy`, `add()` does not consume\n" " // `one_foot` and `one_meter` but copies them into `self` and `rhs`.\n" msgstr "" "// `+` 调用我们为 `Length` 实现的 `add()` 方法。\n" " //\n" " // 由于 `Length` 实现了 `Copy`，`add()` 不会消耗\n" " // `one_foot` 和 `one_meter`，而是将它们复制到 `self` 和 `rhs` 中。\n" #: src/generics/phantom/testcase_units.md:65 msgid "// Addition works.\n" msgstr "// 加法运算正常工作。\n" #: src/generics/phantom/testcase_units.md:66 msgid "\"one foot + one_foot = {:?} in\"" msgstr "\"一英尺 + 一英尺 = {:?} 英寸\"" #: src/generics/phantom/testcase_units.md:67 msgid "\"one meter + one_meter = {:?} mm\"" msgstr "\"一米 + 一米 = {:?} 毫米\"" #: src/generics/phantom/testcase_units.md:69 msgid "" "// Nonsensical operations fail as they should:\n" " // Compile-time Error: type mismatch.\n" " //let one_feter = one_foot + one_meter;\n" msgstr "" "// 无意义的操作会按预期失败：\n" " // 编译时错误：类型不匹配。\n" " //let one_feter = one_foot + one_meter;\n" #: src/generics/phantom/testcase_units.md:77 msgid "" "[Borrowing (`&`)](../../scope/borrow.md), [Bounds (`X: Y`)](../../generics/" "bounds.md), [enum](../../custom_types/enum.md), [impl & self](../../fn/" "methods.md), [Overloading](../../trait/ops.md), [ref](../../scope/borrow/" "ref.md), [Traits (`X for Y`)](../../trait.md), and [TupleStructs](../../" "custom_types/structs.md)." msgstr "" "[借用（`&`）](../../scope/borrow.md)、[约束（`X: Y`）](../../generics/" "bounds.md)、[枚举](../../custom_types/enum.md)、[impl 和 self](../../fn/" "methods.md)、[运算符重载](../../trait/ops.md)、[ref](../../scope/borrow/" "ref.md)、[trait（`X for Y`）](../../trait.md)以及[元组结构体](../../" "custom_types/structs.md)。" #: src/scope.md:3 msgid "" "Scopes play an important part in ownership, borrowing, and lifetimes. That " "is, they indicate to the compiler when borrows are valid, when resources can " "be freed, and when variables are created or destroyed." msgstr "" "作用域在所有权、借用和生命周期中扮演着重要角色。它们向编译器指示借用何时有" "效、资源何时可以被释放，以及变量何时被创建或销毁。" #: src/scope/raii.md:3 msgid "" "Variables in Rust do more than just hold data in the stack: they also _own_ " "resources, e.g. `Box` owns memory in the heap. Rust enforces [RAII]" "(https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) " "(Resource Acquisition Is Initialization), so whenever an object goes out of " "scope, its destructor is called and its owned resources are freed." msgstr "" "Rust 中的变量不仅仅是在栈上保存数据：它们还**拥有**资源，例如 `Box` 拥有堆" "上的内存。Rust 强制执行 [RAII](https://en.wikipedia.org/wiki/" "Resource_Acquisition_Is_Initialization)（资源获取即初始化），因此每当一个对象" "离开作用域时，它的析构函数就会被调用，它拥有的资源也会被释放。" #: src/scope/raii.md:8 msgid "" "This behavior shields against _resource leak_ bugs, so you'll never have to " "manually free memory or worry about memory leaks again! Here's a quick " "showcase:" msgstr "" "这种行为可以防止**资源泄漏**错误，因此你再也不用手动释放内存或担心内存泄漏" "了！以下是一个简单示例：" #: src/scope/raii.md:12 msgid "// raii.rs\n" msgstr "// raii.rs\n" #: src/scope/raii.md:14 src/scope/raii.md:21 src/scope/raii.md:26 msgid "// Allocate an integer on the heap\n" msgstr "// 在堆上分配一个整数\n" #: src/scope/raii.md:17 msgid "// `_box1` is destroyed here, and memory gets freed\n" msgstr "// `_box1` 在此处被销毁，内存被释放\n" #: src/scope/raii.md:24 msgid "// A nested scope:\n" msgstr "// 一个嵌套的作用域：\n" #: src/scope/raii.md:29 msgid "// `_box3` is destroyed here, and memory gets freed\n" msgstr "// `_box3` 在此处被销毁，内存被释放\n" #: src/scope/raii.md:32 msgid "" "// Creating lots of boxes just for fun\n" " // There's no need to manually free memory!\n" msgstr "" "// 创建大量的 box（仅为演示）\n" " // 无需手动释放内存！\n" #: src/scope/raii.md:38 msgid "// `_box2` is destroyed here, and memory gets freed\n" msgstr "// `_box2` 在此处被销毁，内存被释放\n" #: src/scope/raii.md:42 msgid "" "Of course, we can double check for memory errors using [`valgrind`](http://" "valgrind.org/info/):" msgstr "" "当然，我们可以使用 [`valgrind`](http://valgrind.org/info/) 来再次检查内存错" "误：" #: src/scope/raii.md:65 msgid "No leaks here!" msgstr "这里没有内存泄漏！" #: src/scope/raii.md:67 msgid "Destructor" msgstr "析构函数" #: src/scope/raii.md:69 msgid "" "The notion of a destructor in Rust is provided through the [`Drop`](https://" "doc.rust-lang.org/std/ops/trait.Drop.html) trait. The destructor is called " "when the resource goes out of scope. This trait is not required to be " "implemented for every type, only implement it for your type if you require " "its own destructor logic." msgstr "" "Rust 中的析构函数概念是通过 [`Drop`](https://doc.rust-lang.org/std/ops/" "trait.Drop.html) trait 提供的。当资源离开作用域时，析构函数会被调用。并非每种" "类型都需要实现这个 trait，只有当你需要为自己的类型实现特定的析构逻辑时才需要" "实现它。" #: src/scope/raii.md:74 msgid "" "Run the below example to see how the [`Drop`](https://doc.rust-lang.org/std/" "ops/trait.Drop.html) trait works. When the variable in the `main` function " "goes out of scope the custom destructor will be invoked." msgstr "" "运行下面的示例来了解 [`Drop`](https://doc.rust-lang.org/std/ops/" "trait.Drop.html) trait 是如何工作的。当 `main` 函数中的变量离开作用域时，自定" "义的析构函数将被调用。" #: src/scope/raii.md:82 msgid "\"ToDrop is being dropped\"" msgstr "\"ToDrop 正在被丢弃\"" #: src/scope/raii.md:88 msgid "\"Made a ToDrop!\"" msgstr "\"创建了一个 ToDrop！\"" #: src/scope/raii.md:94 msgid "[Box](../std/box.md)" msgstr "[Box](../std/box.md)" #: src/scope/move.md:3 msgid "" "Because variables are in charge of freeing their own resources, **resources " "can only have one owner**. This prevents resources from being freed more " "than once. Note that not all variables own resources (e.g. [references](../" "flow_control/match/destructuring/destructure_pointers.md))." msgstr "" "由于变量负责释放它们自己的资源，**资源只能有一个所有者**。这可以防止资源被多" "次释放。请注意，并非所有变量都拥有资源（例如[引用](../flow_control/match/" "destructuring/destructure_pointers.md)）。" #: src/scope/move.md:8 msgid "" "When doing assignments (`let x = y`) or passing function arguments by value " "(`foo(x)`), the _ownership_ of the resources is transferred. In Rust-speak, " "this is known as a _move_." msgstr "" "当进行赋值（`let x = y`）或按值传递函数参数（`foo(x)`）时，资源的**所有权**会" "被转移。在 Rust 中，这被称为**移动**（move）。" #: src/scope/move.md:12 msgid "" "After moving resources, the previous owner can no longer be used. This " "avoids creating dangling pointers." msgstr "资源移动后，原所有者将无法再被使用。这避免了悬垂指针的产生。" #: src/scope/move.md:16 msgid "// This function takes ownership of the heap allocated memory\n" msgstr "// 此函数获取堆分配内存的所有权\n" #: src/scope/move.md:18 msgid "\"Destroying a box that contains {}\"" msgstr "\"正在销毁一个包含 {} 的 box\"" #: src/scope/move.md:20 msgid "// `c` is destroyed and the memory freed\n" msgstr "// `c` 被销毁，内存被释放\n" #: src/scope/move.md:24 msgid "// _Stack_ allocated integer\n" msgstr "// **栈**分配的整数\n" #: src/scope/move.md:27 msgid "// *Copy* `x` into `y` - no resources are moved\n" msgstr "// 将 `x` **复制**到 `y` - 没有资源被移动\n" #: src/scope/move.md:30 msgid "// Both values can be independently used\n" msgstr "// 两个值可以独立使用\n" #: src/scope/move.md:31 msgid "\"x is {}, and y is {}\"" msgstr "\"x 是 {}，y 是 {}\"" #: src/scope/move.md:33 msgid "// `a` is a pointer to a _heap_ allocated integer\n" msgstr "// `a` 是指向**堆**分配整数的指针\n" #: src/scope/move.md:36 msgid "\"a contains: {}\"" msgstr "\"a 包含：{}\"" #: src/scope/move.md:38 msgid "// *Move* `a` into `b`\n" msgstr "// 将 `a` **移动**到 `b`\n" #: src/scope/move.md:40 msgid "" "// The pointer address of `a` is copied (not the data) into `b`.\n" " // Both are now pointers to the same heap allocated data, but\n" " // `b` now owns it.\n" msgstr "" "// `a` 的指针地址（而非数据）被复制到 `b`\n" " // 现在两者都指向同一块堆分配的数据\n" " // 但 `b` 现在拥有它\n" #: src/scope/move.md:44 msgid "" "// Error! `a` can no longer access the data, because it no longer owns the\n" " // heap memory\n" " //println!(\"a contains: {}\", a);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`a` 不再拥有堆内存，因此无法访问数据\n" " //println!(\"a 包含：{}\", a);\n" " // TODO ^ 尝试取消此行注释\n" #: src/scope/move.md:49 msgid "" "// This function takes ownership of the heap allocated memory from `b`\n" msgstr "// 此函数从 `b` 获取堆分配内存的所有权\n" #: src/scope/move.md:52 msgid "" "// Since the heap memory has been freed at this point, this action would\n" " // result in dereferencing freed memory, but it's forbidden by the " "compiler\n" " // Error! Same reason as the previous Error\n" " //println!(\"b contains: {}\", b);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 此时堆内存已被释放，这个操作会导致解引用已释放的内存\n" " // 但编译器禁止这样做\n" " // 错误！原因与前面的错误相同\n" " //println!(\"b 包含：{}\", b);\n" " // TODO ^ 尝试取消此行注释\n" #: src/scope/move/mut.md:3 msgid "Mutability of data can be changed when ownership is transferred." msgstr "当所有权转移时，数据的可变性可以改变。" #: src/scope/move/mut.md:9 msgid "\"immutable_box contains {}\"" msgstr "\"immutable_box 包含 {}\"" #: src/scope/move/mut.md:11 msgid "" "// Mutability error\n" " //*immutable_box = 4;\n" msgstr "" "// 可变性错误\n" " //*immutable_box = 4;\n" #: src/scope/move/mut.md:14 msgid "// *Move* the box, changing the ownership (and mutability)\n" msgstr "// *移动*盒子，改变所有权（和可变性）\n" #: src/scope/move/mut.md:17 msgid "\"mutable_box contains {}\"" msgstr "\"mutable_box 包含 {}\"" #: src/scope/move/mut.md:19 msgid "// Modify the contents of the box\n" msgstr "// 修改盒子的内容\n" #: src/scope/move/mut.md:22 msgid "\"mutable_box now contains {}\"" msgstr "\"mutable_box 现在包含 {}\"" #: src/scope/move/partial_move.md:3 msgid "" "Within the [destructuring](../../flow_control/match/destructuring.md) of a " "single variable, both `by-move` and `by-reference` pattern bindings can be " "used at the same time. Doing this will result in a _partial move_ of the " "variable, which means that parts of the variable will be moved while other " "parts stay. In such a case, the parent variable cannot be used afterwards as " "a whole, however the parts that are only referenced (and not moved) can " "still be used. Note that types that implement the [`Drop` trait](../../trait/" "drop.md) cannot be partially moved from, because its `drop` method would use " "it afterwards as a whole." msgstr "" "在对单个变量进行[解构](../../flow_control/match/destructuring.md)时，可以同时" "使用 `by-move` 和 `by-reference` 模式绑定。这样做会导致变量的**部分移动**，这" "意味着变量的一部分会被移动，而其他部分保持不变。在这种情况下，父级变量之后不" "能作为一个整体使用，但是仍然可以使用只被引用（而不是被移动）的部分。注意，实" "现了 [`Drop` 特质](../../trait/drop.md) 的类型不能被部分移动，因为其 `drop` " "方法会在之后将其作为整体使用。" #: src/scope/move/partial_move.md:22 msgid "" "// Error! cannot move out of a type which implements the `Drop` trait\n" " //impl Drop for Person {\n" " // fn drop(&mut self) {\n" " // println!(\"Dropping the person struct {:?}\", self)\n" " // }\n" " //}\n" " // TODO ^ Try uncommenting these lines\n" msgstr "" "// 错误！无法从实现了 `Drop` 特质的类型中移动\n" " //impl Drop for Person {\n" " // fn drop(&mut self) {\n" " // println!(\"Dropping the person struct {:?}\", self)\n" " // }\n" " //}\n" " // TODO ^ 尝试取消注释这些行\n" #: src/scope/move/partial_move.md:35 msgid "// `name` is moved out of person, but `age` is referenced\n" msgstr "// `name` 从 person 中被移出，但 `age` 只是被引用\n" #: src/scope/move/partial_move.md:38 msgid "\"The person's age is {}\"" msgstr "\"此人的年龄是 {}\"" #: src/scope/move/partial_move.md:40 msgid "\"The person's name is {}\"" msgstr "\"此人的姓名是 {}\"" #: src/scope/move/partial_move.md:42 msgid "" "// Error! borrow of partially moved value: `person` partial move occurs\n" " //println!(\"The person struct is {:?}\", person);\n" msgstr "" "// 错误！借用部分移动的值：`person` 发生部分移动\n" " //println!(\"person 结构体是 {:?}\", person);\n" #: src/scope/move/partial_move.md:45 msgid "" "// `person` cannot be used but `person.age` can be used as it is not moved\n" msgstr "// `person` 不能使用，但 `person.age` 可以使用，因为它没有被移动\n" #: src/scope/move/partial_move.md:46 msgid "\"The person's age from person struct is {}\"" msgstr "\"从 person 结构体中获取的年龄是 {}\"" #: src/scope/move/partial_move.md:50 msgid "" "(In this example, we store the `age` variable on the heap to illustrate the " "partial move: deleting `ref` in the above code would give an error as the " "ownership of `person.age` would be moved to the variable `age`. If " "`Person.age` were stored on the stack, `ref` would not be required as the " "definition of `age` would copy the data from `person.age` without moving it.)" msgstr "" "（在这个例子中，我们将 `age` 变量存储在堆上以说明部分移动：删除上面代码中的 " "`ref` 会导致错误，因为 `person.age` 的所有权会被移动到变量 `age`。如果 " "`Person.age` 存储在栈上，就不需要 `ref`，因为 `age` 的定义会从 `person.age` " "复制数据而不是移动它。）" #: src/scope/move/partial_move.md:59 msgid "[destructuring](../../flow_control/match/destructuring.md)" msgstr "[解构](../../flow_control/match/destructuring.md)" #: src/scope/borrow.md:3 msgid "" "Most of the time, we'd like to access data without taking ownership over it. " "To accomplish this, Rust uses a _borrowing_ mechanism. Instead of passing " "objects by value (`T`), objects can be passed by reference (`&T`)." msgstr "" "大多数情况下，我们希望访问数据而不获取其所有权。为了实现这一点，Rust 使用了**" "借用**机制。对象可以通过引用（`&T`）传递，而不是按值（`T`）传递。" #: src/scope/borrow.md:7 msgid "" "The compiler statically guarantees (via its borrow checker) that references " "_always_ point to valid objects. That is, while references to an object " "exist, the object cannot be destroyed." msgstr "" "编译器通过其借用检查器静态地保证引用**始终**指向有效的对象。也就是说，当存在" "指向一个对象的引用时，该对象就不能被销毁。" #: src/scope/borrow.md:12 msgid "// This function takes ownership of a box and destroys it\n" msgstr "// 此函数获取一个盒子的所有权并销毁它\n" #: src/scope/borrow.md:14 msgid "\"Destroying box that contains {}\"" msgstr "\"正在销毁包含 {} 的盒子\"" #: src/scope/borrow.md:16 msgid "// This function borrows an i32\n" msgstr "// 此函数借用一个 i32\n" #: src/scope/borrow.md:19 msgid "\"This int is: {}\"" msgstr "\"这个整数是：{}\"" #: src/scope/borrow.md:23 msgid "" "// Create a boxed i32 in the heap, and an i32 on the stack\n" " // Remember: numbers can have arbitrary underscores added for " "readability\n" " // 5_i32 is the same as 5i32\n" msgstr "" "// 在堆上创建一个装箱的 i32，在栈上创建一个 i32\n" " // 注意：数字可以添加任意下划线以提高可读性\n" " // 5_i32 与 5i32 相同\n" #: src/scope/borrow.md:29 msgid "" "// Borrow the contents of the box. Ownership is not taken,\n" " // so the contents can be borrowed again.\n" msgstr "" "// 借用盒子的数据。所有权未被获取，\n" " // 所以数据可以再次被借用。\n" #: src/scope/borrow.md:35 msgid "// Take a reference to the data contained inside the box\n" msgstr "// 获取盒子内数据的引用\n" #: src/scope/borrow.md:38 msgid "" "// Error!\n" " // Can't destroy `boxed_i32` while the inner value is borrowed later " "in scope.\n" msgstr "" "// 错误！\n" " // 当内部值在作用域内稍后被借用时，不能销毁 `boxed_i32`。\n" #: src/scope/borrow.md:43 msgid "// Attempt to borrow `_ref_to_i32` after inner value is destroyed\n" msgstr "// 尝试在内部值被销毁后借用 `_ref_to_i32`\n" #: src/scope/borrow.md:45 msgid "// `_ref_to_i32` goes out of scope and is no longer borrowed.\n" msgstr "// `_ref_to_i32` 超出作用域，不再被借用。\n" #: src/scope/borrow.md:48 msgid "" "// `boxed_i32` can now give up ownership to `eat_box_i32` and be destroyed\n" msgstr "// `boxed_i32` 现在可以将所有权交给 `eat_box_i32` 并被销毁\n" #: src/scope/borrow/mut.md:3 msgid "" "Mutable data can be mutably borrowed using `&mut T`. This is called a " "_mutable reference_ and gives read/write access to the borrower. In " "contrast, `&T` borrows the data via an immutable reference, and the borrower " "can read the data but not modify it:" msgstr "" "可变数据可以使用 `&mut T` 进行可变借用。这被称为**可变引用**，并给予借用者读" "写访问权。相比之下，`&T` 通过不可变引用借用数据，借用者可以读取数据但不能修改" "它：" #: src/scope/borrow/mut.md:12 msgid "" "// `&'static str` is a reference to a string allocated in read only memory\n" msgstr "// `&'static str` 是对分配在只读内存中的字符串的引用\n" #: src/scope/borrow/mut.md:17 msgid "// This function takes a reference to a book\n" msgstr "// 此函数接受一个对 Book 类型的引用\n" #: src/scope/borrow/mut.md:20 msgid "\"I immutably borrowed {} - {} edition\"" msgstr "\"我不可变地借用了《{}》- {} 版\"" #: src/scope/borrow/mut.md:22 msgid "" "// This function takes a reference to a mutable book and changes `year` to " "2014\n" msgstr "// 此函数接受一个对可变 Book 的引用，并将 `year` 改为 2014\n" #: src/scope/borrow/mut.md:26 msgid "\"I mutably borrowed {} - {} edition\"" msgstr "\"我可变地借用了《{}》- {} 版\"" #: src/scope/borrow/mut.md:30 msgid "// Create an immutable Book named `immutabook`\n" msgstr "// 创建一个名为 `immutabook` 的不可变 Book 实例\n" #: src/scope/borrow/mut.md:32 msgid "// string literals have type `&'static str`\n" msgstr "// 字符串字面量的类型是 `&'static str`\n" #: src/scope/borrow/mut.md:33 msgid "\"Douglas Hofstadter\"" msgstr "\"Douglas Hofstadter\"" #: src/scope/borrow/mut.md:34 msgid "\"Gödel, Escher, Bach\"" msgstr "\"哥德尔、埃舍尔、巴赫\"" #: src/scope/borrow/mut.md:38 msgid "// Create a mutable copy of `immutabook` and call it `mutabook`\n" msgstr "// 创建 `immutabook` 的可变副本，并命名为 `mutabook`\n" #: src/scope/borrow/mut.md:41 msgid "// Immutably borrow an immutable object\n" msgstr "// 不可变地借用一个不可变对象\n" #: src/scope/borrow/mut.md:44 msgid "// Immutably borrow a mutable object\n" msgstr "// 不可变地借用一个可变对象\n" #: src/scope/borrow/mut.md:47 msgid "// Borrow a mutable object as mutable\n" msgstr "// 可变地借用一个可变对象\n" #: src/scope/borrow/mut.md:50 msgid "// Error! Cannot borrow an immutable object as mutable\n" msgstr "// 错误！不能将不可变对象作为可变对象借用\n" #: src/scope/borrow/mut.md:58 msgid "[`static`](../lifetime/static_lifetime.md)" msgstr "[`static`](../lifetime/static_lifetime.md)" #: src/scope/borrow/alias.md:3 msgid "" "Data can be immutably borrowed any number of times, but while immutably " "borrowed, the original data can't be mutably borrowed. On the other hand, " "only _one_ mutable borrow is allowed at a time. The original data can be " "borrowed again only _after_ the mutable reference has been used for the last " "time." msgstr "" "数据可以被不可变借用任意次数，但在不可变借用期间，原始数据不能被可变借用。另" "一方面，同一时间只允许**一个**可变借用。只有在可变引用最后一次使用之后，原始" "数据才能再次被借用。" #: src/scope/borrow/alias.md:17 msgid "// Data can be accessed via the references and the original owner\n" msgstr "// 可以通过引用和原始所有者访问数据\n" #: src/scope/borrow/alias.md:18 src/scope/borrow/alias.md:27 #: src/scope/borrow/alias.md:49 msgid "\"Point has coordinates: ({}, {}, {})\"" msgstr "\"点的坐标为：({}, {}, {})\"" #: src/scope/borrow/alias.md:21 msgid "" "// Error! Can't borrow `point` as mutable because it's currently\n" " // borrowed as immutable.\n" " // let mutable_borrow = &mut point;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！不能将 `point` 作为可变借用，因为它当前被不可变借用。\n" " // let mutable_borrow = &mut point;\n" " // TODO ^ 尝试取消注释此行\n" #: src/scope/borrow/alias.md:26 msgid "// The borrowed values are used again here\n" msgstr "// 这里再次使用了借用的值\n" #: src/scope/borrow/alias.md:30 msgid "" "// The immutable references are no longer used for the rest of the code so\n" " // it is possible to reborrow with a mutable reference.\n" msgstr "" "// 不可变引用在代码的剩余部分不再使用\n" " // 因此可以用可变引用重新借用。\n" #: src/scope/borrow/alias.md:34 msgid "// Change data via mutable reference\n" msgstr "// 通过可变引用修改数据\n" #: src/scope/borrow/alias.md:39 msgid "" "// Error! Can't borrow `point` as immutable because it's currently\n" " // borrowed as mutable.\n" " // let y = &point.y;\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！不能将 `point` 作为不可变借用，因为它当前被可变借用。\n" " // let y = &point.y;\n" " // TODO ^ 尝试取消注释此行\n" #: src/scope/borrow/alias.md:44 msgid "" "// Error! Can't print because `println!` takes an immutable reference.\n" " // println!(\"Point Z coordinate is {}\", point.z);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！无法打印，因为 `println!` 需要一个不可变引用。\n" " // println!(\"点的 Z 坐标是 {}\", point.z);\n" " // TODO ^ 尝试取消注释此行\n" #: src/scope/borrow/alias.md:48 msgid "// Ok! Mutable references can be passed as immutable to `println!`\n" msgstr "// 正确！可变引用可以作为不可变引用传递给 `println!`\n" #: src/scope/borrow/alias.md:52 msgid "" "// The mutable reference is no longer used for the rest of the code so it\n" " // is possible to reborrow\n" msgstr "// 可变引用在代码的剩余部分不再使用，所以可以重新借用\n" #: src/scope/borrow/alias.md:55 msgid "\"Point now has coordinates: ({}, {}, {})\"" msgstr "\"点现在的坐标为：({}, {}, {})\"" #: src/scope/borrow/ref.md:3 msgid "" "When doing pattern matching or destructuring via the `let` binding, the " "`ref` keyword can be used to take references to the fields of a struct/" "tuple. The example below shows a few instances where this can be useful:" msgstr "" "在使用 `let` 绑定进行模式匹配或解构时，可以使用 `ref` 关键字来获取结构体或元" "组字段的引用。以下示例展示了几个这种用法有用的场景：" #: src/scope/borrow/ref.md:14 msgid "" "// A `ref` borrow on the left side of an assignment is equivalent to\n" " // an `&` borrow on the right side.\n" msgstr "// 赋值左侧的 `ref` 借用等同于右侧的 `&` 借用。\n" #: src/scope/borrow/ref.md:19 msgid "\"ref_c1 equals ref_c2: {}\"" msgstr "\"ref_c1 等于 ref_c2：{}\"" #: src/scope/borrow/ref.md:23 msgid "// `ref` is also valid when destructuring a struct.\n" msgstr "// 在解构结构体时，`ref` 也是有效的。\n" #: src/scope/borrow/ref.md:25 msgid "// `ref_to_x` is a reference to the `x` field of `point`.\n" msgstr "// `ref_to_x` 是 `point` 的 `x` 字段的引用。\n" #: src/scope/borrow/ref.md:28 msgid "// Return a copy of the `x` field of `point`.\n" msgstr "// 返回 `point` 的 `x` 字段的副本。\n" #: src/scope/borrow/ref.md:32 msgid "// A mutable copy of `point`\n" msgstr "// `point` 的可变副本\n" #: src/scope/borrow/ref.md:36 msgid "// `ref` can be paired with `mut` to take mutable references.\n" msgstr "// `ref` 可以与 `mut` 配合使用来获取可变引用。\n" #: src/scope/borrow/ref.md:39 msgid "// Mutate the `y` field of `mutable_point` via a mutable reference.\n" msgstr "// 通过可变引用修改 `mutable_point` 的 `y` 字段。\n" #: src/scope/borrow/ref.md:43 msgid "\"point is ({}, {})\"" msgstr "\"point 的坐标是 ({}, {})\"" #: src/scope/borrow/ref.md:44 msgid "\"mutable_point is ({}, {})\"" msgstr "\"mutable_point 的坐标是 ({}, {})\"" #: src/scope/borrow/ref.md:46 msgid "// A mutable tuple that includes a pointer\n" msgstr "// 包含指针的可变元组\n" #: src/scope/borrow/ref.md:50 msgid "// Destructure `mutable_tuple` to change the value of `last`.\n" msgstr "// 解构 `mutable_tuple` 以修改 `last` 的值。\n" #: src/scope/borrow/ref.md:55 msgid "\"tuple is {:?}\"" msgstr "\"元组是 {:?}\"" #: src/scope/lifetime.md:3 msgid "" "A _lifetime_ is a construct the compiler (or more specifically, its _borrow " "checker_) uses to ensure all borrows are valid. Specifically, a variable's " "lifetime begins when it is created and ends when it is destroyed. While " "lifetimes and scopes are often referred to together, they are not the same." msgstr "" "**生命周期**是编译器（更具体地说是其**借用检查器**）用来确保所有借用都有效的" "一种机制。具体来说，变量的生命周期从创建时开始，到销毁时结束。尽管生命周期和" "作用域经常被一同提及，但它们并不完全相同。" #: src/scope/lifetime.md:8 msgid "" "Take, for example, the case where we borrow a variable via `&`. The borrow " "has a lifetime that is determined by where it is declared. As a result, the " "borrow is valid as long as it ends before the lender is destroyed. However, " "the scope of the borrow is determined by where the reference is used." msgstr "" "举个例子，当我们通过 `&` 借用一个变量时，这个借用的生命周期由其声明位置决定。" "因此，只要借用在出借者被销毁之前结束，它就是有效的。然而，借用的作用域则由引" "用使用的位置决定。" #: src/scope/lifetime.md:13 msgid "" "In the following example and in the rest of this section, we will see how " "lifetimes relate to scopes, as well as how the two differ." msgstr "" "在接下来的例子和本节的其余部分中，我们将看到生命周期如何与作用域相关联，以及" "两者之间的区别。" #: src/scope/lifetime.md:17 msgid "" "// Lifetimes are annotated below with lines denoting the creation\n" "// and destruction of each variable.\n" "// `i` has the longest lifetime because its scope entirely encloses\n" "// both `borrow1` and `borrow2`. The duration of `borrow1` compared\n" "// to `borrow2` is irrelevant since they are disjoint.\n" msgstr "" "// 下面用线条标注了每个变量的创建和销毁，以表示生命周期。\n" "// `i` 的生命周期最长，因为它的作用域完全包含了 `borrow1` 和 `borrow2`。\n" "// `borrow1` 相对于 `borrow2` 的持续时间是无关紧要的，因为它们是不相交的。\n" "// （译注：为避免中文的宽度显示问题，下面注释没有翻译） \n" #: src/scope/lifetime.md:23 msgid "" "// Lifetime for `i` starts. ────────────────┐\n" " // │\n" msgstr "" "// Lifetime for `i` starts. ────────────────┐\n" " // │\n" #: src/scope/lifetime.md:25 src/scope/lifetime.md:32 msgid "// │\n" msgstr "// │\n" #: src/scope/lifetime.md:26 msgid "" "// `borrow1` lifetime starts. ──┐│\n" " // ││\n" msgstr "" "// `borrow1` lifetime starts. ──┐│\n" " // ││\n" #: src/scope/lifetime.md:28 msgid "\"borrow1: {}\"" msgstr "\"borrow1: {}\"" #: src/scope/lifetime.md:28 src/scope/lifetime.md:35 msgid "// ││\n" msgstr "// ││\n" #: src/scope/lifetime.md:29 msgid "" "// `borrow1` ends. ─────────────────────────────────┘│\n" " // │\n" " // │\n" msgstr "" "// `borrow1` ends. ─────────────────────────────────┘│\n" " // │\n" " // │\n" #: src/scope/lifetime.md:33 msgid "" "// `borrow2` lifetime starts. ──┐│\n" " // ││\n" msgstr "" "// `borrow2` lifetime starts. ──┐│\n" " // ││\n" #: src/scope/lifetime.md:35 msgid "\"borrow2: {}\"" msgstr "\"borrow2: {}\"" #: src/scope/lifetime.md:36 msgid "" "// `borrow2` ends. ─────────────────────────────────┘│\n" " // │\n" msgstr "" "// `borrow2` ends. ─────────────────────────────────┘│\n" " // │\n" #: src/scope/lifetime.md:38 msgid "// Lifetime ends. ─────────────────────────────────────┘\n" msgstr "// Lifetime ends. ─────────────────────────────────────┘\n" #: src/scope/lifetime.md:41 msgid "" "Note that no names or types are assigned to label lifetimes. This restricts " "how lifetimes will be able to be used as we will see." msgstr "" "请注意，生命周期标签没有被赋予名称或类型。这限制了生命周期的使用方式，我们将" "在后面看到这一点。" #: src/scope/lifetime/explicit.md:3 msgid "" "The borrow checker uses explicit lifetime annotations to determine how long " "references should be valid. In cases where lifetimes are not elided[^1], " "Rust requires explicit annotations to determine what the lifetime of a " "reference should be. The syntax for explicitly annotating a lifetime uses an " "apostrophe character as follows:" msgstr "" "借用检查器使用显式生命周期注解来确定引用应该有效多长时间。在生命周期没有被省" "略[^1]的情况下，Rust 需要显式注解来确定引用的生命周期。显式注解生命周期的语法" "使用撇号字符，如下所示：" #: src/scope/lifetime/explicit.md:10 msgid "// `foo` has a lifetime parameter `'a`\n" msgstr "// `foo` 有一个生命周期参数 `'a`\n" #: src/scope/lifetime/explicit.md:14 msgid "" "Similar to [closures](../../fn/closures/anonymity.md), using lifetimes " "requires generics. Additionally, this lifetime syntax indicates that the " "lifetime of `foo` may not exceed that of `'a`. Explicit annotation of a type " "has the form `&'a T` where `'a` has already been introduced." msgstr "" "类似于[闭包](../../fn/closures/anonymity.md)，使用生命周期需要泛型。此外，这" "种生命周期语法表示 `foo` 的生命周期不能超过 `'a` 的生命周期。类型的显式注解形" "式为 `&'a T`，其中 `'a` 已经被引入。" #: src/scope/lifetime/explicit.md:19 msgid "In cases with multiple lifetimes, the syntax is similar:" msgstr "在有多个生命周期的情况下，语法类似：" #: src/scope/lifetime/explicit.md:22 msgid "// `foo` has lifetime parameters `'a` and `'b`\n" msgstr "// `foo` 有生命周期参数 `'a` 和 `'b`\n" #: src/scope/lifetime/explicit.md:26 msgid "" "In this case, the lifetime of `foo` cannot exceed that of either `'a` _or_ " "`'b`." msgstr "在这种情况下，`foo` 的生命周期不能超过 `'a` **或** `'b` 的生命周期。" #: src/scope/lifetime/explicit.md:28 msgid "See the following example for explicit lifetime annotation in use:" msgstr "请看下面的例子，展示了显式生命周期注解的使用：" #: src/scope/lifetime/explicit.md:31 msgid "" "// `print_refs` takes two references to `i32` which have different\n" "// lifetimes `'a` and `'b`. These two lifetimes must both be at\n" "// least as long as the function `print_refs`.\n" msgstr "" "// `print_refs` 接受两个 `i32` 的引用，它们有不同的\n" "// 生命周期 `'a` 和 `'b`。这两个生命周期都必须\n" "// 至少和函数 `print_refs` 一样长。\n" #: src/scope/lifetime/explicit.md:35 msgid "\"x is {} and y is {}\"" msgstr "\"x 是 {}，y 是 {}\"" #: src/scope/lifetime/explicit.md:37 msgid "" "// A function which takes no arguments, but has a lifetime parameter `'a`.\n" msgstr "// 一个没有参数但有生命周期参数 `'a` 的函数。\n" #: src/scope/lifetime/explicit.md:42 msgid "// ERROR: `_x` does not live long enough\n" msgstr "// 错误：`_x` 的生命周期不够长\n" #: src/scope/lifetime/explicit.md:44 msgid "" "// Attempting to use the lifetime `'a` as an explicit type annotation\n" " // inside the function will fail because the lifetime of `&_x` is " "shorter\n" " // than that of `_y`. A short lifetime cannot be coerced into a longer " "one.\n" msgstr "" "// 尝试在函数内部使用生命周期 `'a` 作为显式类型标注会失败，\n" " // 因为 `&_x` 的生命周期比 `_y` 的短。\n" " // 短生命周期无法强制转换为长生命周期。\n" #: src/scope/lifetime/explicit.md:50 msgid "// Create variables to be borrowed below.\n" msgstr "// 创建将要被借用的变量。\n" #: src/scope/lifetime/explicit.md:53 msgid "// Borrows (`&`) of both variables are passed into the function.\n" msgstr "// 将两个变量的借用（`&`）传递给函数。\n" #: src/scope/lifetime/explicit.md:55 msgid "" "// Any input which is borrowed must outlive the borrower.\n" " // In other words, the lifetime of `four` and `nine` must\n" " // be longer than that of `print_refs`.\n" msgstr "" "// 任何被借用的输入必须比借用者存活更久。\n" " // 换句话说，`four` 和 `nine` 的生命周期必须\n" " // 比 `print_refs` 的生命周期更长。\n" #: src/scope/lifetime/explicit.md:60 msgid "" "// `failed_borrow` contains no references to force `'a` to be\n" " // longer than the lifetime of the function, but `'a` is longer.\n" " // Because the lifetime is never constrained, it defaults to `'static`.\n" msgstr "" "// `failed_borrow` 不包含任何引用来强制 `'a` 比函数的生命周期更长，\n" " // 但 `'a` 实际上更长。\n" " // 因为生命周期从未被约束，它默认为 `'static`。\n" #: src/scope/lifetime/explicit.md:66 msgid "" "[elision](elision.md) implicitly annotates lifetimes and so is different." msgstr "[省略（elision）](elision.md)隐式地注解生命周期，因此与显式注解不同。" #: src/scope/lifetime/explicit.md:70 msgid "[generics](../../generics.md) and [closures](../../fn/closures.md)" msgstr "" "[泛型（generics）](../../generics.md)和[闭包（closures）](../../fn/" "closures.md)" #: src/scope/lifetime/fn.md:3 msgid "" "Ignoring [elision](elision.md), function signatures with lifetimes have a " "few constraints:" msgstr "" "排除[省略（elision）](elision.md)的情况，带有生命周期的函数签名有以下几个约" "束：" #: src/scope/lifetime/fn.md:5 msgid "any reference _must_ have an annotated lifetime." msgstr "任何引用**必须**有一个标注的生命周期。" #: src/scope/lifetime/fn.md:6 msgid "" "any reference being returned _must_ have the same lifetime as an input or be " "`static`." msgstr "任何被返回的引用**必须**具有与输入相同的生命周期或者是 `static`。" #: src/scope/lifetime/fn.md:9 msgid "" "Additionally, note that returning references without input is banned if it " "would result in returning references to invalid data. The following example " "shows off some valid forms of functions with lifetimes:" msgstr "" "此外，请注意，如果返回引用而没有输入会导致返回指向无效数据的引用，这是被禁止" "的。以下示例展示了一些带有生命周期的有效函数形式：" #: src/scope/lifetime/fn.md:14 msgid "" "// One input reference with lifetime `'a` which must live\n" "// at least as long as the function.\n" msgstr "// 一个具有生命周期 `'a` 的输入引用，它必须至少与函数存活一样长。\n" #: src/scope/lifetime/fn.md:17 msgid "\"`print_one`: x is {}\"" msgstr "\"`print_one`：x 是 {}\"" #: src/scope/lifetime/fn.md:19 msgid "// Mutable references are possible with lifetimes as well.\n" msgstr "// 可变引用也可以有生命周期。\n" #: src/scope/lifetime/fn.md:24 msgid "" "// Multiple elements with different lifetimes. In this case, it\n" "// would be fine for both to have the same lifetime `'a`, but\n" "// in more complex cases, different lifetimes may be required.\n" msgstr "" "// 多个具有不同生命周期的元素。在这种情况下，\n" "// 两者都有相同的生命周期 `'a` 是可以的，但\n" "// 在更复杂的情况下，可能需要不同的生命周期。\n" #: src/scope/lifetime/fn.md:29 msgid "\"`print_multi`: x is {}, y is {}\"" msgstr "\"`print_multi`：x 是 {}，y 是 {}\"" #: src/scope/lifetime/fn.md:31 msgid "" "// Returning references that have been passed in is acceptable.\n" "// However, the correct lifetime must be returned.\n" msgstr "" "// 返回已传入的引用是可以接受的。\n" "// 但是，必须返回正确的生命周期。\n" #: src/scope/lifetime/fn.md:35 msgid "" "//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n" "// The above is invalid: `'a` must live longer than the function.\n" "// Here, `&String::from(\"foo\")` would create a `String`, followed by a\n" "// reference. Then the data is dropped upon exiting the scope, leaving\n" "// a reference to invalid data to be returned.\n" msgstr "" "//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n" "// 上面的代码是无效的：`'a` 必须比函数存活更长。\n" "// 这里的 `&String::from(\"foo\")` 会创建一个 `String`，然后创建一个引用。\n" "// 接着，在退出作用域时数据被丢弃，导致返回一个指向无效数据的引用。\n" #: src/scope/lifetime/fn.md:60 msgid "[Functions](../../fn.md)" msgstr "[函数](../../fn.md)" #: src/scope/lifetime/methods.md:3 msgid "Methods are annotated similarly to functions:" msgstr "方法的生命周期注解与函数类似：" #: src/scope/lifetime/methods.md:9 msgid "// Annotate lifetimes as in a standalone function.\n" msgstr "// 像独立函数一样注解生命周期。\n" #: src/scope/lifetime/methods.md:12 msgid "\"`print`: {}\"" msgstr "\"`print`：{}\"" #: src/scope/lifetime/methods.md:26 msgid "[methods](../../fn/methods.md)" msgstr "[方法](../../fn/methods.md)" #: src/scope/lifetime/struct.md:3 msgid "Annotation of lifetimes in structures are also similar to functions:" msgstr "结构体中生命周期的注解也与函数类似：" #: src/scope/lifetime/struct.md:6 msgid "" "// A type `Borrowed` which houses a reference to an\n" "// `i32`. The reference to `i32` must outlive `Borrowed`.\n" msgstr "" "// `Borrowed` 类型包含一个 `i32` 的引用。\n" "// 这个 `i32` 的引用必须比 `Borrowed` 存活更久。\n" #: src/scope/lifetime/struct.md:10 msgid "// Similarly, both references here must outlive this structure.\n" msgstr "// 同样，这里的两个引用都必须比这个结构体存活更久。\n" #: src/scope/lifetime/struct.md:17 msgid "// An enum which is either an `i32` or a reference to one.\n" msgstr "// 一个枚举，可以是 `i32`，或者是 `i32` 的引用。\n" #: src/scope/lifetime/struct.md:34 src/scope/lifetime/struct.md:36 msgid "\"x is borrowed in {:?}\"" msgstr "\"x 在 {:?} 中被借用\"" #: src/scope/lifetime/struct.md:35 msgid "\"x and y are borrowed in {:?}\"" msgstr "\"x 和 y 在 {:?} 中被借用\"" #: src/scope/lifetime/struct.md:37 msgid "\"y is *not* borrowed in {:?}\"" msgstr "\"y 在 {:?} 中**没有**被借用\"" #: src/scope/lifetime/struct.md:43 msgid "[`struct`s](../../custom_types/structs.md)" msgstr "[`struct`（结构体）](../../custom_types/structs.md)" #: src/scope/lifetime/trait.md:3 msgid "" "Annotation of lifetimes in trait methods basically are similar to functions. " "Note that `impl` may have annotation of lifetimes too." msgstr "" "trait 方法中的生命周期注解基本上与函数类似。注意，`impl` 也可能需要生命周期注" "解。" #: src/scope/lifetime/trait.md:7 msgid "// A struct with annotation of lifetimes.\n" msgstr "// 一个带有生命周期注解的结构体。\n" #: src/scope/lifetime/trait.md:12 msgid "// Annotate lifetimes to impl.\n" msgstr "// 为 impl 添加生命周期注解。\n" #: src/scope/lifetime/trait.md:24 msgid "\"b is {:?}\"" msgstr "\"b 是 {:?}\"" #: src/scope/lifetime/trait.md:30 msgid "[`trait`s](../../trait.md)" msgstr "[`trait`](../../trait.md)" #: src/scope/lifetime/lifetime_bounds.md:3 msgid "" "Just like generic types can be bounded, lifetimes (themselves generic) use " "bounds as well. The `:` character has a slightly different meaning here, but " "`+` is the same. Note how the following read:" msgstr "" "正如泛型类型可以被约束一样，生命周期（本身也是泛型）也可以使用约束。这里的 " "`:` 符号含义略有不同，但 `+` 的用法相同。请注意以下表达的含义：" #: src/scope/lifetime/lifetime_bounds.md:7 msgid "`T: 'a`: _All_ references in `T` must outlive lifetime `'a`." msgstr "`T: 'a`：`T` 中的**所有**引用必须比生命周期 `'a` 存活更久。" #: src/scope/lifetime/lifetime_bounds.md:8 msgid "" "`T: Trait + 'a`: Type `T` must implement trait `Trait` and _all_ references " "in `T` must outlive `'a`." msgstr "" "`T: Trait + 'a`：类型 `T` 必须实现 trait `Trait`，并且 `T` 中的**所有**引用必" "须比 `'a` 存活更久。" #: src/scope/lifetime/lifetime_bounds.md:11 msgid "" "The example below shows the above syntax in action used after keyword " "`where`:" msgstr "下面的例子展示了上述语法在 `where` 关键字之后的实际应用：" #: src/scope/lifetime/lifetime_bounds.md:14 msgid "// Trait to bound with.\n" msgstr "// 用于约束的 trait。\n" #: src/scope/lifetime/lifetime_bounds.md:17 msgid "" "// `Ref` contains a reference to a generic type `T` that has\n" "// some lifetime `'a` unknown by `Ref`. `T` is bounded such that any\n" "// *references* in `T` must outlive `'a`. Additionally, the lifetime\n" "// of `Ref` may not exceed `'a`.\n" msgstr "" "// `Ref` 包含一个指向泛型类型 `T` 的引用，`T` 具有一个 `Ref` 未知的\n" "// 生命周期 `'a`。`T` 受到约束，使得 `T` 中的任何*引用*必须比 `'a` 存活更" "久。\n" "// 此外，`Ref` 的生命周期不能超过 `'a`。\n" #: src/scope/lifetime/lifetime_bounds.md:22 msgid "// A generic function which prints using the `Debug` trait.\n" msgstr "// 一个使用 `Debug` trait 进行打印的泛型函数。\n" #: src/scope/lifetime/lifetime_bounds.md:26 msgid "\"`print`: t is {:?}\"" msgstr "\"`print`: t 是 {:?}\"" #: src/scope/lifetime/lifetime_bounds.md:28 msgid "" "// Here a reference to `T` is taken where `T` implements\n" "// `Debug` and all *references* in `T` outlive `'a`. In\n" "// addition, `'a` must outlive the function.\n" msgstr "" "// 这里取了一个 `T` 的引用，其中 `T` 实现了\n" "// `Debug` 并且 `T` 中的所有*引用*都比 `'a` 存活更久。\n" "// 此外，`'a` 必须比函数存活更久。\n" #: src/scope/lifetime/lifetime_bounds.md:34 msgid "\"`print_ref`: t is {:?}\"" msgstr "\"`print_ref`: t 是 {:?}\"" #: src/scope/lifetime/lifetime_bounds.md:48 msgid "" "[generics](../../generics.md), [bounds in generics](../../generics/" "bounds.md), and [multiple bounds in generics](../../generics/multi_bounds.md)" msgstr "" "[泛型](../../generics.md)、[泛型中的约束](../../generics/bounds.md)和[泛型中" "的多重约束](../../generics/multi_bounds.md)" #: src/scope/lifetime/lifetime_coercion.md:3 msgid "" "A longer lifetime can be coerced into a shorter one so that it works inside " "a scope it normally wouldn't work in. This comes in the form of inferred " "coercion by the Rust compiler, and also in the form of declaring a lifetime " "difference:" msgstr "" "一个较长的生命周期可以被强制转换为一个较短的生命周期，使其能在通常无法工作的" "作用域内工作。这种转换可以通过 Rust 编译器的推断自动完成，也可以通过声明不同" "的生命周期的形式实现：" #: src/scope/lifetime/lifetime_coercion.md:9 msgid "" "// Here, Rust infers a lifetime that is as short as possible.\n" "// The two references are then coerced to that lifetime.\n" msgstr "" "// 在这里，Rust 推断出一个尽可能短的生命周期。\n" "// 然后两个引用被强制转换为该生命周期。\n" #: src/scope/lifetime/lifetime_coercion.md:14 msgid "" "// `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`.\n" "// Here, we take in an `&'a i32` and return a `&'b i32` as a result of " "coercion.\n" msgstr "" "// `<'a: 'b, 'b>` 表示生命周期 `'a` 至少和 `'b` 一样长。\n" "// 这里，我们接收一个 `&'a i32` 并返回一个 `&'b i32` 作为强制转换的结果。\n" #: src/scope/lifetime/lifetime_coercion.md:22 msgid "// Longer lifetime\n" msgstr "// 较长的生命周期\n" #: src/scope/lifetime/lifetime_coercion.md:25 msgid "// Shorter lifetime\n" msgstr "// 较短的生命周期\n" #: src/scope/lifetime/lifetime_coercion.md:27 msgid "\"The product is {}\"" msgstr "\"乘积是 {}\"" #: src/scope/lifetime/lifetime_coercion.md:28 msgid "\"{} is the first\"" msgstr "\"{} 是第一个\"" #: src/scope/lifetime/static_lifetime.md:3 msgid "" "Rust has a few reserved lifetime names. One of those is `'static`. You might " "encounter it in two situations:" msgstr "" "Rust 有几个保留的生命周期名称。其中之一是 `'static`。你可能在两种情况下遇到" "它：" #: src/scope/lifetime/static_lifetime.md:7 msgid "// A reference with 'static lifetime:\n" msgstr "// 具有 'static 生命周期的引用：\n" #: src/scope/lifetime/static_lifetime.md:8 msgid "\"hello world\"" msgstr "\"你好，世界\"" #: src/scope/lifetime/static_lifetime.md:9 msgid "// 'static as part of a trait bound:\n" msgstr "// 'static 作为 trait 约束的一部分：\n" #: src/scope/lifetime/static_lifetime.md:14 msgid "" "Both are related but subtly different and this is a common source for " "confusion when learning Rust. Here are some examples for each situation:" msgstr "" "这两种情况虽然相关但有微妙的区别，这也是学习 Rust 时常见的困惑来源。以下是每" "种情况的一些例子：" #: src/scope/lifetime/static_lifetime.md:17 msgid "Reference lifetime" msgstr "引用生命周期" #: src/scope/lifetime/static_lifetime.md:19 msgid "" "As a reference lifetime `'static` indicates that the data pointed to by the " "reference lives for the remaining lifetime of the running program. It can " "still be coerced to a shorter lifetime." msgstr "" "作为引用生命周期，`'static` 表示该引用指向的数据在程序的整个剩余运行期间都有" "效。它仍然可以被强制转换为更短的生命周期。" #: src/scope/lifetime/static_lifetime.md:23 msgid "" "There are two common ways to make a variable with `'static` lifetime, and " "both are stored in the read-only memory of the binary:" msgstr "" "有两种常见的方法可以创建具有 `'static` 生命周期的变量，它们都存储在二进制文件" "的只读内存中：" #: src/scope/lifetime/static_lifetime.md:26 msgid "Make a constant with the `static` declaration." msgstr "使用 `static` 声明创建一个常量。" #: src/scope/lifetime/static_lifetime.md:27 msgid "Make a `string` literal which has type: `&'static str`." msgstr "创建一个字符串字面量，其类型为：`&'static str`。" #: src/scope/lifetime/static_lifetime.md:29 msgid "See the following example for a display of each method:" msgstr "请看下面的例子，展示了这些方法：" #: src/scope/lifetime/static_lifetime.md:32 msgid "// Make a constant with `'static` lifetime.\n" msgstr "// 创建一个具有 `'static` 生命周期的常量。\n" #: src/scope/lifetime/static_lifetime.md:34 msgid "" "// Returns a reference to `NUM` where its `'static`\n" "// lifetime is coerced to that of the input argument.\n" msgstr "" "// 返回一个指向 `NUM` 的引用，其中 `'static` 生命周期\n" "// 被强制转换为输入参数的生命周期。\n" #: src/scope/lifetime/static_lifetime.md:43 msgid "// Make a `string` literal and print it:\n" msgstr "// 创建一个字符串字面量并打印它：\n" #: src/scope/lifetime/static_lifetime.md:44 msgid "\"I'm in read-only memory\"" msgstr "\"我存储在只读内存中\"" #: src/scope/lifetime/static_lifetime.md:45 msgid "\"static_string: {}\"" msgstr "\"static_string 的值：{}\"" #: src/scope/lifetime/static_lifetime.md:47 msgid "" "// When `static_string` goes out of scope, the reference\n" " // can no longer be used, but the data remains in the binary.\n" msgstr "" "// 当 `static_string` 离开作用域时，该引用\n" " // 不能再被使用，但数据仍然保留在二进制文件中。\n" #: src/scope/lifetime/static_lifetime.md:52 msgid "// Make an integer to use for `coerce_static`:\n" msgstr "// 创建一个整数用于 `coerce_static` 函数：\n" #: src/scope/lifetime/static_lifetime.md:55 msgid "// Coerce `NUM` to lifetime of `lifetime_num`:\n" msgstr "// 将 `NUM` 的生命周期强制转换为与 `lifetime_num` 一致：\n" #: src/scope/lifetime/static_lifetime.md:58 msgid "\"coerced_static: {}\"" msgstr "\"coerced_static: {}\"" #: src/scope/lifetime/static_lifetime.md:61 msgid "\"NUM: {} stays accessible!\"" msgstr "\"NUM：{} 仍然可以访问！\"" #: src/scope/lifetime/static_lifetime.md:65 msgid "" "Since `'static` references only need to be valid for the _remainder_ of a " "program's life, they can be created while the program is executed. Just to " "demonstrate, the below example uses [`Box::leak`](https://doc.rust-lang.org/" "std/boxed/struct.Box.html#method.leak) to dynamically create `'static` " "references. In that case it definitely doesn't live for the entire duration, " "but only from the leaking point onward." msgstr "" "`'static` 引用只需在程序生命周期的**剩余部分**有效，因此可以在程序执行过程中" "创建。为了演示这一点，下面的例子使用 [`Box::leak`](https://doc.rust-lang.org/" "std/boxed/struct.Box.html#method.leak) 动态创建 `'static` 引用。在这种情况" "下，它显然不会存在于整个程序生命周期，而只是从泄漏点开始存在。" #: src/scope/lifetime/static_lifetime.md:90 msgid "Trait bound" msgstr "Trait 约束" #: src/scope/lifetime/static_lifetime.md:92 msgid "" "As a trait bound, it means the type does not contain any non-static " "references. Eg. the receiver can hold on to the type for as long as they " "want and it will never become invalid until they drop it." msgstr "" "作为 trait 约束时，它表示该类型不包含任何非静态引用。例如，接收者可以随意持有" "该类型，直到主动丢弃之前，它都不会变为无效。" #: src/scope/lifetime/static_lifetime.md:96 msgid "" "It's important to understand this means that any owned data always passes a " "`'static` lifetime bound, but a reference to that owned data generally does " "not:" msgstr "" "理解这一点很重要：任何拥有所有权的数据总是满足 `'static` 生命周期约束，但对该" "数据的引用通常不满足：" #: src/scope/lifetime/static_lifetime.md:104 msgid "\"'static value passed in is: {:?}\"" msgstr "\"传入的 'static 值是：{:?}\"" #: src/scope/lifetime/static_lifetime.md:108 msgid "// i is owned and contains no references, thus it's 'static:\n" msgstr "// i 拥有所有权且不包含任何引用，因此它是 'static 的：\n" #: src/scope/lifetime/static_lifetime.md:112 msgid "" "// oops, &i only has the lifetime defined by the scope of\n" " // main(), so it's not 'static:\n" msgstr "" "// 糟糕，&i 的生命周期仅由 main() 的作用域定义，\n" " // 所以它不是 'static 的：\n" #: src/scope/lifetime/static_lifetime.md:118 msgid "The compiler will tell you:" msgstr "编译器会提示你：" #: src/scope/lifetime/static_lifetime.md:135 msgid "[`'static` constants](../../custom_types/constants.md)" msgstr "[`'static` 常量](../../custom_types/constants.md)" #: src/scope/lifetime/elision.md:3 msgid "" "Some lifetime patterns are overwhelmingly common and so the borrow checker " "will allow you to omit them to save typing and to improve readability. This " "is known as elision. Elision exists in Rust solely because these patterns " "are common." msgstr "" "有些生命周期模式非常常见，因此借用检查器允许省略它们以减少代码量并提高可读" "性。这被称为省略。Rust 中的省略存在的唯一原因是这些模式很常见。" #: src/scope/lifetime/elision.md:8 msgid "" "The following code shows a few examples of elision. For a more comprehensive " "description of elision, see [lifetime elision](https://doc.rust-lang.org/" "book/ch10-03-lifetime-syntax.html#lifetime-elision) in the book." msgstr "" "以下代码展示了一些省略的例子。要更全面地了解省略，请参阅 Rust 程序设计语言中" "的[生命周期省略](https://doc.rust-lang.org/book/ch10-03-lifetime-" "syntax.html#lifetime-elision)章节。" #: src/scope/lifetime/elision.md:12 msgid "" "// `elided_input` and `annotated_input` essentially have identical " "signatures\n" "// because the lifetime of `elided_input` is inferred by the compiler:\n" msgstr "" "// `elided_input` 和 `annotated_input` 本质上具有相同的签名\n" "// 因为 `elided_input` 的生命周期是由编译器推断的：\n" #: src/scope/lifetime/elision.md:15 msgid "\"`elided_input`: {}\"" msgstr "\"`elided_input`: {}\"" #: src/scope/lifetime/elision.md:19 msgid "\"`annotated_input`: {}\"" msgstr "\"`annotated_input`: {}\"" #: src/scope/lifetime/elision.md:21 msgid "" "// Similarly, `elided_pass` and `annotated_pass` have identical signatures\n" "// because the lifetime is added implicitly to `elided_pass`:\n" msgstr "" "// 同样，`elided_pass` 和 `annotated_pass` 具有相同的签名\n" "// 因为生命周期被隐式地添加到 `elided_pass`：\n" #: src/scope/lifetime/elision.md:34 msgid "\"`elided_pass`: {}\"" msgstr "\"`elided_pass`: {}\"" #: src/scope/lifetime/elision.md:35 msgid "\"`annotated_pass`: {}\"" msgstr "\"`annotated_pass`: {}\"" #: src/scope/lifetime/elision.md:41 msgid "" "[elision](https://doc.rust-lang.org/book/ch10-03-lifetime-" "syntax.html#lifetime-elision)" msgstr "" "[省略](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-" "elision)" #: src/trait.md:3 msgid "" "A `trait` is a collection of methods defined for an unknown type: `Self`. " "They can access other methods declared in the same trait." msgstr "" "`trait` 是为未知类型 `Self` 定义的一组方法集合。这些方法可以访问同一 trait 中" "声明的其他方法。" #: src/trait.md:6 msgid "" "Traits can be implemented for any data type. In the example below, we define " "`Animal`, a group of methods. The `Animal` `trait` is then implemented for " "the `Sheep` data type, allowing the use of methods from `Animal` with a " "`Sheep`." msgstr "" "trait 可以为任何数据类型实现。在下面的例子中，我们定义了 `Animal`，一组方法的" "集合。然后为 `Sheep` 数据类型实现 `Animal` trait，这样就可以对 `Sheep` 使用 " "`Animal` 中的方法。" #: src/trait.md:15 msgid "" "// Associated function signature; `Self` refers to the implementor type.\n" msgstr "// 关联函数签名；`Self` 指代实现者类型。\n" #: src/trait.md:18 msgid "// Method signatures; these will return a string.\n" msgstr "// 方法签名；这些方法将返回一个字符串。\n" #: src/trait.md:22 msgid "// Traits can provide default method definitions.\n" msgstr "// trait 可以提供默认的方法实现。\n" #: src/trait.md:24 msgid "\"{} says {}\"" msgstr "\"{} 说 {}\"" #: src/trait.md:35 msgid "// Implementor methods can use the implementor's trait methods.\n" msgstr "// 实现者的方法可以使用实现者的 trait 方法。\n" #: src/trait.md:36 msgid "\"{} is already naked...\"" msgstr "\"{} 已经剃过毛了...\"" #: src/trait.md:38 msgid "\"{} gets a haircut!\"" msgstr "\"{} 剃了个毛！\"" #: src/trait.md:44 src/trait/dyn.md:25 msgid "// Implement the `Animal` trait for `Sheep`.\n" msgstr "// 为 `Sheep` 实现 `Animal` trait\n" #: src/trait.md:47 msgid "// `Self` is the implementor type: `Sheep`.\n" msgstr "// `Self` 是实现者类型，即 `Sheep`\n" #: src/trait.md:58 msgid "\"baaaaah?\"" msgstr "\"咩～？\"" #: src/trait.md:60 src/trait/dyn.md:29 msgid "\"baaaaah!\"" msgstr "\"咩～！\"" #: src/trait.md:64 msgid "// Default trait methods can be overridden.\n" msgstr "// 可以重写默认的 trait 方法\n" #: src/trait.md:66 msgid "// For example, we can add some quiet contemplation.\n" msgstr "// 例如，我们可以添加一些安静的思考\n" #: src/trait.md:67 msgid "\"{} pauses briefly... {}\"" msgstr "\"{} 短暂停顿…… {}\"" #: src/trait.md:72 msgid "// Type annotation is necessary in this case.\n" msgstr "// 在这种情况下需要类型标注\n" #: src/trait.md:73 msgid "\"Dolly\"" msgstr "\"多莉\"" #: src/trait.md:74 msgid "// TODO ^ Try removing the type annotations.\n" msgstr "// TODO ^ 尝试移除类型标注\n" #: src/trait/derive.md:3 msgid "" "The compiler is capable of providing basic implementations for some traits " "via the `#[derive]` [attribute](../attribute.md). These traits can still be " "manually implemented if a more complex behavior is required." msgstr "" "编译器可以通过 `#[derive]` [属性](../attribute.md)为某些 trait 提供基本实现。" "如果需要更复杂的行为，这些 trait 仍然可以手动实现。" #: src/trait/derive.md:7 msgid "The following is a list of derivable traits:" msgstr "以下是可派生的 trait 列表：" #: src/trait/derive.md:9 msgid "" "Comparison traits: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), " "[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), " "[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]" "(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)." msgstr "" "比较 trait：[`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html)、" "[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html)、" "[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html)、[`PartialOrd`]" "(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)。" #: src/trait/derive.md:11 msgid "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), to create " "`T` from `&T` via a copy." msgstr "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html)，通过复制 " "`&T` 创建 `T`。" #: src/trait/derive.md:12 msgid "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), to give a " "type 'copy semantics' instead of 'move semantics'." msgstr "" "[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html)，使类型具备" "\"复制语义\"而不是\"移动语义\"。" #: src/trait/derive.md:13 msgid "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), to compute a " "hash from `&T`." msgstr "" "[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html)，从 `&T` 计算哈" "希值。" #: src/trait/derive.md:14 msgid "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), to " "create an empty instance of a data type." msgstr "" "[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html)，创建一" "个数据类型的空实例。" #: src/trait/derive.md:15 msgid "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), to format a " "value using the `{:?}` formatter." msgstr "" "[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html)，使用 `{:?}` 格" "式化器来格式化一个值。" #: src/trait/derive.md:18 msgid "// `Centimeters`, a tuple struct that can be compared\n" msgstr "// `Centimeters`，一个可比较的元组结构体\n" #: src/trait/derive.md:21 msgid "// `Inches`, a tuple struct that can be printed\n" msgstr "// `Inches`，一个可打印的元组结构体\n" #: src/trait/derive.md:33 msgid "// `Seconds`, a tuple struct with no additional attributes\n" msgstr "// `Seconds`，一个没有额外属性的元组结构体\n" #: src/trait/derive.md:40 msgid "" "// Error: `Seconds` can't be printed; it doesn't implement the `Debug` " "trait\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误：`Seconds` 无法打印，因为它没有实现 `Debug` trait\n" " //println!(\"One second looks like: {:?}\", _one_second);\n" " // TODO ^ 尝试取消这行的注释\n" #: src/trait/derive.md:44 msgid "" "// Error: `Seconds` can't be compared; it doesn't implement the `PartialEq` " "trait\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误：`Seconds` 无法比较，因为它没有实现 `PartialEq` trait\n" " //let _this_is_true = (_one_second == _one_second);\n" " // TODO ^ 尝试取消这行的注释\n" #: src/trait/derive.md:50 msgid "\"One foot equals {:?}\"" msgstr "\"一英尺等于 {:?}\"" #: src/trait/derive.md:56 msgid "\"smaller\"" msgstr "\"更小\"" #: src/trait/derive.md:58 msgid "\"bigger\"" msgstr "\"更大\"" #: src/trait/derive.md:61 msgid "\"One foot is {} than one meter.\"" msgstr "\"一英尺比一米{}\"" #: src/trait/derive.md:67 msgid "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)" msgstr "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)" #: src/trait/dyn.md:3 msgid "" "The Rust compiler needs to know how much space every function's return type " "requires. This means all your functions have to return a concrete type. " "Unlike other languages, if you have a trait like `Animal`, you can't write a " "function that returns `Animal`, because its different implementations will " "need different amounts of memory." msgstr "" "Rust 编译器需要知道每个函数的返回类型所需的内存空间。这意味着所有函数都必须返" "回一个具体类型。与其他语言不同，如果你有一个像 `Animal` 这样的 trait，你不能" "编写一个直接返回 `Animal` 的函数，因为它的不同实现可能需要不同大小的内存。" #: src/trait/dyn.md:8 msgid "" "However, there's an easy workaround. Instead of returning a trait object " "directly, our functions return a `Box` which _contains_ some `Animal`. A " "`box` is just a reference to some memory in the heap. Because a reference " "has a statically-known size, and the compiler can guarantee it points to a " "heap-allocated `Animal`, we can return a trait from our function!" msgstr "" "然而，有一个简单的解决方法。我们可以让函数返回一个**包含** `Animal` 的 " "`Box`，而不是直接返回 trait 对象。`Box` 本质上是一个指向堆内存的引用。由于引" "用的大小是静态已知的，且编译器可以保证它指向堆上分配的 `Animal`，这样我们就能" "从函数中返回一个 trait 了！" #: src/trait/dyn.md:13 msgid "" "Rust tries to be as explicit as possible whenever it allocates memory on the " "heap. So if your function returns a pointer-to-trait-on-heap in this way, " "you need to write the return type with the `dyn` keyword, e.g. `Box`." msgstr "" "Rust 在堆上分配内存时力求明确。因此，如果你的函数以这种方式返回一个指向堆上 " "trait 的指针，你需要在返回类型中使用 `dyn` 关键字，例如 `Box`。" #: src/trait/dyn.md:22 msgid "// Instance method signature\n" msgstr "// 实例方法签名\n" #: src/trait/dyn.md:32 msgid "// Implement the `Animal` trait for `Cow`.\n" msgstr "// 为 `Cow` 实现 `Animal` trait\n" #: src/trait/dyn.md:36 msgid "\"moooooo!\"" msgstr "\"哞~哞~哞~\"" #: src/trait/dyn.md:39 msgid "" "// Returns some struct that implements Animal, but we don't know which one " "at compile time.\n" msgstr "" "// 返回某个实现了 Animal 的结构体，但在编译时我们并不知道具体是哪一个\n" #: src/trait/dyn.md:52 msgid "\"You've randomly chosen an animal, and it says {}\"" msgstr "\"你随机选择了一个动物，它说：{}\"" #: src/trait/ops.md:3 msgid "" "In Rust, many of the operators can be overloaded via traits. That is, some " "operators can be used to accomplish different tasks based on their input " "arguments. This is possible because operators are syntactic sugar for method " "calls. For example, the `+` operator in `a + b` calls the `add` method (as " "in `a.add(b)`). This `add` method is part of the `Add` trait. Hence, the `+` " "operator can be used by any implementor of the `Add` trait." msgstr "" "在 Rust 中，许多运算符可以通过 trait 进行重载。这意味着某些运算符可以根据输入" "参数执行不同的任务。之所以可能，是因为运算符实际上是方法调用的语法糖。例如，" "`a + b` 中的 `+` 运算符会调用 `add` 方法（相当于 `a.add(b)`）。这个 `add` 方" "法是 `Add` trait 的一部分。因此，任何实现了 `Add` trait 的类型都可以使用 `+` " "运算符。" #: src/trait/ops.md:9 msgid "" "A list of the traits, such as `Add`, that overload operators can be found in " "[`core::ops`](https://doc.rust-lang.org/core/ops/)." msgstr "" "可以在 [`core::ops`](https://doc.rust-lang.org/core/ops/) 模块中找到用于重载" "运算符的 trait 列表，如 `Add` 等。" #: src/trait/ops.md:22 msgid "" "// The `std::ops::Add` trait is used to specify the functionality of `+`.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Bar`.\n" "// The following block implements the operation: Foo + Bar = FooBar\n" msgstr "" "// `std::ops::Add` trait 用于指定 `+` 的功能\n" "// 这里我们实现 `Add` - 这个 trait 用于与 `Bar` 类型的右操作数相加\n" "// 下面的代码块实现了操作：Foo + Bar = FooBar\n" #: src/trait/ops.md:30 msgid "\"> Foo.add(Bar) was called\"" msgstr "\"> 调用了 Foo.add(Bar)\"" #: src/trait/ops.md:35 msgid "" "// By reversing the types, we end up implementing non-commutative addition.\n" "// Here, we make `Add` - the trait for addition with a RHS of type " "`Foo`.\n" "// This block implements the operation: Bar + Foo = BarFoo\n" msgstr "" "// 通过交换类型顺序，我们实现了非交换加法。\n" "// 这里我们实现 `Add` trait —— 用于处理右操作数类型为 `Foo` 的加法。\n" "// 此代码块实现了如下操作：Bar + Foo = BarFoo\n" #: src/trait/ops.md:43 msgid "\"> Bar.add(Foo) was called\"" msgstr "\"> 调用了 Bar.add(Foo)\"" #: src/trait/ops.md:50 msgid "\"Foo + Bar = {:?}\"" msgstr "\"Foo + Bar = {:?}\"" #: src/trait/ops.md:51 msgid "\"Bar + Foo = {:?}\"" msgstr "\"Bar + Foo = {:?}\"" #: src/trait/ops.md:55 src/testing.md:16 src/testing/doc_testing.md:105 #: src/testing/dev_dependencies.md:36 msgid "See Also" msgstr "参见" #: src/trait/ops.md:57 msgid "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [Syntax Index]" "(https://doc.rust-lang.org/book/appendix-02-operators.html)" msgstr "" "[Add](https://doc.rust-lang.org/core/ops/trait.Add.html)，[语法索引](https://" "doc.rust-lang.org/book/appendix-02-operators.html)" #: src/trait/drop.md:3 msgid "" "The [`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) trait only " "has one method: `drop`, which is called automatically when an object goes " "out of scope. The main use of the `Drop` trait is to free the resources that " "the implementor instance owns." msgstr "" "[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) trait 只有一个方" "法：`drop`，它会在对象离开作用域时自动调用。`Drop` trait 的主要用途是释放实现" "该 trait 的实例所拥有的资源。" #: src/trait/drop.md:7 msgid "" "`Box`, `Vec`, `String`, `File`, and `Process` are some examples of types " "that implement the `Drop` trait to free resources. The `Drop` trait can also " "be manually implemented for any custom data type." msgstr "" "`Box`、`Vec`、`String`、`File` 和 `Process` 是一些实现了 `Drop` trait 以释放" "资源的类型示例。你也可以为任何自定义数据类型手动实现 `Drop` trait。" #: src/trait/drop.md:11 msgid "" "The following example adds a print to console to the `drop` function to " "announce when it is called." msgstr "" "下面的例子在 `drop` 函数中添加了一个控制台打印，用于宣告它被调用的时机。" #: src/trait/drop.md:18 msgid "// This trivial implementation of `drop` adds a print to console.\n" msgstr "// 这个简单的 `drop` 实现添加了一个控制台打印\n" #: src/trait/drop.md:22 msgid "\"> Dropping {}\"" msgstr "\"> 正在释放 {}\"" #: src/trait/drop.md:27 src/std_misc/path.md:33 src/std_misc/fs.md:44 #: src/std_misc/fs.md:87 msgid "\"a\"" msgstr "\"a\"" #: src/trait/drop.md:29 msgid "// block A\n" msgstr "// 块 A\n" #: src/trait/drop.md:31 src/std_misc/path.md:33 msgid "\"b\"" msgstr "\"b\"" #: src/trait/drop.md:33 msgid "// block B\n" msgstr "// 块 B\n" #: src/trait/drop.md:35 src/std_misc/path.md:36 msgid "\"c\"" msgstr "\"c\"" #: src/trait/drop.md:36 msgid "\"d\"" msgstr "\"d\"" #: src/trait/drop.md:38 msgid "\"Exiting block B\"" msgstr "\"正在退出块 B\"" #: src/trait/drop.md:40 msgid "\"Just exited block B\"" msgstr "\"刚刚退出了块 B\"" #: src/trait/drop.md:42 msgid "\"Exiting block A\"" msgstr "\"正在退出块 A\"" #: src/trait/drop.md:44 msgid "\"Just exited block A\"" msgstr "\"刚刚退出了块 A\"" #: src/trait/drop.md:46 msgid "// Variable can be manually dropped using the `drop` function\n" msgstr "// 可以使用 `drop` 函数手动释放变量\n" #: src/trait/drop.md:48 msgid "// TODO ^ Try commenting this line\n" msgstr "// TODO ^ 试试注释掉这一行\n" #: src/trait/drop.md:50 msgid "\"end of the main function\"" msgstr "\"main 函数结束\"" #: src/trait/drop.md:52 msgid "" "// `_a` *won't* be `drop`ed again here, because it already has been\n" " // (manually) `drop`ed\n" msgstr "" "// `_a` 在这里**不会**被再次 `drop`，因为它已经\n" " // 被（手动）`drop` 过了\n" #: src/trait/drop.md:57 msgid "" "For a more practical example, here's how the `Drop` trait can be used to " "automatically clean up temporary files when they're no longer needed:" msgstr "" "下面是一个更实用的例子，展示如何使用 `Drop` 特质在不再需要临时文件时自动清理" "它们：" #: src/trait/drop.md:71 msgid "// Note: File::create() will overwrite existing files\n" msgstr "// 注意：File::create() 会覆盖现有文件\n" #: src/trait/drop.md:77 msgid "" "// When TempFile is dropped:\n" "// 1. First, the File will be automatically closed (Drop for File)\n" "// 2. Then our drop implementation will remove the file\n" msgstr "" "// 当 TempFile 被丢弃时：\n" "// 1. 首先，File 会自动关闭（File 的 Drop 实现）\n" "// 2. 然后我们的 drop 实现会删除文件\n" #: src/trait/drop.md:83 msgid "// Note: File is already closed at this point\n" msgstr "// 注意：文件在此时已经关闭\n" #: src/trait/drop.md:85 msgid "\"Failed to remove temporary file: {}\"" msgstr "\"删除临时文件失败：{}\"" #: src/trait/drop.md:87 msgid "\"> Dropped temporary file: {:?}\"" msgstr "\"> 已丢弃临时文件：{:?}\"" #: src/trait/drop.md:92 msgid "// Create a new scope to demonstrate drop behavior\n" msgstr "// 创建新作用域来演示丢弃行为\n" #: src/trait/drop.md:94 msgid "\"test.txt\"" msgstr "\"test.txt\"" #: src/trait/drop.md:95 msgid "\"Temporary file created\"" msgstr "\"已创建临时文件\"" #: src/trait/drop.md:96 msgid "// File will be automatically cleaned up when temp goes out of scope\n" msgstr "// 当 temp 超出作用域时，文件会自动清理\n" #: src/trait/drop.md:98 msgid "\"End of scope - file should be cleaned up\"" msgstr "\"作用域结束 - 文件应该被清理\"" #: src/trait/drop.md:100 msgid "// We can also manually drop if needed\n" msgstr "// 如果需要，我们也可以手动丢弃\n" #: src/trait/drop.md:101 msgid "\"another_test.txt\"" msgstr "\"another_test.txt\"" #: src/trait/drop.md:102 msgid "// Explicitly drop the file\n" msgstr "// 显式丢弃文件\n" #: src/trait/drop.md:103 msgid "\"Manually dropped file\"" msgstr "\"手动丢弃的文件\"" #: src/trait/iter.md:3 msgid "" "The [`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) " "trait is used to implement iterators over collections such as arrays." msgstr "" "[`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) trait " "用于实现对数组等集合的迭代器。" #: src/trait/iter.md:6 msgid "" "The trait requires only a method to be defined for the `next` element, which " "may be manually defined in an `impl` block or automatically defined (as in " "arrays and ranges)." msgstr "" "该 trait 只要求为 `next` 元素定义一个方法，这个方法可以在 `impl` 块中手动定" "义，也可以自动定义（如在数组和区间中）。" #: src/trait/iter.md:10 msgid "" "As a point of convenience for common situations, the `for` construct turns " "some collections into iterators using the [`.into_iter()`](https://doc.rust-" "lang.org/std/iter/trait.IntoIterator.html) method." msgstr "" "为了在常见情况下提供便利，`for` 结构使用 [`.into_iter()`](https://doc.rust-" "lang.org/std/iter/trait.IntoIterator.html) 方法将某些集合转换为迭代器。" #: src/trait/iter.md:18 msgid "" "// Implement `Iterator` for `Fibonacci`.\n" "// The `Iterator` trait only requires a method to be defined for the `next` " "element,\n" "// and an `associated type` to declare the return type of the iterator.\n" msgstr "" "// 为 `Fibonacci` 实现 `Iterator`。\n" "// `Iterator` 特质只要求为 `next` 元素定义一个方法，\n" "// 并需要一个`关联类型`来声明迭代器的返回类型。\n" #: src/trait/iter.md:23 msgid "// We can refer to this type using Self::Item\n" msgstr "// 我们可以使用 Self::Item 引用这个类型\n" #: src/trait/iter.md:26 msgid "" "// Here, we define the sequence using `.curr` and `.next`.\n" " // The return type is `Option`:\n" " // * When the `Iterator` is finished, `None` is returned.\n" " // * Otherwise, the next value is wrapped in `Some` and returned.\n" " // We use Self::Item in the return type, so we can change\n" " // the type without having to update the function signatures.\n" msgstr "" "// 这里，我们使用 `.curr` 和 `.next` 定义序列。\n" " // 返回类型是 `Option`：\n" " // * 当 `Iterator` 结束时，返回 `None`。\n" " // * 否则，将下一个值包装在 `Some` 中并返回。\n" " // 我们在返回类型中使用 Self::Item，这样可以更改\n" " // 类型而无需更新函数签名。\n" #: src/trait/iter.md:38 msgid "" "// Since there's no endpoint to a Fibonacci sequence, the `Iterator`\n" " // will never return `None`, and `Some` is always returned.\n" msgstr "" "// 由于斐波那契序列没有终点，`Iterator` \n" " // 永远不会返回 `None`，始终返回 `Some`。\n" #: src/trait/iter.md:43 msgid "// Returns a Fibonacci sequence generator\n" msgstr "// 返回一个斐波那契序列生成器\n" #: src/trait/iter.md:50 msgid "// `0..3` is an `Iterator` that generates: 0, 1, and 2.\n" msgstr "// `0..3` 是一个生成 0、1 和 2 的 `Iterator`。\n" #: src/trait/iter.md:53 msgid "\"Four consecutive `next` calls on 0..3\"" msgstr "\"对 0..3 连续调用四次 `next`\"" #: src/trait/iter.md:54 src/trait/iter.md:55 src/trait/iter.md:56 #: src/trait/iter.md:57 src/std_misc/fs.md:90 msgid "\"> {:?}\"" msgstr "\"> {:?}\"" #: src/trait/iter.md:59 msgid "" "// `for` works through an `Iterator` until it returns `None`.\n" " // Each `Some` value is unwrapped and bound to a variable (here, `i`).\n" msgstr "" "// `for` 遍历 `Iterator` 直到它返回 `None`。\n" " // 每个 `Some` 值被解包并绑定到一个变量（这里是 `i`）。\n" #: src/trait/iter.md:61 msgid "\"Iterate through 0..3 using `for`\"" msgstr "\"使用 `for` 遍历 0..3\"" #: src/trait/iter.md:63 src/trait/iter.md:69 src/trait/iter.md:75 #: src/trait/iter.md:83 src/std/vec.md:50 src/std/str.md:22 #: src/std_misc/fs.md:82 msgid "\"> {}\"" msgstr "\"> {}\"" #: src/trait/iter.md:66 msgid "// The `take(n)` method reduces an `Iterator` to its first `n` terms.\n" msgstr "// `take(n)` 方法将 `Iterator` 限制为其前 `n` 项。\n" #: src/trait/iter.md:67 msgid "\"The first four terms of the Fibonacci sequence are: \"" msgstr "\"斐波那契序列的前四项是：\"" #: src/trait/iter.md:72 msgid "" "// The `skip(n)` method shortens an `Iterator` by dropping its first `n` " "terms.\n" msgstr "// `skip(n)` 方法通过跳过前 `n` 项来缩短 `Iterator`。\n" #: src/trait/iter.md:73 msgid "\"The next four terms of the Fibonacci sequence are: \"" msgstr "\"斐波那契序列的接下来四项是：\"" #: src/trait/iter.md:80 msgid "// The `iter` method produces an `Iterator` over an array/slice.\n" msgstr "// `iter` 方法为数组/切片创建一个 `Iterator`。\n" #: src/trait/iter.md:81 msgid "\"Iterate the following array {:?}\"" msgstr "\"遍历以下数组 {:?}\"" #: src/trait/impl_trait.md:3 msgid "`impl Trait` can be used in two locations:" msgstr "`impl Trait` 可以在两个位置使用：" #: src/trait/impl_trait.md:5 msgid "as an argument type" msgstr "作为参数类型" #: src/trait/impl_trait.md:6 msgid "as a return type" msgstr "作为返回类型" #: src/trait/impl_trait.md:8 msgid "As an argument type" msgstr "作为参数类型" #: src/trait/impl_trait.md:10 msgid "" "If your function is generic over a trait but you don't mind the specific " "type, you can simplify the function declaration using `impl Trait` as the " "type of the argument." msgstr "" "如果你的函数对某个 trait 是泛型的，但不关心具体类型，你可以使用 `impl Trait` " "作为参数类型来简化函数声明。" #: src/trait/impl_trait.md:12 msgid "For example, consider the following code:" msgstr "例如，考虑以下代码：" #: src/trait/impl_trait.md:18 src/trait/impl_trait.md:37 msgid "// For each line in the source\n" msgstr "// 遍历数据源中的每一行\n" #: src/trait/impl_trait.md:20 src/trait/impl_trait.md:39 msgid "" "// If the line was read successfully, process it, if not, return the error\n" msgstr "// 如果成功读取行，则处理它；否则，返回错误\n" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 src/std/str.md:41 msgid "','" msgstr "','" #: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 msgid "// Split the line separated by commas\n" msgstr "// 按逗号分割行\n" #: src/trait/impl_trait.md:22 src/trait/impl_trait.md:41 msgid "// Remove leading and trailing whitespace\n" msgstr "// 去除首尾空白\n" #: src/trait/impl_trait.md:23 src/trait/impl_trait.md:42 msgid "// Collect all strings in a row into a Vec\n" msgstr "// 将该行的所有字符串收集到 Vec 中\n" #: src/trait/impl_trait.md:26 src/trait/impl_trait.md:45 msgid "// Collect all lines into a Vec>\n" msgstr "// 将所有行收集到 Vec> 中\n" #: src/trait/impl_trait.md:30 msgid "" "`parse_csv_document` is generic, allowing it to take any type which " "implements BufRead, such as `BufReader` or `[u8]`, but it's not " "important what type `R` is, and `R` is only used to declare the type of " "`src`, so the function can also be written as:" msgstr "" "`parse_csv_document` 是泛型函数，可以接受任何实现了 `BufRead` 的类型，如 " "`BufReader` 或 `[u8]`。但具体的 `R` 类型并不重要，`R` 仅用于声明 `src` " "的类型。因此，这个函数也可以写成：" #: src/trait/impl_trait.md:49 msgid "" "Note that using `impl Trait` as an argument type means that you cannot " "explicitly state what form of the function you use, i.e. " "`parse_csv_document::(std::io::empty())` will not work with " "the second example." msgstr "" "注意，使用 `impl Trait` 作为参数类型意味着你无法显式指定使用的函数形式。例" "如，`parse_csv_document::(std::io::empty())` 在第二个例子中将" "无法工作。" #: src/trait/impl_trait.md:51 msgid "As a return type" msgstr "作为返回类型" #: src/trait/impl_trait.md:53 msgid "" "If your function returns a type that implements `MyTrait`, you can write its " "return type as `-> impl MyTrait`. This can help simplify your type " "signatures quite a lot!" msgstr "" "如果函数返回一个实现了 `MyTrait` 的类型，你可以将其返回类型写为 `-> impl " "MyTrait`。这可以大大简化类型签名！" #: src/trait/impl_trait.md:59 msgid "" "// This function combines two `Vec` and returns an iterator over it.\n" "// Look how complicated its return type is!\n" msgstr "" "// 这个函数合并两个 `Vec` 并返回一个迭代器。\n" "// 看看它的返回类型有多复杂！\n" #: src/trait/impl_trait.md:68 msgid "" "// This is the exact same function, but its return type uses `impl Trait`.\n" "// Look how much simpler it is!\n" msgstr "" "// 这是完全相同的函数，但它的返回类型使用了 `impl Trait`。\n" "// 看看它变得多么简单！\n" #: src/trait/impl_trait.md:87 msgid "\"all done\"" msgstr "\"全部完成\"" #: src/trait/impl_trait.md:91 msgid "" "More importantly, some Rust types can't be written out. For example, every " "closure has its own unnamed concrete type. Before `impl Trait` syntax, you " "had to allocate on the heap in order to return a closure. But now you can do " "it all statically, like this:" msgstr "" "更重要的是，某些 Rust 类型无法直接写出。例如，每个闭包都有自己的未命名具体类" "型。在 `impl Trait` 语法出现之前，你必须在堆上分配内存才能返回闭包。但现在你" "可以完全静态地做到这一点，像这样：" #: src/trait/impl_trait.md:97 msgid "// Returns a function that adds `y` to its input\n" msgstr "// 返回一个将 `y` 加到输入值上的函数\n" #: src/trait/impl_trait.md:109 msgid "" "You can also use `impl Trait` to return an iterator that uses `map` or " "`filter` closures! This makes using `map` and `filter` easier. Because " "closure types don't have names, you can't write out an explicit return type " "if your function returns iterators with closures. But with `impl Trait` you " "can do this easily:" msgstr "" "你还可以使用 `impl Trait` 返回一个使用 `map` 或 `filter` 闭包的迭代器！这使得" "使用 `map` 和 `filter` 更加容易。由于闭包类型没有名称，如果你的函数返回带有闭" "包的迭代器，你无法写出显式的返回类型。但使用 `impl Trait`，你可以轻松实现：" #: src/trait/clone.md:3 msgid "" "When dealing with resources, the default behavior is to transfer them during " "assignments or function calls. However, sometimes we need to make a copy of " "the resource as well." msgstr "" "在处理资源时，默认行为是在赋值或函数调用期间转移它们。然而，有时我们也需要复" "制资源。" #: src/trait/clone.md:7 msgid "" "The [`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) trait " "helps us do exactly this. Most commonly, we can use the `.clone()` method " "defined by the `Clone` trait." msgstr "" "[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) trait 帮助我" "们实现这一点。最常见的是，我们可以使用 `Clone` trait 定义的 `.clone()` 方法。" #: src/trait/clone.md:11 msgid "// A unit struct without resources\n" msgstr "// 一个不包含资源的单元结构体\n" #: src/trait/clone.md:14 msgid "// A tuple struct with resources that implements the `Clone` trait\n" msgstr "// 一个包含资源并实现了 `Clone` trait 的元组结构体\n" #: src/trait/clone.md:20 msgid "// Instantiate `Unit`\n" msgstr "// 实例化 `Unit`\n" #: src/trait/clone.md:22 msgid "// Copy `Unit`, there are no resources to move\n" msgstr "// 复制 `Unit`，没有资源需要移动\n" #: src/trait/clone.md:25 msgid "// Both `Unit`s can be used independently\n" msgstr "// 两个 `Unit` 可以独立使用\n" #: src/trait/clone.md:26 src/trait/clone.md:31 msgid "\"original: {:?}\"" msgstr "\"原始: {:?}\"" #: src/trait/clone.md:27 msgid "\"copy: {:?}\"" msgstr "\"复制: {:?}\"" #: src/trait/clone.md:29 msgid "// Instantiate `Pair`\n" msgstr "// 实例化 `Pair`\n" #: src/trait/clone.md:33 msgid "// Move `pair` into `moved_pair`, moves resources\n" msgstr "// 将 `pair` 移动到 `moved_pair`，资源也随之移动\n" #: src/trait/clone.md:35 msgid "\"moved: {:?}\"" msgstr "\"已移动: {:?}\"" #: src/trait/clone.md:37 msgid "" "// Error! `pair` has lost its resources\n" " //println!(\"original: {:?}\", pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`pair` 已失去其资源\n" " //println!(\"原始: {:?}\", pair);\n" " // TODO ^ 尝试取消注释此行\n" #: src/trait/clone.md:41 msgid "// Clone `moved_pair` into `cloned_pair` (resources are included)\n" msgstr "// 将 `moved_pair` 克隆到 `cloned_pair`（包括资源）\n" #: src/trait/clone.md:43 msgid "// Drop the moved original pair using std::mem::drop\n" msgstr "// 使用 std::mem::drop 丢弃已移动的原始对\n" #: src/trait/clone.md:46 msgid "" "// Error! `moved_pair` has been dropped\n" " //println!(\"moved and dropped: {:?}\", moved_pair);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`moved_pair` 已被丢弃\n" " //println!(\"已移动并丢弃: {:?}\", moved_pair);\n" " // TODO ^ 尝试取消注释此行\n" #: src/trait/clone.md:50 msgid "// The result from .clone() can still be used!\n" msgstr "// .clone() 的结果仍然可以使用！\n" #: src/trait/clone.md:51 msgid "\"clone: {:?}\"" msgstr "\"克隆: {:?}\"" #: src/trait/supertraits.md:3 msgid "" "Rust doesn't have \"inheritance\", but you can define a trait as being a " "superset of another trait. For example:" msgstr "" "Rust 没有“继承”，但你可以将一个 trait 定义为另一个 trait 的超集。例如：" #: src/trait/supertraits.md:10 msgid "" "// Person is a supertrait of Student.\n" "// Implementing Student requires you to also impl Person.\n" msgstr "" "// Person 是 Student 的超 trait。\n" "// 实现 Student 需要你同时实现 Person。\n" #: src/trait/supertraits.md:20 msgid "" "// CompSciStudent (computer science student) is a subtrait of both " "Programmer\n" "// and Student. Implementing CompSciStudent requires you to impl both " "supertraits.\n" msgstr "" "// CompSciStudent（计算机科学学生）是 Programmer 和 Student 的子 trait。\n" "// 实现 CompSciStudent 需要你实现两个超 trait。\n" #: src/trait/supertraits.md:29 msgid "" "\"My name is {} and I attend {}. My favorite language is {}. My Git username " "is {}\"" msgstr "" "\"我的名字是 {}，我就读于 {}。我最喜欢的语言是 {}。我的 Git 用户名是 {}\"" #: src/trait/supertraits.md:42 msgid "" "[The Rust Programming Language chapter on supertraits](https://doc.rust-" "lang.org/book/ch19-03-advanced-traits.html#using-supertraits-to-require-one-" "traits-functionality-within-another-trait)" msgstr "" "[《Rust 程序设计语言》中关于超 trait 的章节](https://doc.rust-lang.org/book/" "ch19-03-advanced-traits.html#using-supertraits-to-require-one-traits-" "functionality-within-another-trait)" #: src/trait/disambiguating.md:3 msgid "" "A type can implement many different traits. What if two traits both require " "the same name for a function? For example, many traits might have a method " "named `get()`. They might even have different return types!" msgstr "" "一个类型可以实现多个不同的 trait。如果两个 trait 都要求函数使用相同的名称，该" "怎么办？例如，许多 trait 可能都有一个名为 `get()` 的方法，它们甚至可能有不同" "的返回类型！" #: src/trait/disambiguating.md:7 msgid "" "Good news: because each trait implementation gets its own `impl` block, it's " "clear which trait's `get` method you're implementing." msgstr "" "好消息是：由于每个 trait 实现都有自己的 `impl` 块，因此很容易分清楚你正在实现" "哪个 trait 的 `get` 方法。" #: src/trait/disambiguating.md:10 msgid "" "What about when it comes time to _call_ those methods? To disambiguate " "between them, we have to use Fully Qualified Syntax." msgstr "" "那么在调用这些方法时又该如何处理呢？为了消除它们之间的歧义，我们必须使用完全" "限定语法。" #: src/trait/disambiguating.md:15 msgid "// Get the selected username out of this widget\n" msgstr "// 从这个小部件中获取选定的用户名\n" #: src/trait/disambiguating.md:20 msgid "// Get the selected age out of this widget\n" msgstr "// 从这个小部件中获取选定的年龄\n" #: src/trait/disambiguating.md:23 msgid "// A form with both a UsernameWidget and an AgeWidget\n" msgstr "// 一个同时包含 UsernameWidget 和 AgeWidget 的表单\n" #: src/trait/disambiguating.md:44 src/trait/disambiguating.md:54 msgid "\"rustacean\"" msgstr "\"rustacean\"" #: src/trait/disambiguating.md:48 msgid "" "// If you uncomment this line, you'll get an error saying\n" " // \"multiple `get` found\". Because, after all, there are multiple " "methods\n" " // named `get`.\n" " // println!(\"{}\", form.get());\n" msgstr "" "// 如果你取消注释这一行，你会得到一个错误，提示\n" " // \"找到多个 `get`\"。这是因为确实存在多个\n" " // 名为 `get` 的方法。\n" " // println!(\"{}\", form.get());\n" #: src/trait/disambiguating.md:62 msgid "" "[The Rust Programming Language chapter on Fully Qualified syntax](https://" "doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-" "for-disambiguation-calling-methods-with-the-same-name)" msgstr "" "[《Rust 程序设计语言》中关于完全限定语法的章节](https://doc.rust-lang.org/" "book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-" "calling-methods-with-the-same-name)" #: src/macros.md:1 msgid "`macro_rules!`" msgstr "`macro_rules!`" #: src/macros.md:3 msgid "" "Rust provides a powerful macro system that allows metaprogramming. As you've " "seen in previous chapters, macros look like functions, except that their " "name ends with a bang `!`, but instead of generating a function call, macros " "are expanded into source code that gets compiled with the rest of the " "program. However, unlike macros in C and other languages, Rust macros are " "expanded into abstract syntax trees, rather than string preprocessing, so " "you don't get unexpected precedence bugs." msgstr "" "Rust 提供了一个强大的宏系统，支持元编程。正如你在前面章节中所看到的，宏看起来" "像函数，只是它们的名字以感叹号 `!` 结尾。但与生成函数调用不同，宏会展开成源代" "码，然后与程序的其余部分一起编译。与 C 和其他语言中的宏不同，Rust 宏展开成抽" "象语法树，而不是进行字符串预处理，因此你不会遇到意外的优先级错误。" #: src/macros.md:11 msgid "Macros are created using the `macro_rules!` macro." msgstr "宏是使用 `macro_rules!` 宏来创建的。" #: src/macros.md:14 msgid "// This is a simple macro named `say_hello`.\n" msgstr "// 这是一个名为 `say_hello` 的简单宏。\n" #: src/macros.md:16 msgid "// `()` indicates that the macro takes no argument.\n" msgstr "// `()` 表示该宏不接受任何参数。\n" #: src/macros.md:18 msgid "// The macro will expand into the contents of this block.\n" msgstr "// 宏将展开成这个代码块的内容。\n" #: src/macros.md:19 msgid "\"Hello!\"" msgstr "\"Hello!\"" #: src/macros.md:24 msgid "// This call will expand into `println!(\"Hello!\")`\n" msgstr "// 这个调用将展开成 `println!(\"Hello!\")`\n" #: src/macros.md:29 msgid "So why are macros useful?" msgstr "那么，为什么宏是有用的呢？" #: src/macros.md:31 msgid "" "Don't repeat yourself. There are many cases where you may need similar " "functionality in multiple places but with different types. Often, writing a " "macro is a useful way to avoid repeating code. (More on this later)" msgstr "" "不要重复自己。在许多情况下，你可能需要在多个地方使用相似的功能，但类型不同。" "通常，编写宏是避免代码重复的有效方法。（稍后会详细介绍）" #: src/macros.md:35 msgid "" "Domain-specific languages. Macros allow you to define special syntax for a " "specific purpose. (More on this later)" msgstr "领域特定语言。宏允许你为特定目的定义专门的语法。（稍后会详细介绍）" #: src/macros.md:38 msgid "" "Variadic interfaces. Sometimes you want to define an interface that takes a " "variable number of arguments. An example is `println!` which could take any " "number of arguments, depending on the format string. (More on this later)" msgstr "" "可变参数接口。有时你可能想定义一个接受可变数量参数的接口。例如 `println!`，它" "可以根据格式字符串接受任意数量的参数。（稍后会详细介绍）" #: src/macros/syntax.md:3 msgid "" "In following subsections, we will show how to define macros in Rust. There " "are three basic ideas:" msgstr "在接下来的小节中，我们将展示如何在 Rust 中定义宏。有三个基本概念：" #: src/macros/syntax.md:6 msgid "[Patterns and Designators](designators.md)" msgstr "[模式和指示符](designators.md)" #: src/macros/syntax.md:7 msgid "[Overloading](overload.md)" msgstr "[重载](overload.md)" #: src/macros/syntax.md:8 msgid "[Repetition](repeat.md)" msgstr "[重复](repeat.md)" #: src/macros/designators.md:3 msgid "" "The arguments of a macro are prefixed by a dollar sign `$` and type " "annotated with a _designator_:" msgstr "宏的参数以美元符号 `$` 为前缀，并用**指示符**来标注类型：" #: src/macros/designators.md:8 msgid "" "// This macro takes an argument of designator `ident` and\n" " // creates a function named `$func_name`.\n" " // The `ident` designator is used for variable/function names.\n" msgstr "" "// 这个宏接受一个 `ident` 指示符的参数，\n" " // 并创建一个名为 `$func_name` 的函数。\n" " // `ident` 指示符用于变量/函数名。\n" #: src/macros/designators.md:13 msgid "// The `stringify!` macro converts an `ident` into a string.\n" msgstr "// `stringify!` 宏将 `ident` 转换为字符串。\n" #: src/macros/designators.md:14 msgid "\"You called {:?}()\"" msgstr "\"你调用了 {:?}()\"" #: src/macros/designators.md:19 msgid "// Create functions named `foo` and `bar` with the above macro.\n" msgstr "// 使用上面的宏创建名为 `foo` 和 `bar` 的函数。\n" #: src/macros/designators.md:25 msgid "" "// This macro takes an expression of type `expr` and prints\n" " // it as a string along with its result.\n" " // The `expr` designator is used for expressions.\n" msgstr "" "// 这个宏接受一个 `expr` 类型的表达式，\n" " // 并将其作为字符串打印出来，同时打印其结果。\n" " // `expr` 指示符用于表达式。\n" #: src/macros/designators.md:29 msgid "// `stringify!` will convert the expression *as it is* into a string.\n" msgstr "// `stringify!` 将表达式**原样**转换为字符串。\n" #: src/macros/designators.md:30 msgid "\"{:?} = {:?}\"" msgstr "\"{:?} = {:?}\"" #: src/macros/designators.md:42 msgid "// Recall that blocks are expressions too!\n" msgstr "// 记住，代码块也是表达式！\n" #: src/macros/designators.md:51 msgid "These are some of the available designators:" msgstr "以下是一些可用的指示符：" #: src/macros/designators.md:53 msgid "`block`" msgstr "`block`" #: src/macros/designators.md:54 msgid "`expr` is used for expressions" msgstr "`expr` 用于表达式" #: src/macros/designators.md:55 msgid "`ident` is used for variable/function names" msgstr "`ident` 用于变量/函数名" #: src/macros/designators.md:56 msgid "`item`" msgstr "`item`" #: src/macros/designators.md:57 msgid "`literal` is used for literal constants" msgstr "`literal` 用于字面常量" #: src/macros/designators.md:58 msgid "`pat` (_pattern_)" msgstr "`pat`（**模式** _pattern_）" #: src/macros/designators.md:59 msgid "`path`" msgstr "`path`" #: src/macros/designators.md:60 msgid "`stmt` (_statement_)" msgstr "`stmt`（**语句** _statement_）" #: src/macros/designators.md:61 msgid "`tt` (_token tree_)" msgstr "`tt`（**标记树** _token tree_）" #: src/macros/designators.md:62 msgid "`ty` (_type_)" msgstr "`ty`（**类型** _type_）" #: src/macros/designators.md:63 msgid "`vis` (_visibility qualifier_)" msgstr "`vis`（**可见性限定符** _visibility qualifier_）" #: src/macros/designators.md:65 msgid "" "For a complete list, see the [Rust Reference](https://doc.rust-lang.org/" "reference/macros-by-example.html)." msgstr "" "完整列表请参阅 [Rust 参考手册](https://doc.rust-lang.org/reference/macros-by-" "example.html)。" #: src/macros/overload.md:3 msgid "" "Macros can be overloaded to accept different combinations of arguments. In " "that regard, `macro_rules!` can work similarly to a match block:" msgstr "" "宏可以被重载以接受不同的参数组合。在这方面，`macro_rules!` 的工作方式类似于 " "match 块：" #: src/macros/overload.md:7 msgid "" "// `test!` will compare `$left` and `$right`\n" "// in different ways depending on how you invoke it:\n" msgstr "" "// `test!` 将以不同的方式比较 `$left` 和 `$right`\n" "// 具体取决于你如何调用它：\n" #: src/macros/overload.md:10 msgid "" "// Arguments don't need to be separated by a comma.\n" " // Any template can be used!\n" msgstr "" "// 参数不需要用逗号分隔。\n" " // 可以使用任何模板！\n" #: src/macros/overload.md:13 msgid "\"{:?} and {:?} is {:?}\"" msgstr "\"{:?} 和 {:?} 是 {:?}\"" #: src/macros/overload.md:18 msgid "// ^ each arm must end with a semicolon.\n" msgstr "// ^ 每个分支必须以分号结束。\n" #: src/macros/overload.md:20 msgid "\"{:?} or {:?} is {:?}\"" msgstr "\"{:?} 或 {:?} 是 {:?}\"" #: src/macros/repeat.md:3 msgid "" "Macros can use `+` in the argument list to indicate that an argument may " "repeat at least once, or `*`, to indicate that the argument may repeat zero " "or more times." msgstr "" "宏可以在参数列表中使用 `+` 来表示一个参数可能重复至少一次，或使用 `*` 来表示" "一个参数可能重复零次或多次。" #: src/macros/repeat.md:7 msgid "" "In the following example, surrounding the matcher with `$(...),+` will match " "one or more expression, separated by commas. Also note that the semicolon is " "optional on the last case." msgstr "" "在下面的例子中，用 `$(...),+` 包围匹配器将匹配一个或多个由逗号分隔的表达式。" "另外请注意，最后一个情况的分号是可选的。" #: src/macros/repeat.md:12 msgid "// `find_min!` will calculate the minimum of any number of arguments.\n" msgstr "// `find_min!` 将计算任意数量参数中的最小值。\n" #: src/macros/repeat.md:14 msgid "// Base case:\n" msgstr "// 基本情况：\n" #: src/macros/repeat.md:16 msgid "// `$x` followed by at least one `$y,`\n" msgstr "// `$x` 后面至少跟着一个 `$y,`\n" #: src/macros/repeat.md:18 msgid "// Call `find_min!` on the tail `$y`\n" msgstr "// 对剩余的 `$y` 递归调用 `find_min!`\n" #: src/macros/dry.md:3 msgid "" "Macros allow writing DRY code by factoring out the common parts of functions " "and/or test suites. Here is an example that implements and tests the `+=`, " "`*=` and `-=` operators on `Vec`:" msgstr "" "宏通过提取函数和/或测试套件的共同部分，使我们能够编写符合 DRY（Don't Repeat " "Yourself）原则的代码。下面是一个在 `Vec` 上实现并测试 `+=`、`*=` 和 `-=` " "运算符的示例：" #: src/macros/dry.md:11 msgid "" "// The `tt` (token tree) designator is used for\n" " // operators and tokens.\n" msgstr "" "// `tt`（token tree，标记树）指示符用于\n" " // 运算符和标记。\n" #: src/macros/dry.md:15 msgid "\"{:?}: dimension mismatch: {:?} {:?} {:?}\"" msgstr "\"{:?}：维度不匹配：{:?} {:?} {:?}\"" #: src/macros/dry.md:30 msgid "// *x = x.$method(*y);\n" msgstr "// *x = x.$method(*y);\n" #: src/macros/dry.md:35 msgid "// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.\n" msgstr "// 实现 `add_assign`、`mul_assign` 和 `sub_assign` 函数。\n" #: src/macros/dry.md:60 msgid "// Test `add_assign`, `mul_assign`, and `sub_assign`.\n" msgstr "// 测试 `add_assign`、`mul_assign` 和 `sub_assign`。\n" #: src/macros/dsl.md:1 msgid "Domain Specific Languages (DSLs)" msgstr "领域特定语言（DSL）" #: src/macros/dsl.md:3 msgid "" "A DSL is a mini \"language\" embedded in a Rust macro. It is completely " "valid Rust because the macro system expands into normal Rust constructs, but " "it looks like a small language. This allows you to define concise or " "intuitive syntax for some special functionality (within bounds)." msgstr "" "DSL 是嵌入在 Rust 宏中的一种微型\"语言\"。它是完全有效的 Rust 代码，因为宏系" "统会将其展开为普通的 Rust 结构，但它看起来像一种小型语言。这使你能够为某些特" "定功能定义简洁或直观的语法（在一定范围内）。" #: src/macros/dsl.md:8 msgid "" "Suppose that I want to define a little calculator API. I would like to " "supply an expression and have the output printed to console." msgstr "" "假设我想定义一个简单的计算器 API。我希望提供一个表达式，并将计算结果打印到控" "制台。" #: src/macros/dsl.md:15 msgid "// Force types to be unsigned integers\n" msgstr "// 强制类型为无符号整数\n" #: src/macros/dsl.md:16 src/macros/variadics.md:15 msgid "\"{} = {}\"" msgstr "\"{} = {}\"" #: src/macros/dsl.md:23 msgid "// hehehe `eval` is _not_ a Rust keyword!\n" msgstr "// 嘿嘿，`eval` 可不是 Rust 的关键字哦！\n" #: src/macros/dsl.md:32 src/macros/variadics.md:35 msgid "Output:" msgstr "输出：" #: src/macros/dsl.md:39 msgid "" "This was a very simple example, but much more complex interfaces have been " "developed, such as [`lazy_static`](https://crates.io/crates/lazy_static) or " "[`clap`](https://crates.io/crates/clap)." msgstr "" "这个例子非常简单，但已经有很多利用宏开发的复杂接口，比如 [`lazy_static`]" "(https://crates.io/crates/lazy_static) 或 [`clap`](https://crates.io/crates/" "clap)。" #: src/macros/dsl.md:43 msgid "" "Also, note the two pairs of braces in the macro. The outer ones are part of " "the syntax of `macro_rules!`, in addition to `()` or `[]`." msgstr "" "另外，注意宏中的两对大括号。外层的大括号是 `macro_rules!` 语法的一部分，除此" "之外还可以使用 `()` 或 `[]`。" #: src/macros/variadics.md:1 msgid "Variadic Interfaces" msgstr "可变参数接口" #: src/macros/variadics.md:3 msgid "" "A _variadic_ interface takes an arbitrary number of arguments. For example, " "`println!` can take an arbitrary number of arguments, as determined by the " "format string." msgstr "" "**可变参数**接口可以接受任意数量的参数。例如，`println!` 可以接受任意数量的参" "数，这由格式字符串决定。" #: src/macros/variadics.md:7 msgid "" "We can extend our `calculate!` macro from the previous section to be " "variadic:" msgstr "我们可以将上一节的 `calculate!` 宏扩展为可变参数的形式：" #: src/macros/variadics.md:11 msgid "// The pattern for a single `eval`\n" msgstr "// 单个 `eval` 的模式\n" #: src/macros/variadics.md:14 msgid "// Force types to be integers\n" msgstr "// 强制类型为整数\n" #: src/macros/variadics.md:19 msgid "// Decompose multiple `eval`s recursively\n" msgstr "// 递归分解多个 `eval`\n" #: src/macros/variadics.md:27 msgid "// Look ma! Variadic `calculate!`!\n" msgstr "// 瞧瞧！这是可变参数的 `calculate!`！\n" #: src/error.md:3 msgid "" "Error handling is the process of handling the possibility of failure. For " "example, failing to read a file and then continuing to use that _bad_ input " "would clearly be problematic. Noticing and explicitly managing those errors " "saves the rest of the program from various pitfalls." msgstr "" "错误处理是处理可能出现失败情况的过程。例如，读取文件失败后继续使用那个**错误" "的**输入显然会导致问题。注意并明确管理这些错误可以使程序的其他部分避免各种陷" "阱。" #: src/error.md:8 msgid "" "There are various ways to deal with errors in Rust, which are described in " "the following subchapters. They all have more or less subtle differences and " "different use cases. As a rule of thumb:" msgstr "" "Rust 中有多种处理错误的方法，这些方法将在接下来的小节中详细介绍。它们或多或少" "都有一些细微的差别和不同的使用场景。一般来说：" #: src/error.md:12 msgid "" "An explicit `panic` is mainly useful for tests and dealing with " "unrecoverable errors. For prototyping it can be useful, for example when " "dealing with functions that haven't been implemented yet, but in those cases " "the more descriptive `unimplemented` is better. In tests `panic` is a " "reasonable way to explicitly fail." msgstr "" "显式的 `panic` 主要用于测试和处理不可恢复的错误。在原型开发中，它可能会有用，" "例如在处理尚未实现的函数时。但在这些情况下，使用更具描述性的 `unimplemented` " "会更好。在测试中，`panic` 是一种合理的显式失败方式。" #: src/error.md:17 msgid "" "The `Option` type is for when a value is optional or when the lack of a " "value is not an error condition. For example the parent of a directory - `/` " "and `C:` don't have one. When dealing with `Option`s, `unwrap` is fine for " "prototyping and cases where it's absolutely certain that there is guaranteed " "to be a value. However `expect` is more useful since it lets you specify an " "error message in case something goes wrong anyway." msgstr "" "`Option` 类型用于值是可选的情况，或者缺少值不构成错误条件的情况。例如目录的父" "目录 - `/` 和 `C:` 就没有父目录。在处理 `Option` 时，对于原型设计和绝对确定有" "值的情况，使用 `unwrap` 是可以的。然而，`expect` 更有用，因为它允许你指定一个" "错误消息，以防万一出错。" #: src/error.md:24 msgid "" "When there is a chance that things do go wrong and the caller has to deal " "with the problem, use `Result`. You can `unwrap` and `expect` them as well " "(please don't do that unless it's a test or quick prototype)." msgstr "" "当有可能出错且调用者必须处理问题时，请使用 `Result`。你也可以对它们使用 " "`unwrap` 和 `expect`（除非是测试或快速原型，否则请不要这样做）。" #: src/error.md:28 msgid "" "For a more rigorous discussion of error handling, refer to the error " "handling section in the [official book](https://doc.rust-lang.org/book/" "ch09-00-error-handling.html)." msgstr "" "关于错误处理更详尽的讨论，请参阅[官方文档](https://doc.rust-lang.org/book/" "ch09-00-error-handling.html)中的错误处理章节。" #: src/error/panic.md:3 msgid "" "The simplest error handling mechanism we will see is `panic`. It prints an " "error message, starts unwinding the stack, and usually exits the program. " "Here, we explicitly call `panic` on our error condition:" msgstr "" "我们将看到的最简单的错误处理机制是 `panic`。它会打印一条错误消息，开始展开" "栈，并通常会退出程序。在这里，我们在错误条件下显式调用 `panic`：" #: src/error/panic.md:9 msgid "// You shouldn't drink too many sugary beverages.\n" msgstr "// 你不应该喝太多含糖饮料。\n" #: src/error/panic.md:10 src/error/panic.md:17 src/error/abort_unwind.md:10 #: src/error/abort_unwind.md:23 src/error/abort_unwind.md:41 #: src/error/abort_unwind.md:50 src/error/option_unwrap.md:32 #: src/error/option_unwrap.md:43 src/error/option_unwrap.md:50 msgid "\"lemonade\"" msgstr "\"柠檬水\"" #: src/error/panic.md:10 src/error/option_unwrap.md:43 msgid "\"AAAaaaaa!!!!\"" msgstr "\"啊啊啊啊啊！！！！\"" #: src/error/panic.md:12 src/error/abort_unwind.md:17 #: src/error/abort_unwind.md:44 msgid "\"Some refreshing {} is all I need.\"" msgstr "\"来点清爽的{}就是我现在需要的。\"" #: src/error/panic.md:16 src/error/abort_unwind.md:22 #: src/error/abort_unwind.md:49 src/error/option_unwrap.md:49 msgid "\"water\"" msgstr "\"水\"" #: src/error/panic.md:18 msgid "\"still water\"" msgstr "\"纯净水\"" #: src/error/panic.md:22 msgid "" "The first call to `drink` works. The second panics and thus the third is " "never called." msgstr "" "第一次调用 `drink` 正常执行。第二次调用会引发 panic，因此第三次调用永远不会被" "执行。" #: src/error/abort_unwind.md:1 msgid "`abort` and `unwind`" msgstr "`abort` 和 `unwind`" #: src/error/abort_unwind.md:3 msgid "" "The previous section illustrates the error handling mechanism `panic`. " "Different code paths can be conditionally compiled based on the panic " "setting. The current values available are `unwind` and `abort`." msgstr "" "上一节介绍了错误处理机制 `panic`。可以根据 panic 设置有条件地编译不同的代码路" "径。当前可用的值有 `unwind` 和 `abort`。" #: src/error/abort_unwind.md:5 msgid "" "Building on the prior lemonade example, we explicitly use the panic strategy " "to exercise different lines of code." msgstr "基于之前的柠檬水示例，我们明确使用 panic 策略来执行不同的代码行。" #: src/error/abort_unwind.md:9 msgid "// You shouldn't drink too much sugary beverages.\n" msgstr "// 你不应该喝太多含糖饮料。\n" #: src/error/abort_unwind.md:11 msgid "\"abort\"" msgstr "\"中止\"" #: src/error/abort_unwind.md:12 src/error/abort_unwind.md:37 msgid "\"This is not your party. Run!!!!\"" msgstr "\"这不是你的派对。快跑！！！！\"" #: src/error/abort_unwind.md:14 src/error/abort_unwind.md:32 msgid "\"Spit it out!!!!\"" msgstr "\"快吐出来！！！！\"" #: src/error/abort_unwind.md:27 msgid "" "Here is another example focusing on rewriting `drink()` and explicitly use " "the `unwind` keyword." msgstr "" "这里是另一个示例，重点是重写 `drink()` 函数并明确使用 `unwind` 关键字。" #: src/error/abort_unwind.md:30 src/error/abort_unwind.md:35 msgid "\"unwind\"" msgstr "\"unwind\"" #: src/error/abort_unwind.md:54 msgid "" "The panic strategy can be set from the command line by using `abort` or " "`unwind`." msgstr "可以通过命令行使用 `abort` 或 `unwind` 来设置 panic 策略。" #: src/error/option_unwrap.md:3 msgid "" "In the last example, we showed that we can induce program failure at will. " "We told our program to `panic` if we drink a sugary lemonade. But what if we " "expect _some_ drink but don't receive one? That case would be just as bad, " "so it needs to be handled!" msgstr "" "在上一个例子中，我们展示了如何主动引发程序失败。我们让程序在喝含糖柠檬水时触" "发 `panic`。但如果我们期望得到**某种**饮料却没有收到呢？这种情况同样糟糕，所" "以需要处理！" #: src/error/option_unwrap.md:8 msgid "" "We _could_ test this against the null string (`\"\"`) as we do with a " "lemonade. Since we're using Rust, let's instead have the compiler point out " "cases where there's no drink." msgstr "" "我们**可以**像处理柠檬水那样对空字符串（`\"\"`）进行测试。但既然我们使用的是 " "Rust，不如让编译器指出没有饮料的情况。" #: src/error/option_unwrap.md:12 msgid "" "An `enum` called `Option` in the `std` library is used when absence is a " "possibility. It manifests itself as one of two \"options\":" msgstr "" "`std` 库中的 `Option` 枚举用于处理可能存在缺失的情况。它表现为两个\"选项" "\"之一：" #: src/error/option_unwrap.md:15 msgid "`Some(T)`: An element of type `T` was found" msgstr "`Some(T)`：找到了一个 `T` 类型的元素" #: src/error/option_unwrap.md:16 msgid "`None`: No element was found" msgstr "`None`：没有找到元素" #: src/error/option_unwrap.md:18 msgid "" "These cases can either be explicitly handled via `match` or implicitly with " "`unwrap`. Implicit handling will either return the inner element or `panic`." msgstr "" "这些情况可以通过 `match` 显式处理，也可以用 `unwrap` 隐式处理。隐式处理要么返" "回内部元素，要么触发 `panic`。" #: src/error/option_unwrap.md:21 msgid "" "Note that it's possible to manually customize `panic` with [expect](https://" "doc.rust-lang.org/std/option/enum.Option.html#method.expect), but `unwrap` " "otherwise leaves us with a less meaningful output than explicit handling. In " "the following example, explicit handling yields a more controlled result " "while retaining the option to `panic` if desired." msgstr "" "注意，可以使用 [`expect`](https://doc.rust-lang.org/std/option/" "enum.Option.html#method.expect) 手动自定义 `panic`，但 `unwrap` 相比显式处理" "会产生一个不太有意义的输出。在下面的例子中，显式处理产生了一个更可控的结果，" "同时保留了在需要时触发 `panic` 的选项。" #: src/error/option_unwrap.md:27 msgid "" "// The adult has seen it all, and can handle any drink well.\n" "// All drinks are handled explicitly using `match`.\n" msgstr "" "// 成年人见多识广，可以很好地处理任何饮料。\n" "// 所有饮料都使用 `match` 显式处理。\n" #: src/error/option_unwrap.md:30 msgid "// Specify a course of action for each case.\n" msgstr "// 为每种情况指定一个处理方案。\n" #: src/error/option_unwrap.md:32 msgid "\"Yuck! Too sugary.\"" msgstr "\"呸！太甜了。\"" #: src/error/option_unwrap.md:33 msgid "\"{}? How nice.\"" msgstr "\"{}？真不错。\"" #: src/error/option_unwrap.md:34 msgid "\"No drink? Oh well.\"" msgstr "\"没有饮料？好吧。\"" #: src/error/option_unwrap.md:37 msgid "" "// Others will `panic` before drinking sugary drinks.\n" "// All drinks are handled implicitly using `unwrap`.\n" msgstr "" "// 其他人在喝含糖饮料前会触发 `panic`。\n" "// 所有饮料都使用 `unwrap` 隐式处理。\n" #: src/error/option_unwrap.md:41 msgid "// `unwrap` returns a `panic` when it receives a `None`.\n" msgstr "// 当 `unwrap` 收到 `None` 时会触发 `panic`。\n" #: src/error/option_unwrap.md:45 msgid "\"I love {}s!!!!!\"" msgstr "\"我超爱{}！！！！！\"" #: src/error/option_unwrap.md:57 msgid "\"coffee\"" msgstr "\"咖啡\"" #: src/error/option_unwrap/question_mark.md:3 msgid "" "You can unpack `Option`s by using `match` statements, but it's often easier " "to use the `?` operator. If `x` is an `Option`, then evaluating `x?` will " "return the underlying value if `x` is `Some`, otherwise it will terminate " "whatever function is being executed and return `None`." msgstr "" "你可以使用 `match` 语句来解包 `Option`，但使用 `?` 运算符通常更简便。如果 " "`x` 是一个 `Option`，那么求值 `x?` 将在 `x` 是 `Some` 时返回其内部值，否则它" "将终止当前执行的函数并返回 `None`。" #: src/error/option_unwrap/question_mark.md:10 msgid "" "// If `current_age` is `None`, this returns `None`.\n" " // If `current_age` is `Some`, the inner `u8` value + 1\n" " // gets assigned to `next_age`\n" msgstr "" "// 如果 `current_age` 是 `None`，这将返回 `None`。\n" " // 如果 `current_age` 是 `Some`，内部的 `u8` 值加 1\n" " // 后被赋值给 `next_age`\n" #: src/error/option_unwrap/question_mark.md:14 msgid "\"Next year I will be {}\"" msgstr "\"明年我将会 {} 岁\"" #: src/error/option_unwrap/question_mark.md:18 msgid "You can chain many `?`s together to make your code much more readable." msgstr "你可以将多个 `?` 链接在一起，使你的代码更易读。" #: src/error/option_unwrap/question_mark.md:38 msgid "" "// Gets the area code of the phone number of the person's job, if it " "exists.\n" msgstr "// 如果存在，获取此人工作电话号码的区号。\n" #: src/error/option_unwrap/question_mark.md:40 msgid "" "// This would need many nested `match` statements without the `?` operator.\n" " // It would take a lot more code - try writing it yourself and see " "which\n" " // is easier.\n" msgstr "" "// 如果没有 `?` 运算符，这将需要许多嵌套的 `match` 语句。\n" " // 这将需要更多的代码 - 试着自己写一下，看看哪种方式\n" " // 更容易。\n" #: src/error/option_unwrap/map.md:3 msgid "" "`match` is a valid method for handling `Option`s. However, you may " "eventually find heavy usage tedious, especially with operations only valid " "with an input. In these cases, [combinators](https://doc.rust-lang.org/" "reference/glossary.html#combinator) can be used to manage control flow in a " "modular fashion." msgstr "" "`match` 是处理 `Option` 的有效方法。然而，频繁使用可能会让人感到繁琐，尤其是" "在只有输入时才有效的操作中。在这些情况下，可以使用[组合器](https://doc.rust-" "lang.org/reference/glossary.html#combinator)以模块化的方式管理控制流。" #: src/error/option_unwrap/map.md:8 msgid "" "`Option` has a built in method called `map()`, a combinator for the simple " "mapping of `Some -> Some` and `None -> None`. Multiple `map()` calls can be " "chained together for even more flexibility." msgstr "" "`Option` 有一个内置方法 `map()`，这是一个用于简单映射 `Some -> Some` 和 " "`None -> None` 的组合器。多个 `map()` 调用可以链式使用，从而提供更大的灵活" "性。" #: src/error/option_unwrap/map.md:12 msgid "" "In the following example, `process()` replaces all functions previous to it " "while staying compact." msgstr "在下面的例子中，`process()` 函数以简洁的方式替代了之前的所有函数。" #: src/error/option_unwrap/map.md:23 msgid "" "// Peeling food. If there isn't any, then return `None`.\n" "// Otherwise, return the peeled food.\n" msgstr "" "// 剥皮食物。如果没有食物，则返回 `None`。\n" "// 否则，返回剥皮后的食物。\n" #: src/error/option_unwrap/map.md:32 msgid "" "// Chopping food. If there isn't any, then return `None`.\n" "// Otherwise, return the chopped food.\n" msgstr "" "// 切碎食物。如果没有食物，则返回 `None`。\n" "// 否则，返回切碎后的食物。\n" #: src/error/option_unwrap/map.md:41 msgid "" "// Cooking food. Here, we showcase `map()` instead of `match` for case " "handling.\n" msgstr "" "// 烹饪食物。这里我们展示了使用 `map()` 而非 `match` 来处理不同情况。\n" #: src/error/option_unwrap/map.md:46 msgid "" "// A function to peel, chop, and cook food all in sequence.\n" "// We chain multiple uses of `map()` to simplify the code.\n" msgstr "" "// 一个按顺序剥皮、切碎和烹饪食物的函数。\n" "// 我们通过链式调用多个 `map()` 来简化代码。\n" #: src/error/option_unwrap/map.md:54 msgid "// Check whether there's food or not before trying to eat it!\n" msgstr "// 在尝试吃之前，先检查是否有食物！\n" #: src/error/option_unwrap/map.md:58 msgid "\"Mmm. I love {:?}\"" msgstr "\"嗯，我喜欢 {:?}\"" #: src/error/option_unwrap/map.md:59 msgid "\"Oh no! It wasn't edible.\"" msgstr "\"哎呀！这不能吃。\"" #: src/error/option_unwrap/map.md:70 msgid "// Let's try the simpler looking `process()` now.\n" msgstr "// 现在让我们试试看起来更简洁的 `process()` 函数。\n" #: src/error/option_unwrap/map.md:81 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" msgstr "" "[闭包](../../fn/closures.md)、[`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html)、[`Option::map()`](https://doc.rust-lang.org/std/" "option/enum.Option.html#method.map)" #: src/error/option_unwrap/and_then.md:3 msgid "" "`map()` was described as a chainable way to simplify `match` statements. " "However, using `map()` on a function that returns an `Option` results in " "the nested `Option>`. Chaining multiple calls together can then " "become confusing. That's where another combinator called `and_then()`, known " "in some languages as flatmap, comes in." msgstr "" "`map()` 被描述为一种可链式调用的方式来简化 `match` 语句。然而，在返回 " "`Option` 的函数上使用 `map()` 会导致嵌套的 `Option>`。链式调用多" "个这样的函数可能会变得令人困惑。这时，另一个称为 `and_then()` 的组合器（在某" "些语言中称为 flatmap）就派上用场了。" #: src/error/option_unwrap/and_then.md:9 msgid "" "`and_then()` calls its function input with the wrapped value and returns the " "result. If the `Option` is `None`, then it returns `None` instead." msgstr "" "`and_then()` 使用包装的值调用其函数输入并返回结果。如果 `Option` 是 `None`，" "则直接返回 `None`。" #: src/error/option_unwrap/and_then.md:11 msgid "" "In the following example, `cookable_v3()` results in an `Option`. " "Using `map()` instead of `and_then()` would have given an " "`Option>`, which is an invalid type for `eat()`." msgstr "" "在下面的例子中，`cookable_v3()` 返回一个 `Option`。如果使用 `map()` 而" "不是 `and_then()`，将会得到一个 `Option>`，这对于 `eat()` 函数来" "说是一个无效的类型。" #: src/error/option_unwrap/and_then.md:20 msgid "// We don't have the ingredients to make Sushi.\n" msgstr "// 我们没有制作寿司的原料。\n" #: src/error/option_unwrap/and_then.md:28 msgid "// We have the recipe for everything except Cordon Bleu.\n" msgstr "// 我们有除了蓝带猪排以外所有菜品的食谱。\n" #: src/error/option_unwrap/and_then.md:36 msgid "" "// To make a dish, we need both the recipe and the ingredients.\n" "// We can represent the logic with a chain of `match`es:\n" msgstr "" "// 要做一道菜，我们需要食谱和原料。\n" "// 我们可以用一系列的 `match` 来表示这个逻辑：\n" #: src/error/option_unwrap/and_then.md:45 msgid "" "// This can conveniently be rewritten more compactly with `and_then()`:\n" msgstr "// 这可以使用 `and_then()` 更简洁地重写：\n" #: src/error/option_unwrap/and_then.md:50 msgid "" "// Otherwise we'd need to `flatten()` an `Option>`\n" "// to get an `Option`:\n" msgstr "" "// 否则我们需要对 `Option>` 使用 `flatten()`\n" "// 来获得 `Option`：\n" #: src/error/option_unwrap/and_then.md:59 msgid "\"Yay! On {:?} we get to eat {:?}.\"" msgstr "\"太好了！在 {:?} 我们可以吃到 {:?}。\"" #: src/error/option_unwrap/and_then.md:60 msgid "\"Oh no. We don't get to eat on {:?}?\"" msgstr "\"哦不。我们在 {:?} 没有东西吃吗？\"" #: src/error/option_unwrap/and_then.md:75 msgid "" "[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then), and [`Option::flatten()`]" "(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" msgstr "" "[闭包](../../fn/closures.md)、[`Option`](https://doc.rust-lang.org/std/" "option/enum.Option.html)、[`Option::and_then()`](https://doc.rust-lang.org/" "std/option/enum.Option.html#method.and_then) 和 [`Option::flatten()`]" "(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)" #: src/error/option_unwrap/defaults.md:1 msgid "Unpacking options and defaults" msgstr "解包 Option 和设置默认值" #: src/error/option_unwrap/defaults.md:3 msgid "" "There is more than one way to unpack an `Option` and fall back on a default " "if it is `None`. To choose the one that meets our needs, we need to consider " "the following:" msgstr "" "有多种方法可以解包 `Option` 并在其为 `None` 时使用默认值。为了选择满足我们需" "求的方法，我们需要考虑以下几点：" #: src/error/option_unwrap/defaults.md:5 msgid "do we need eager or lazy evaluation?" msgstr "我们需要立即求值还是惰性求值？" #: src/error/option_unwrap/defaults.md:6 msgid "" "do we need to keep the original empty value intact, or modify it in place?" msgstr "我们需要保持原始的空值不变，还是就地修改它？" #: src/error/option_unwrap/defaults.md:8 msgid "`or()` is chainable, evaluates eagerly, keeps empty value intact" msgstr "`or()` 可链式调用，立即求值，保持空值不变" #: src/error/option_unwrap/defaults.md:10 msgid "" "`or()`is chainable and eagerly evaluates its argument, as is shown in the " "following example. Note that because `or`'s arguments are evaluated eagerly, " "the variable passed to `or` is moved." msgstr "" "`or()` 可以链式调用，并且会立即求值其参数，如下例所示。注意，由于 `or` 的参数" "是立即求值的，传递给 `or` 的变量会被移动。" #: src/error/option_unwrap/defaults.md:22 #: src/error/option_unwrap/defaults.md:55 msgid "\"first_available_fruit: {:?}\"" msgstr "\"第一个可用的水果：{:?}\"" #: src/error/option_unwrap/defaults.md:23 msgid "// first_available_fruit: Some(Orange)\n" msgstr "// first_available_fruit: Some(Orange)\n" #: src/error/option_unwrap/defaults.md:25 msgid "" "// `or` moves its argument.\n" " // In the example above, `or(orange)` returned a `Some`, so `or(apple)` " "was not invoked.\n" " // But the variable named `apple` has been moved regardless, and cannot " "be used anymore.\n" " // println!(\"Variable apple was moved, so this line won't compile: {:?}" "\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" "// `or` 会移动其参数。\n" " // 在上面的例子中，`or(orange)` 返回了 `Some`，所以 `or(apple)` 没有被调" "用。\n" " // 但是名为 `apple` 的变量无论如何都被移动了，不能再使用。\n" " // println!(\"变量 apple 被移动了，所以这行不会编译：{:?}\", apple);\n" " // TODO：取消上面这行的注释来查看编译器错误\n" #: src/error/option_unwrap/defaults.md:33 msgid "`or_else()` is chainable, evaluates lazily, keeps empty value intact" msgstr "`or_else()` 可以链式调用，惰性求值，保持空值不变" #: src/error/option_unwrap/defaults.md:35 msgid "" "Another alternative is to use `or_else`, which is also chainable, and " "evaluates lazily, as is shown in the following example:" msgstr "" "另一种选择是使用 `or_else`，它同样支持链式调用，并且采用惰性求值。以下是一个" "示例：" #: src/error/option_unwrap/defaults.md:44 msgid "\"Providing kiwi as fallback\"" msgstr "\"提供猕猴桃作为备选\"" #: src/error/option_unwrap/defaults.md:48 #: src/error/option_unwrap/defaults.md:93 msgid "\"Providing lemon as fallback\"" msgstr "\"提供柠檬作为备选\"" #: src/error/option_unwrap/defaults.md:56 msgid "" "// Providing kiwi as fallback\n" " // first_available_fruit: Some(Kiwi)\n" msgstr "" "// 提供猕猴桃作为备选\n" " // first_available_fruit: Some(Kiwi)\n" #: src/error/option_unwrap/defaults.md:61 msgid "`get_or_insert()` evaluates eagerly, modifies empty value in place" msgstr "`get_or_insert()` 立即求值，原地修改空值" #: src/error/option_unwrap/defaults.md:63 msgid "" "To make sure that an `Option` contains a value, we can use `get_or_insert` " "to modify it in place with a fallback value, as is shown in the following " "example. Note that `get_or_insert` eagerly evaluates its parameter, so " "variable `apple` is moved:" msgstr "" "为确保 `Option` 包含一个值，我们可以使用 `get_or_insert` 来原地修改它，提供一" "个备选值。下面的例子展示了这一点。请注意，`get_or_insert` 会立即求值其参数，" "因此变量 `apple` 会被移动：" #: src/error/option_unwrap/defaults.md:73 #: src/error/option_unwrap/defaults.md:98 msgid "\"first_available_fruit is: {:?}\"" msgstr "\"第一个可用的水果是：{:?}\"" #: src/error/option_unwrap/defaults.md:74 #: src/error/option_unwrap/defaults.md:99 msgid "\"my_fruit is: {:?}\"" msgstr "\"我的水果是：{:?}\"" #: src/error/option_unwrap/defaults.md:75 msgid "" "// first_available_fruit is: Apple\n" " // my_fruit is: Some(Apple)\n" " //println!(\"Variable named `apple` is moved: {:?}\", apple);\n" " // TODO: uncomment the line above to see the compiler error\n" msgstr "" "// first_available_fruit is: Apple\n" " // my_fruit is: Some(Apple)\n" " //println!(\"名为 `apple` 的变量已被移动：{:?}\", apple);\n" " // TODO：取消上面这行的注释以查看编译器错误\n" #: src/error/option_unwrap/defaults.md:82 msgid "`get_or_insert_with()` evaluates lazily, modifies empty value in place" msgstr "`get_or_insert_with()` 惰性求值，原地修改空值" #: src/error/option_unwrap/defaults.md:84 msgid "" "Instead of explicitly providing a value to fall back on, we can pass a " "closure to `get_or_insert_with`, as follows:" msgstr "" "我们可以向 `get_or_insert_with` 传递一个闭包，而不是显式提供一个备选值。示例" "如下：" #: src/error/option_unwrap/defaults.md:100 msgid "" "// Providing lemon as fallback\n" " // first_available_fruit is: Lemon\n" " // my_fruit is: Some(Lemon)\n" msgstr "" "// 提供柠檬作为备选\n" " // first_available_fruit is: Lemon\n" " // my_fruit is: Some(Lemon)\n" #: src/error/option_unwrap/defaults.md:104 msgid "" "// If the Option has a value, it is left unchanged, and the closure is not " "invoked\n" msgstr "// 如果 Option 已有值，它将保持不变，闭包不会被调用\n" #: src/error/option_unwrap/defaults.md:107 msgid "\"should_be_apple is: {:?}\"" msgstr "\"should_be_apple 的值为：{:?}\"" #: src/error/option_unwrap/defaults.md:108 msgid "\"my_apple is unchanged: {:?}\"" msgstr "\"my_apple 保持不变：{:?}\"" #: src/error/option_unwrap/defaults.md:109 msgid "" "// The output is a follows. Note that the closure `get_lemon_as_fallback` is " "not invoked\n" " // should_be_apple is: Apple\n" " // my_apple is unchanged: Some(Apple)\n" msgstr "" "// 输出如下。注意闭包 `get_lemon_as_fallback` 并未被调用\n" " // should_be_apple is: Apple\n" " // my_apple is unchanged: Some(Apple)\n" #: src/error/option_unwrap/defaults.md:117 msgid "" "[`closures`](https://doc.rust-lang.org/book/ch13-01-closures.html), " "[`get_or_insert`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.get_or_insert), [`get_or_insert_with`](https://" "doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with), " "[`moved variables`](https://doc.rust-lang.org/book/ch04-02-references-and-" "borrowing.html), [`or`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.or), [`or_else`](https://doc.rust-lang.org/core/" "option/enum.Option.html#method.or_else)" msgstr "" "[`闭包`](https://doc.rust-lang.org/book/ch13-01-closures.html)、" "[`get_or_insert`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.get_or_insert)、[`get_or_insert_with`](https://" "doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with)、[`" "变量移动`](https://doc.rust-lang.org/book/ch04-02-references-and-" "borrowing.html)、[`or`](https://doc.rust-lang.org/core/option/" "enum.Option.html#method.or)、[`or_else`](https://doc.rust-lang.org/core/" "option/enum.Option.html#method.or_else)" #: src/error/result.md:3 msgid "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) is a " "richer version of the [`Option`](https://doc.rust-lang.org/std/option/" "enum.Option.html) type that describes possible _error_ instead of possible " "_absence_." msgstr "" "[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) 是 " "[`Option`](https://doc.rust-lang.org/std/option/enum.Option.html) 类型的增强" "版，它描述可能的**错误**而非可能的**缺失**。" #: src/error/result.md:6 msgid "That is, `Result` could have one of two outcomes:" msgstr "也就是说，`Result` 可能有两种结果之一：" #: src/error/result.md:8 msgid "`Ok(T)`: An element `T` was found" msgstr "`Ok(T)`：找到了一个 `T` 类型的元素" #: src/error/result.md:9 msgid "`Err(E)`: An error was found with element `E`" msgstr "`Err(E)`：发生了一个 `E` 类型的错误" #: src/error/result.md:11 msgid "" "By convention, the expected outcome is `Ok` while the unexpected outcome is " "`Err`." msgstr "按照惯例，预期的结果是 `Ok`，而意外的结果是 `Err`。" #: src/error/result.md:13 msgid "" "Like `Option`, `Result` has many methods associated with it. `unwrap()`, for " "example, either yields the element `T` or `panic`s. For case handling, there " "are many combinators between `Result` and `Option` that overlap." msgstr "" "与 `Option` 类似，`Result` 也有许多关联方法。例如，`unwrap()` 要么返回元素 " "`T`，要么触发 `panic`。对于情况处理，`Result` 和 `Option` 之间有许多重叠的组" "合子。" #: src/error/result.md:17 msgid "" "In working with Rust, you will likely encounter methods that return the " "`Result` type, such as the [`parse()`](https://doc.rust-lang.org/std/" "primitive.str.html#method.parse) method. It might not always be possible to " "parse a string into the other type, so `parse()` returns a `Result` " "indicating possible failure." msgstr "" "在使用 Rust 时，你可能会遇到返回 `Result` 类型的方法，比如 [`parse()`]" "(https://doc.rust-lang.org/std/primitive.str.html#method.parse) 方法。将字符" "串解析为其他类型并非总是可行，因此 `parse()` 返回一个 `Result` 来表示可能的失" "败。" #: src/error/result.md:22 msgid "" "Let's see what happens when we successfully and unsuccessfully `parse()` a " "string:" msgstr "让我们看看成功和失败地 `parse()` 一个字符串会发生什么：" #: src/error/result.md:26 msgid "// Let's try using `unwrap()` to get the number out. Will it bite us?\n" msgstr "// 让我们尝试使用 `unwrap()` 来获取数字。这样做会有问题吗？\n" #: src/error/result.md:33 src/error/result.md:36 #: src/error/result/result_map.md:42 src/error/result/result_map.md:46 #: src/error/result/result_map.md:75 src/error/result/result_map.md:79 #: src/error/result/result_alias.md:36 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:36 src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:34 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:67 #: src/error/result/enter_question_mark.md:68 msgid "\"2\"" msgstr "\"2\"" #: src/error/result.md:34 src/error/result.md:37 msgid "\"double is {}\"" msgstr "\"double is {}\"" #: src/error/result.md:36 src/error/result/result_map.md:46 #: src/error/result/result_map.md:79 src/error/result/result_alias.md:37 #: src/error/result/early_returns.md:37 #: src/error/result/enter_question_mark.md:35 #: src/error/result/enter_question_mark.md:68 msgid "\"t\"" msgstr "\"t\"" #: src/error/result.md:41 msgid "" "In the unsuccessful case, `parse()` leaves us with an error for `unwrap()` " "to `panic` on. Additionally, the `panic` exits our program and provides an " "unpleasant error message." msgstr "" "在解析失败的情况下，`parse()` 会返回一个错误，导致 `unwrap()` 触发 panic。此" "外，panic 会终止程序并输出一条不友好的错误信息。" #: src/error/result.md:45 msgid "" "To improve the quality of our error message, we should be more specific " "about the return type and consider explicitly handling the error." msgstr "" "为了提高错误信息的质量，我们应该更明确地指定返回类型，并考虑显式地处理错误。" #: src/error/result.md:48 msgid "Using `Result` in `main`" msgstr "在 `main` 函数中使用 `Result`" #: src/error/result.md:50 msgid "" "The `Result` type can also be the return type of the `main` function if " "specified explicitly. Typically the `main` function will be of the form:" msgstr "" "如果显式指定，`Result` 类型也可以作为 `main` 函数的返回类型。通常，`main` 函" "数的形式如下：" #: src/error/result.md:59 msgid "" "However `main` is also able to have a return type of `Result`. If an error " "occurs within the `main` function it will return an error code and print a " "debug representation of the error (using the [`Debug`](https://doc.rust-" "lang.org/std/fmt/trait.Debug.html) trait). The following example shows such " "a scenario and touches on aspects covered in [the following section](result/" "early_returns.md)." msgstr "" "然而，`main` 函数也可以返回 `Result` 类型。如果 `main` 函数内发生错误，它将返" "回一个错误代码并打印该错误的调试表示（使用 [`Debug`] trait）。以下示例展示了" "这种情况，并涉及了[下一节]中讨论的内容。\n" "\n" "[`Debug`]: https://doc.rust-lang.org/std/fmt/trait.Debug.html\n" "[下一节]: result/early_returns.md" #: src/error/result/result_map.md:3 msgid "" "Panicking in the previous example's `multiply` does not make for robust " "code. Generally, we want to return the error to the caller so it can decide " "what is the right way to respond to errors." msgstr "" "在前面示例的 `multiply` 函数中使用 panic 并不能产生健壮的代码。通常，我们希望" "将错误返回给调用者，让它决定如何正确地处理错误。" #: src/error/result/result_map.md:7 msgid "" "We first need to know what kind of error type we are dealing with. To " "determine the `Err` type, we look to [`parse()`](https://doc.rust-lang.org/" "std/primitive.str.html#method.parse), which is implemented with the " "[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for " "[`i32`](https://doc.rust-lang.org/std/primitive.i32.html). As a result, the " "`Err` type is specified as [`ParseIntError`](https://doc.rust-lang.org/std/" "num/struct.ParseIntError.html)." msgstr "" "首先，我们需要知道我们正在处理的错误类型。要确定 `Err` 类型，我们可以查看 " "[`parse()`] 方法，它是通过 [`FromStr`] trait 为 [`i32`] 实现的。因此，`Err` " "类型被指定为 [`ParseIntError`]。\n" "\n" "[`parse()`]: https://doc.rust-lang.org/std/primitive.str.html#method.parse\n" "[`FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html\n" "[`i32`]: https://doc.rust-lang.org/std/primitive.i32.html\n" "[`ParseIntError`]: https://doc.rust-lang.org/std/num/" "struct.ParseIntError.html" #: src/error/result/result_map.md:12 msgid "" "In the example below, the straightforward `match` statement leads to code " "that is overall more cumbersome." msgstr "在下面的示例中，直接使用 `match` 语句会导致整体代码更加繁琐。" #: src/error/result/result_map.md:17 msgid "" "// With the return type rewritten, we use pattern matching without " "`unwrap()`.\n" msgstr "// 重写返回类型后，我们使用模式匹配而不是 `unwrap()`。\n" #: src/error/result/result_map.md:35 src/error/result/result_map.md:68 #: src/error/result/result_alias.md:30 src/error/result/early_returns.md:30 #: src/error/result/enter_question_mark.md:28 #: src/error/result/enter_question_mark.md:61 msgid "\"n is {}\"" msgstr "\"n 是 {}\"" #: src/error/result/result_map.md:36 src/error/result/result_map.md:69 #: src/error/result/result_alias.md:31 src/error/result/early_returns.md:31 #: src/error/result/enter_question_mark.md:29 #: src/error/result/enter_question_mark.md:62 #: src/error/multiple_error_types/define_error_type.md:55 #: src/error/multiple_error_types/boxing_errors.md:42 #: src/error/multiple_error_types/reenter_question_mark.md:54 #: src/error/multiple_error_types/wrap_error.md:68 msgid "\"Error: {}\"" msgstr "\"错误：{}\"" #: src/error/result/result_map.md:41 src/error/result/result_map.md:74 msgid "// This still presents a reasonable answer.\n" msgstr "// 这仍然给出了一个合理的答案。\n" #: src/error/result/result_map.md:45 src/error/result/result_map.md:78 msgid "// The following now provides a much more helpful error message.\n" msgstr "// 以下代码现在提供了一个更有帮助的错误消息。\n" #: src/error/result/result_map.md:51 msgid "" "Luckily, `Option`'s `map`, `and_then`, and many other combinators are also " "implemented for `Result`. [`Result`](https://doc.rust-lang.org/std/result/" "enum.Result.html) contains a complete listing." msgstr "" "幸运的是，`Option` 的 `map`、`and_then` 以及许多其他组合器也为 `Result` 实现" "了。[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) 文档中" "包含了完整的列表。" #: src/error/result/result_map.md:56 msgid "" "// As with `Option`, we can use combinators such as `map()`.\n" "// This function is otherwise identical to the one above and reads:\n" "// Multiply if both values can be parsed from str, otherwise pass on the " "error.\n" msgstr "" "// 与 `Option` 类似，我们可以使用诸如 `map()` 之类的组合器。\n" "// 这个函数除此之外与上面的函数相同，其含义为：\n" "// 如果两个值都可以从字符串解析，则相乘；否则传递错误。\n" #: src/error/result/result_alias.md:3 msgid "" "How about when we want to reuse a specific `Result` type many times? Recall " "that Rust allows us to create [aliases](../../types/alias.md). Conveniently, " "we can define one for the specific `Result` in question." msgstr "" "如果我们想多次重用特定的 `Result` 类型，该怎么办？回想一下，Rust 允许我们创建" "[别名](../../types/alias.md)。方便的是，我们可以为特定的 `Result` 定义一个别" "名。" #: src/error/result/result_alias.md:7 msgid "" "At a module level, creating aliases can be particularly helpful. Errors " "found in a specific module often have the same `Err` type, so a single alias " "can succinctly define _all_ associated `Results`. This is so useful that the " "`std` library even supplies one: [`io::Result`](https://doc.rust-lang.org/" "std/io/type.Result.html)!" msgstr "" "在模块级别，创建别名特别有用。在特定模块中发现的错误通常具有相同的 `Err` 类" "型，因此单个别名可以简洁地定义**所有**相关的 `Result`。这非常实用，以至于 " "`std` 库甚至提供了一个：[`io::Result`](https://doc.rust-lang.org/std/io/" "type.Result.html)！" #: src/error/result/result_alias.md:12 msgid "Here's a quick example to show off the syntax:" msgstr "这里有一个简单的例子来展示语法：" #: src/error/result/result_alias.md:16 msgid "" "// Define a generic alias for a `Result` with the error type " "`ParseIntError`.\n" msgstr "// 为错误类型为 `ParseIntError` 的 `Result` 定义一个泛型别名。\n" #: src/error/result/result_alias.md:19 msgid "// Use the above alias to refer to our specific `Result` type.\n" msgstr "// 使用上面定义的别名来引用我们特定的 `Result` 类型。\n" #: src/error/result/result_alias.md:26 msgid "// Here, the alias again allows us to save some space.\n" msgstr "// 在这里，别名再次让我们节省了一些代码空间。\n" #: src/error/result/result_alias.md:43 msgid "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" msgstr "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)" #: src/error/result/early_returns.md:3 msgid "" "In the previous example, we explicitly handled the errors using combinators. " "Another way to deal with this case analysis is to use a combination of " "`match` statements and _early returns_." msgstr "" "在前面的例子中，我们使用组合器显式地处理了错误。处理这种情况分析的另一种方法" "是使用 `match` 语句和**提前返回**的组合。" #: src/error/result/early_returns.md:7 msgid "" "That is, we can simply stop executing the function and return the error if " "one occurs. For some, this form of code can be easier to both read and " "write. Consider this version of the previous example, rewritten using early " "returns:" msgstr "" "也就是说，如果发生错误，我们可以简单地停止执行函数并返回错误。对某些人来说，" "这种形式的代码可能更容易阅读和编写。考虑使用提前返回重写的前面示例的这个版" "本：" #: src/error/result/early_returns.md:41 msgid "" "At this point, we've learned to explicitly handle errors using combinators " "and early returns. While we generally want to avoid panicking, explicitly " "handling all of our errors is cumbersome." msgstr "" "到目前为止，我们已经学会了使用组合器和提前返回来显式处理错误。虽然我们通常想" "避免 panic，但显式处理所有错误是很繁琐的。" #: src/error/result/early_returns.md:45 msgid "" "In the next section, we'll introduce `?` for the cases where we simply need " "to `unwrap` without possibly inducing `panic`." msgstr "" "在下一节中，我们将介绍 `?` 运算符，用于我们只需要 `unwrap` 而不可能引发 " "`panic` 的情况。" #: src/error/result/enter_question_mark.md:3 msgid "" "Sometimes we just want the simplicity of `unwrap` without the possibility of " "a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when " "what we really wanted was to get the variable _out_. This is exactly the " "purpose of `?`." msgstr "" "有时我们只想要 `unwrap` 的简单性，而不希望有 `panic` 的可能。到目前为止，当我" "们真正想要的是获取变量**值**时，`unwrap` 迫使我们不断地增加嵌套。这正是 `?` " "运算符的目的。" #: src/error/result/enter_question_mark.md:7 msgid "Upon finding an `Err`, there are two valid actions to take:" msgstr "当遇到 `Err` 时，有两种可行的处理方式：" #: src/error/result/enter_question_mark.md:9 msgid "`panic!` which we already decided to try to avoid if possible" msgstr "1. 使用 `panic!`（我们已经决定尽可能避免这种方式）" #: src/error/result/enter_question_mark.md:10 msgid "`return` because an `Err` means it cannot be handled" msgstr "2. 使用 `return`（因为 `Err` 表示无法处理该错误）" #: src/error/result/enter_question_mark.md:12 msgid "" "`?` is _almost_[^†] exactly equivalent to an `unwrap` which `return`s " "instead of `panic`king on `Err`s. Let's see how we can simplify the earlier " "example that used combinators:" msgstr "" "`?` 运算符**几乎**[^†]等同于在遇到 `Err` 时执行 `return` 而非 `panic` 的 " "`unwrap`。让我们看看如何简化之前使用组合器的例子：" #: src/error/result/enter_question_mark.md:39 msgid "The `try!` macro" msgstr "`try!` 宏" #: src/error/result/enter_question_mark.md:41 msgid "" "Before there was `?`, the same functionality was achieved with the `try!` " "macro. The `?` operator is now recommended, but you may still find `try!` " "when looking at older code. The same `multiply` function from the previous " "example would look like this using `try!`:" msgstr "" "在 `?` 运算符出现之前，相同的功能是通过 `try!` 宏实现的。现在推荐使用 `?` 运" "算符，但在查看旧代码时，你可能仍会遇到 `try!`。使用 `try!` 宏，前面例子中的 " "`multiply` 函数会是这样的：" #: src/error/result/enter_question_mark.md:47 msgid "" "// To compile and run this example without errors, while using Cargo, change " "the value\n" "// of the `edition` field, in the `[package]` section of the `Cargo.toml` " "file, to \"2015\".\n" msgstr "" "// 要使用 Cargo 编译并运行此示例而不出错，请将 `Cargo.toml` 文件中\n" "// `[package]` 部分的 `edition` 字段值更改为 \"2015\"。\n" #: src/error/result/enter_question_mark.md:72 msgid "" "See [re-enter ?](../multiple_error_types/reenter_question_mark.md) for more " "details." msgstr "" "更多详情请参阅[重新认识 ?](../multiple_error_types/" "reenter_question_mark.md)。" #: src/error/multiple_error_types.md:3 msgid "" "The previous examples have always been very convenient; `Result`s interact " "with other `Result`s and `Option`s interact with other `Option`s." msgstr "" "前面的例子一直都很方便：`Result` 与 `Result` 交互，`Option` 与 `Option` 交" "互。" #: src/error/multiple_error_types.md:6 msgid "" "Sometimes an `Option` needs to interact with a `Result`, or a `Result` needs to interact with a `Result`. In those cases, we " "want to manage our different error types in a way that makes them composable " "and easy to interact with." msgstr "" "有时，`Option` 需要与 `Result` 交互，或者 `Result` 需要与 " "`Result` 交互。在这些情况下，我们希望以一种使不同错误类型可组合且" "易于交互的方式来管理它们。" #: src/error/multiple_error_types.md:11 msgid "" "In the following code, two instances of `unwrap` generate different error " "types. `Vec::first` returns an `Option`, while `parse::` returns a " "`Result`:" msgstr "" "在下面的代码中，两个 `unwrap` 实例生成了不同的错误类型。`Vec::first` 返回一" "个 `Option`，而 `parse::` 返回一个 `Result`：" #: src/error/multiple_error_types.md:17 msgid "// Generate error 1\n" msgstr "// 生成错误 1\n" #: src/error/multiple_error_types.md:18 msgid "// Generate error 2\n" msgstr "// 生成错误 2\n" #: src/error/multiple_error_types.md:22 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/wrap_error.md:77 src/error/iter_result.md:40 msgid "\"42\"" msgstr "\"42\"" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"93\"" msgstr "\"93\"" #: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:16 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:45 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:60 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:47 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:59 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:77 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"18\"" msgstr "\"18\"" #: src/error/multiple_error_types.md:24 #: src/error/multiple_error_types/option_result.md:18 #: src/error/multiple_error_types/option_result.md:47 #: src/error/multiple_error_types/define_error_type.md:62 #: src/error/multiple_error_types/boxing_errors.md:49 #: src/error/multiple_error_types/reenter_question_mark.md:61 #: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7 #: src/error/iter_result.md:24 src/error/iter_result.md:40 #: src/error/iter_result.md:60 src/error/iter_result.md:75 #: src/error/iter_result.md:90 msgid "\"tofu\"" msgstr "\"tofu\"" #: src/error/multiple_error_types.md:26 src/error/multiple_error_types.md:28 #: src/error/multiple_error_types.md:31 #: src/error/multiple_error_types/define_error_type.md:54 #: src/error/multiple_error_types/boxing_errors.md:41 #: src/error/multiple_error_types/reenter_question_mark.md:53 #: src/error/multiple_error_types/wrap_error.md:66 msgid "\"The first doubled is {}\"" msgstr "\"第一个数的两倍是 {}\"" #: src/error/multiple_error_types.md:29 #: src/error/multiple_error_types/option_result.md:23 msgid "// Error 1: the input vector is empty\n" msgstr "// 错误 1：输入向量为空\n" #: src/error/multiple_error_types.md:32 #: src/error/multiple_error_types/option_result.md:26 msgid "// Error 2: the element doesn't parse to a number\n" msgstr "// 错误 2：元素无法解析为数字\n" #: src/error/multiple_error_types.md:36 msgid "" "Over the next sections, we'll see several strategies for handling these kind " "of problems." msgstr "在接下来的章节中，我们将探讨几种处理此类问题的策略。" #: src/error/multiple_error_types/option_result.md:3 msgid "" "The most basic way of handling mixed error types is to just embed them in " "each other." msgstr "处理混合错误类型最基本的方法是将它们相互嵌套。" #: src/error/multiple_error_types/option_result.md:20 #: src/error/multiple_error_types/option_result.md:22 #: src/error/multiple_error_types/option_result.md:25 #: src/error/multiple_error_types/option_result.md:49 #: src/error/multiple_error_types/option_result.md:50 #: src/error/multiple_error_types/option_result.md:51 msgid "\"The first doubled is {:?}\"" msgstr "\"第一个数的两倍是 {:?}\"" #: src/error/multiple_error_types/option_result.md:30 msgid "" "There are times when we'll want to stop processing on errors (like with [`?`]" "(../result/enter_question_mark.md)) but keep going when the `Option` is " "`None`. The `transpose` function comes in handy to swap the `Result` and " "`Option`." msgstr "" "有时我们希望在遇到错误时停止处理（例如使用 [`?`](../result/" "enter_question_mark.md)），但在 `Option` 为 `None` 时继续执行。这时 " "`transpose` 函数就派上用场了，它可以方便地交换 `Result` 和 `Option`。" #: src/error/multiple_error_types/define_error_type.md:3 msgid "" "Sometimes it simplifies the code to mask all of the different errors with a " "single type of error. We'll show this with a custom error." msgstr "" "有时，用单一类型的错误来掩盖所有不同的错误可以简化代码。我们将通过自定义错误" "来演示这一点。" #: src/error/multiple_error_types/define_error_type.md:6 msgid "" "Rust allows us to define our own error types. In general, a \"good\" error " "type:" msgstr "Rust 允许我们定义自己的错误类型。通常，一个\"好的\"错误类型应该：" #: src/error/multiple_error_types/define_error_type.md:8 msgid "Represents different errors with the same type" msgstr "用同一类型表示不同的错误" #: src/error/multiple_error_types/define_error_type.md:9 msgid "Presents nice error messages to the user" msgstr "向用户展示友好的错误消息" #: src/error/multiple_error_types/define_error_type.md:10 msgid "Is easy to compare with other types" msgstr "易于与其他类型进行比较" #: src/error/multiple_error_types/define_error_type.md:11 msgid "Good: `Err(EmptyVec)`" msgstr "好的示例：`Err(EmptyVec)`" #: src/error/multiple_error_types/define_error_type.md:12 msgid "" "Bad: `Err(\"Please use a vector with at least one element\".to_owned())`" msgstr "不好的示例：`Err(\"请使用至少包含一个元素的向量\".to_owned())`" #: src/error/multiple_error_types/define_error_type.md:13 msgid "Can hold information about the error" msgstr "能够保存错误的相关信息" #: src/error/multiple_error_types/define_error_type.md:14 msgid "Good: `Err(BadChar(c, position))`" msgstr "好的示例：`Err(BadChar(c, position))`" #: src/error/multiple_error_types/define_error_type.md:15 msgid "Bad: `Err(\"+ cannot be used here\".to_owned())`" msgstr "不好的示例：`Err(\"此处不能使用 +\".to_owned())`" #: src/error/multiple_error_types/define_error_type.md:16 msgid "Composes well with other errors" msgstr "能够与其他错误很好地组合" #: src/error/multiple_error_types/define_error_type.md:22 msgid "" "// Define our error types. These may be customized for our error handling " "cases.\n" "// Now we will be able to write our own errors, defer to an underlying " "error\n" "// implementation, or do something in between.\n" msgstr "" "// 定义我们的错误类型。这些可以根据我们的错误处理情况进行自定义。\n" "// 现在我们可以编写自己的错误，依赖底层的错误实现，\n" "// 或者在两者之间做一些处理。\n" #: src/error/multiple_error_types/define_error_type.md:28 msgid "" "// Generation of an error is completely separate from how it is displayed.\n" "// There's no need to be concerned about cluttering complex logic with the " "display style.\n" "//\n" "// Note that we don't store any extra info about the errors. This means we " "can't state\n" "// which string failed to parse without modifying our types to carry that " "information.\n" msgstr "" "// 错误的生成与其显示方式是完全分离的。\n" "// 无需担心显示样式会使复杂的逻辑变得混乱。\n" "//\n" "// 注意，我们没有存储关于错误的任何额外信息。这意味着如果不修改类型\n" "// 来携带相关信息，我们就无法指出具体是哪个字符串解析失败了。\n" #: src/error/multiple_error_types/define_error_type.md:36 #: src/error/multiple_error_types/boxing_errors.md:23 #: src/error/multiple_error_types/reenter_question_mark.md:37 msgid "\"invalid first item to double\"" msgstr "\"无效的第一个待加倍项\"" #: src/error/multiple_error_types/define_error_type.md:42 msgid "// Change the error to our new type.\n" msgstr "// 将错误更改为我们的新类型。\n" #: src/error/multiple_error_types/define_error_type.md:46 msgid "// Update to the new error type here also.\n" msgstr "// 这里也更新为新的错误类型。\n" #: src/error/multiple_error_types/boxing_errors.md:3 msgid "" "A way to write simple code while preserving the original errors is to [`Box`]" "(https://doc.rust-lang.org/std/boxed/struct.Box.html) them. The drawback is " "that the underlying error type is only known at runtime and not [statically " "determined](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-" "objects-perform-dynamic-dispatch)." msgstr "" "一种既能编写简洁代码又能保留原始错误信息的方法是使用 [`Box`](https://" "doc.rust-lang.org/std/boxed/struct.Box.html) 将它们装箱。这种方法的缺点是底层" "错误类型只能在运行时确定，而不是[静态确定](https://doc.rust-lang.org/book/" "ch17-02-trait-objects.html#trait-objects-perform-dynamic-dispatch)的。" #: src/error/multiple_error_types/boxing_errors.md:7 msgid "" "The stdlib helps in boxing our errors by having `Box` implement conversion " "from any type that implements the `Error` trait into the trait object " "`Box`, via [`From`](https://doc.rust-lang.org/std/convert/" "trait.From.html)." msgstr "" "标准库通过让 `Box` 实现从任何实现了 `Error` trait 的类型到 trait 对象 " "`Box` 的转换来帮助我们装箱错误，这是通过 [`From`](https://doc.rust-" "lang.org/std/convert/trait.From.html) 实现的。" #: src/error/multiple_error_types/boxing_errors.md:14 #: src/error/multiple_error_types/reenter_question_mark.md:28 msgid "// Change the alias to use `Box`.\n" msgstr "// 将别名改为使用 `Box`。\n" #: src/error/multiple_error_types/boxing_errors.md:31 #: src/error/multiple_error_types/boxing_errors.md:34 msgid "// Converts to Box\n" msgstr "// 转换为 Box\n" #: src/error/multiple_error_types/boxing_errors.md:59 msgid "" "[Dynamic dispatch](https://doc.rust-lang.org/book/ch17-02-trait-" "objects.html#trait-objects-perform-dynamic-dispatch) and [`Error` trait]" "(https://doc.rust-lang.org/std/error/trait.Error.html)" msgstr "" "[动态分发](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-" "objects-perform-dynamic-dispatch)和 [`Error` trait](https://doc.rust-" "lang.org/std/error/trait.Error.html)" #: src/error/multiple_error_types/reenter_question_mark.md:3 msgid "" "Notice in the previous example that our immediate reaction to calling " "`parse` is to `map` the error from a library error into a boxed error:" msgstr "" "注意在前面的例子中，我们对调用 `parse` 的直接反应是将库错误通过 `map` 转换为" "一个装箱的错误：" #: src/error/multiple_error_types/reenter_question_mark.md:12 msgid "" "Since this is a simple and common operation, it would be convenient if it " "could be elided. Alas, because `and_then` is not sufficiently flexible, it " "cannot. However, we can instead use `?`." msgstr "" "由于这是一个简单且常见的操作，如果能够省略就会很方便。可惜的是，由于 " "`and_then` 不够灵活，所以无法实现这一点。不过，我们可以使用 `?` 来替代。" #: src/error/multiple_error_types/reenter_question_mark.md:16 msgid "" "`?` was previously explained as either `unwrap` or `return Err(err)`. This " "is only mostly true. It actually means `unwrap` or `return " "Err(From::from(err))`. Since `From::from` is a conversion utility between " "different types, this means that if you `?` where the error is convertible " "to the return type, it will convert automatically." msgstr "" "之前我们将 `?` 解释为 `unwrap` 或 `return Err(err)`。这只是大致正确。实际上，" "它的含义是 `unwrap` 或 `return Err(From::from(err))`。由于 `From::from` 是不" "同类型之间的转换工具，这意味着如果你在错误可转换为返回类型的地方使用 `?`，它" "将自动进行转换。" #: src/error/multiple_error_types/reenter_question_mark.md:22 msgid "" "Here, we rewrite the previous example using `?`. As a result, the `map_err` " "will go away when `From::from` is implemented for our error type:" msgstr "" "在这里，我们使用 `?` 重写了前面的例子。当为我们的错误类型实现 `From::from` " "后，`map_err` 就不再需要了：" #: src/error/multiple_error_types/reenter_question_mark.md:42 msgid "" "// The same structure as before but rather than chain all `Results`\n" "// and `Options` along, we `?` to get the inner value out immediately.\n" msgstr "" "// 结构与之前相同，但不再链式处理所有的 `Result` 和 `Option`，\n" "// 而是使用 `?` 立即获取内部值。\n" #: src/error/multiple_error_types/reenter_question_mark.md:69 msgid "" "This is actually fairly clean now. Compared with the original `panic`, it is " "very similar to replacing the `unwrap` calls with `?` except that the return " "types are `Result`. As a result, they must be destructured at the top level." msgstr "" "现在代码变得相当简洁了。与原来使用 `panic` 的版本相比，这种方法非常类似于用 " "`?` 替换 `unwrap` 调用，只是返回类型变成了 `Result`。因此，需要在顶层对结果进" "行解构。" #: src/error/multiple_error_types/reenter_question_mark.md:76 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`?" "`](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" msgstr "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html)和[`?`运" "算符](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-" "question-mark-operator)" #: src/error/multiple_error_types/wrap_error.md:3 msgid "An alternative to boxing errors is to wrap them in your own error type." msgstr "除了将错误装箱外，另一种方法是将它们包装在你自定义的错误类型中。" #: src/error/multiple_error_types/wrap_error.md:16 msgid "" "// We will defer to the parse error implementation for their error.\n" " // Supplying extra info requires adding more data to the type.\n" msgstr "" "// 我们将使用解析错误的实现来处理它们的错误。\n" " // 提供额外信息需要向类型添加更多数据。\n" #: src/error/multiple_error_types/wrap_error.md:25 msgid "\"please use a vector with at least one element\"" msgstr "\"请使用至少包含一个元素的向量\"" #: src/error/multiple_error_types/wrap_error.md:26 msgid "" "// The wrapped error contains additional information and is available\n" " // via the source() method.\n" msgstr "// 包装的错误包含额外信息，可通过 source() 方法获取。\n" #: src/error/multiple_error_types/wrap_error.md:29 msgid "\"the provided string could not be parsed as int\"" msgstr "\"提供的字符串无法解析为整数\"" #: src/error/multiple_error_types/wrap_error.md:38 msgid "" "// The cause is the underlying implementation error type. Is implicitly\n" " // cast to the trait object `&error::Error`. This works because " "the\n" " // underlying type already implements the `Error` trait.\n" msgstr "" "// 错误原因是底层实现的错误类型。它被隐式地\n" " // 转换为 trait 对象 `&error::Error`。这是可行的，因为\n" " // 底层类型已经实现了 `Error` trait。\n" #: src/error/multiple_error_types/wrap_error.md:45 msgid "" "// Implement the conversion from `ParseIntError` to `DoubleError`.\n" "// This will be automatically called by `?` if a `ParseIntError`\n" "// needs to be converted into a `DoubleError`.\n" msgstr "" "// 实现从 `ParseIntError` 到 `DoubleError` 的转换。\n" "// 当需要将 `ParseIntError` 转换为 `DoubleError` 时，\n" "// `?` 运算符会自动调用这个转换。\n" #: src/error/multiple_error_types/wrap_error.md:57 msgid "" "// Here we implicitly use the `ParseIntError` implementation of `From` " "(which\n" " // we defined above) in order to create a `DoubleError`.\n" msgstr "" "// 这里我们隐式使用了 `ParseIntError` 的 `From` 实现（我们在上面定义的）\n" " // 来创建一个 `DoubleError`。\n" #: src/error/multiple_error_types/wrap_error.md:70 msgid "\" Caused by: {}\"" msgstr "\" 错误原因：{}\"" #: src/error/multiple_error_types/wrap_error.md:87 msgid "" "This adds a bit more boilerplate for handling errors and might not be needed " "in all applications. There are some libraries that can take care of the " "boilerplate for you." msgstr "" "这种方法增加了一些处理错误的样板代码，可能并非所有应用程序都需要。有一些库可" "以帮你处理这些样板代码。" #: src/error/multiple_error_types/wrap_error.md:93 msgid "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and " "[`Enums`](../../custom_types/enum.md)" msgstr "" "[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) 和[`枚" "举`](../../custom_types/enum.md)" #: src/error/multiple_error_types/wrap_error.md:95 msgid "" "[`Crates for handling errors`](https://crates.io/keywords/error-handling)" msgstr "[处理错误的 crate](https://crates.io/keywords/error-handling)" #: src/error/iter_result.md:3 msgid "An `Iter::map` operation might fail, for example:" msgstr "`Iter::map` 操作可能会失败，例如：" #: src/error/iter_result.md:12 src/error/iter_result.md:29 #: src/error/iter_result.md:65 msgid "\"Results: {:?}\"" msgstr "\"结果：{:?}\"" #: src/error/iter_result.md:16 msgid "Let's step through strategies for handling this." msgstr "让我们逐步介绍处理这种情况的策略。" #: src/error/iter_result.md:18 msgid "Ignore the failed items with `filter_map()`" msgstr "使用 `filter_map()` 忽略失败的项" #: src/error/iter_result.md:20 msgid "" "`filter_map` calls a function and filters out the results that are `None`." msgstr "`filter_map` 调用一个函数并过滤掉结果为 `None` 的项。" #: src/error/iter_result.md:33 msgid "Collect the failed items with `map_err()` and `filter_map()`" msgstr "使用 `map_err()` 和 `filter_map()` 收集失败的项" #: src/error/iter_result.md:35 msgid "" "`map_err` calls a function with the error, so by adding that to the previous " "`filter_map` solution we can save them off to the side while iterating." msgstr "" "`map_err` 会对错误调用一个函数，因此将其添加到之前的 `filter_map` 解决方案" "中，我们可以在迭代时将错误项保存到一旁。" #: src/error/iter_result.md:40 msgid "\"999\"" msgstr "\"999\"" #: src/error/iter_result.md:47 src/error/iter_result.md:80 #: src/error/iter_result.md:97 msgid "\"Numbers: {:?}\"" msgstr "\"数字：{:?}\"" #: src/error/iter_result.md:48 src/error/iter_result.md:81 #: src/error/iter_result.md:98 msgid "\"Errors: {:?}\"" msgstr "\"错误：{:?}\"" #: src/error/iter_result.md:52 msgid "Fail the entire operation with `collect()`" msgstr "使用 `collect()` 使整个操作失败" #: src/error/iter_result.md:54 msgid "" "`Result` implements `FromIterator` so that a vector of results " "(`Vec>`) can be turned into a result with a vector " "(`Result, E>`). Once an `Result::Err` is found, the iteration will " "terminate." msgstr "" "`Result` 实现了 `FromIterator` trait，因此结果的向量（`Vec>`）可" "以转换为包含向量的结果（`Result, E>`）。一旦遇到 `Result::Err`，迭代就" "会终止。" #: src/error/iter_result.md:69 msgid "This same technique can be used with `Option`." msgstr "这种技巧同样适用于 `Option`。" #: src/error/iter_result.md:71 msgid "Collect all valid values and failures with `partition()`" msgstr "使用 `partition()` 收集所有有效值和失败项" #: src/error/iter_result.md:85 msgid "" "When you look at the results, you'll note that everything is still wrapped " "in `Result`. A little more boilerplate is needed for this." msgstr "" "当你查看结果时，你会注意到所有内容仍然被包装在 `Result` 中。这需要一些额外的" "样板代码。" #: src/std.md:3 msgid "" "The `std` library provides many custom types which expands drastically on " "the `primitives`. Some of these include:" msgstr "`std` 库提供了许多自定义类型，大大扩展了\"原生类型\"的功能。其中包括：" #: src/std.md:6 msgid "growable `String`s like: `\"hello world\"`" msgstr "可增长的 `String`，例如：`\"hello world\"`" #: src/std.md:7 msgid "growable vectors: `[1, 2, 3]`" msgstr "可增长的向量（vector）：`[1, 2, 3]`" #: src/std.md:8 msgid "optional types: `Option`" msgstr "可选类型：`Option`" #: src/std.md:9 msgid "error handling types: `Result`" msgstr "错误处理类型：`Result`" #: src/std.md:10 msgid "heap allocated pointers: `Box`" msgstr "堆分配的指针：`Box`" #: src/std.md:14 src/std_misc.md:14 msgid "" "[primitives](primitives.md) and [the std library](https://doc.rust-lang.org/" "std/)" msgstr "[原生类型](primitives.md)和[标准库](https://doc.rust-lang.org/std/)" #: src/std/box.md:3 msgid "" "All values in Rust are stack allocated by default. Values can be _boxed_ " "(allocated on the heap) by creating a `Box`. A box is a smart pointer to " "a heap allocated value of type `T`. When a box goes out of scope, its " "destructor is called, the inner object is destroyed, and the memory on the " "heap is freed." msgstr "" "在 Rust 中，所有值默认都是栈分配的。通过创建 `Box`，可以将值**装箱**（在堆" "上分配）。Box 是指向堆分配的 `T` 类型值的智能指针。当 Box 离开作用域时，会调" "用其析构函数，内部对象被销毁，堆上的内存被释放。" #: src/std/box.md:8 msgid "" "Boxed values can be dereferenced using the `*` operator; this removes one " "layer of indirection." msgstr "可以使用 `*` 运算符解引用装箱的值，这会移除一层间接引用。" #: src/std/box.md:20 msgid "" "// A Rectangle can be specified by where its top left and bottom right\n" "// corners are in space\n" msgstr "// 可以通过指定左上角和右下角在空间中的位置来定义矩形\n" #: src/std/box.md:34 msgid "// Allocate this point on the heap, and return a pointer to it\n" msgstr "// 在堆上分配这个点，并返回指向它的指针\n" #: src/std/box.md:39 msgid "" "// (all the type annotations are superfluous)\n" " // Stack allocated variables\n" msgstr "" "// （所有的类型标注都不是必须的）\n" " // 栈分配的变量\n" #: src/std/box.md:47 msgid "// Heap allocated rectangle\n" msgstr "// 堆分配的矩形\n" #: src/std/box.md:53 msgid "// The output of functions can be boxed\n" msgstr "// 函数的输出可以被装箱\n" #: src/std/box.md:56 msgid "// Double indirection\n" msgstr "// 双重间接引用\n" #: src/std/box.md:59 msgid "\"Point occupies {} bytes on the stack\"" msgstr "\"Point 在栈上占用 {} 字节\"" #: src/std/box.md:61 msgid "\"Rectangle occupies {} bytes on the stack\"" msgstr "\"Rectangle 在栈上占用 {} 字节\"" #: src/std/box.md:64 msgid "// box size == pointer size\n" msgstr "// box 大小 == 指针大小\n" #: src/std/box.md:65 msgid "\"Boxed point occupies {} bytes on the stack\"" msgstr "\"装箱的 point 在栈上占用 {} 字节\"" #: src/std/box.md:67 msgid "\"Boxed rectangle occupies {} bytes on the stack\"" msgstr "\"装箱的 rectangle 在栈上占用 {} 字节\"" #: src/std/box.md:69 msgid "\"Boxed box occupies {} bytes on the stack\"" msgstr "\"装箱的 box 在栈上占用 {} 字节\"" #: src/std/box.md:72 msgid "// Copy the data contained in `boxed_point` into `unboxed_point`\n" msgstr "// 将 `boxed_point` 中的数据复制到 `unboxed_point`\n" #: src/std/box.md:74 msgid "\"Unboxed point occupies {} bytes on the stack\"" msgstr "\"未装箱的 point 在栈上占用 {} 字节\"" #: src/std/vec.md:3 msgid "" "Vectors are re-sizable arrays. Like slices, their size is not known at " "compile time, but they can grow or shrink at any time. A vector is " "represented using 3 parameters:" msgstr "" "向量（Vector）是可调整大小的数组。与切片（Slice）类似，它们的大小在编译时是未" "知的，但可以随时增长或缩小。向量由 3 个参数表示：" #: src/std/vec.md:7 msgid "pointer to the data" msgstr "指向数据的指针" #: src/std/vec.md:8 msgid "length" msgstr "长度" #: src/std/vec.md:9 msgid "capacity" msgstr "容量" #: src/std/vec.md:11 msgid "" "The capacity indicates how much memory is reserved for the vector. The " "vector can grow as long as the length is smaller than the capacity. When " "this threshold needs to be surpassed, the vector is reallocated with a " "larger capacity." msgstr "" "容量表示为向量预留的内存量。只要长度小于容量，向量就可以增长。当需要超过这个" "阈值时，向量会被重新分配更大的容量。" #: src/std/vec.md:17 msgid "// Iterators can be collected into vectors\n" msgstr "// 迭代器可以被收集到向量中\n" #: src/std/vec.md:19 msgid "\"Collected (0..10) into: {:?}\"" msgstr "\"将 (0..10) 收集到：{:?}\"" #: src/std/vec.md:21 msgid "// The `vec!` macro can be used to initialize a vector\n" msgstr "// 可以使用 `vec!` 宏初始化向量\n" #: src/std/vec.md:23 msgid "\"Initial vector: {:?}\"" msgstr "\"初始向量：{:?}\"" #: src/std/vec.md:25 msgid "// Insert new element at the end of the vector\n" msgstr "// 在向量末尾插入新元素\n" #: src/std/vec.md:26 msgid "\"Push 4 into the vector\"" msgstr "\"将 4 推入向量\"" #: src/std/vec.md:28 msgid "\"Vector: {:?}\"" msgstr "\"向量：{:?}\"" #: src/std/vec.md:30 msgid "// Error! Immutable vectors can't grow\n" msgstr "// 错误！不可变向量无法增长\n" #: src/std/vec.md:34 msgid "" "// The `len` method yields the number of elements currently stored in a " "vector\n" msgstr "// `len` 方法返回当前存储在向量中的元素数量\n" #: src/std/vec.md:35 msgid "\"Vector length: {}\"" msgstr "\"向量长度：{}\"" #: src/std/vec.md:37 msgid "// Indexing is done using the square brackets (indexing starts at 0)\n" msgstr "// 使用方括号进行索引（索引从 0 开始）\n" #: src/std/vec.md:38 msgid "\"Second element: {}\"" msgstr "\"第二个元素：{}\"" #: src/std/vec.md:40 msgid "// `pop` removes the last element from the vector and returns it\n" msgstr "// `pop` 移除并返回向量的最后一个元素\n" #: src/std/vec.md:41 msgid "\"Pop last element: {:?}\"" msgstr "\"弹出最后一个元素：{:?}\"" #: src/std/vec.md:43 msgid "// Out of bounds indexing yields a panic\n" msgstr "// 越界索引会导致 panic\n" #: src/std/vec.md:44 msgid "\"Fourth element: {}\"" msgstr "\"第四个元素：{}\"" #: src/std/vec.md:47 msgid "// `Vector`s can be easily iterated over\n" msgstr "// 可以轻松地遍历 `Vector`\n" #: src/std/vec.md:48 msgid "\"Contents of xs:\"" msgstr "\"xs 的内容：\"" #: src/std/vec.md:53 msgid "" "// A `Vector` can also be iterated over while the iteration\n" " // count is enumerated in a separate variable (`i`)\n" msgstr "" "// 遍历 `Vector` 时，可以同时用一个单独的变量（`i`）\n" " // 来枚举迭代计数\n" #: src/std/vec.md:56 msgid "\"In position {} we have value {}\"" msgstr "\"在位置 {} 的值是 {}\"" #: src/std/vec.md:59 msgid "" "// Thanks to `iter_mut`, mutable `Vector`s can also be iterated\n" " // over in a way that allows modifying each value\n" msgstr "" "// 借助 `iter_mut`，可变的 `Vector` 也可以被遍历，\n" " // 并且允许修改每个值\n" #: src/std/vec.md:64 msgid "\"Updated vector: {:?}\"" msgstr "\"更新后的向量：{:?}\"" #: src/std/vec.md:68 msgid "" "More `Vec` methods can be found under the [std::vec](https://doc.rust-" "lang.org/std/vec/) module" msgstr "" "更多 `Vec` 方法可以在 [std::vec](https://doc.rust-lang.org/std/vec/) 模块中找" "到" #: src/std/str.md:3 msgid "The two most used string types in Rust are `String` and `&str`." msgstr "Rust 中最常用的两种字符串类型是 `String` 和 `&str`。" #: src/std/str.md:5 msgid "" "A `String` is stored as a vector of bytes (`Vec`), but guaranteed to " "always be a valid UTF-8 sequence. `String` is heap allocated, growable and " "not null terminated." msgstr "" "`String` 存储为字节向量（`Vec`），但保证始终是有效的 UTF-8 序列。" "`String` 在堆上分配，可增长，且不以 null 结尾。" #: src/std/str.md:9 msgid "" "`&str` is a slice (`&[u8]`) that always points to a valid UTF-8 sequence, " "and can be used to view into a `String`, just like `&[T]` is a view into " "`Vec`." msgstr "" "`&str` 是一个切片（`&[u8]`），它始终指向一个有效的 UTF-8 序列，可以用来查看 " "`String`，就像 `&[T]` 是 `Vec` 的一个视图一样。" #: src/std/str.md:14 msgid "" "// (all the type annotations are superfluous)\n" " // A reference to a string allocated in read only memory\n" msgstr "" "// （所有的类型注解都不是必须的）\n" " // 一个指向只读内存中分配的字符串的引用\n" #: src/std/str.md:16 msgid "\"the quick brown fox jumps over the lazy dog\"" msgstr "\"敏捷的棕色狐狸跳过懒惰的狗\"" #: src/std/str.md:17 msgid "\"Pangram: {}\"" msgstr "\"全字母句：{}\"" #: src/std/str.md:19 msgid "// Iterate over words in reverse, no new string is allocated\n" msgstr "// 反向遍历单词，不会分配新的字符串\n" #: src/std/str.md:20 msgid "\"Words in reverse\"" msgstr "\"单词逆序\"" #: src/std/str.md:25 msgid "// Copy chars into a vector, sort and remove duplicates\n" msgstr "// 将字符复制到向量中，排序并去重\n" #: src/std/str.md:30 msgid "// Create an empty and growable `String`\n" msgstr "// 创建一个空的、可增长的 `String`\n" #: src/std/str.md:33 msgid "// Insert a char at the end of string\n" msgstr "// 在字符串末尾插入一个字符\n" #: src/std/str.md:35 msgid "// Insert a string at the end of string\n" msgstr "// 在字符串末尾追加另一个字符串\n" #: src/std/str.md:39 msgid "" "// The trimmed string is a slice to the original string, hence no new\n" " // allocation is performed\n" msgstr "// 修剪后的字符串是原始字符串的一个切片，因此不会进行新的内存分配\n" #: src/std/str.md:43 msgid "\"Used characters: {}\"" msgstr "\"使用的字符：{}\"" #: src/std/str.md:45 msgid "// Heap allocate a string\n" msgstr "// 在堆上分配一个字符串\n" #: src/std/str.md:46 msgid "\"I like dogs\"" msgstr "\"我喜欢狗\"" #: src/std/str.md:47 msgid "// Allocate new memory and store the modified string there\n" msgstr "// 分配新的内存并在其中存储修改后的字符串\n" #: src/std/str.md:48 msgid "\"dog\"" msgstr "\"狗\"" #: src/std/str.md:48 msgid "\"cat\"" msgstr "\"猫\"" #: src/std/str.md:50 msgid "\"Alice says: {}\"" msgstr "\"爱丽丝说：{}\"" #: src/std/str.md:51 msgid "\"Bob says: {}\"" msgstr "\"鲍勃说：{}\"" #: src/std/str.md:55 msgid "" "More `str`/`String` methods can be found under the [std::str](https://" "doc.rust-lang.org/std/str/) and [std::string](https://doc.rust-lang.org/std/" "string/) modules" msgstr "" "更多 `str` 和 `String` 的方法可以在 [std::str](https://doc.rust-lang.org/std/" "str/) 和 [std::string](https://doc.rust-lang.org/std/string/) 模块中找到" #: src/std/str.md:60 msgid "Literals and escapes" msgstr "字面值和转义字符" #: src/std/str.md:62 msgid "" "There are multiple ways to write string literals with special characters in " "them. All result in a similar `&str` so it's best to use the form that is " "the most convenient to write. Similarly there are multiple ways to write " "byte string literals, which all result in `&[u8; N]`." msgstr "" "有多种方式可以编写包含特殊字符的字符串字面值。所有方式都会产生类似的 `&str`，" "因此最好使用最方便编写的形式。同样，也有多种方式可以编写字节字符串字面值，它" "们都会产生 `&[u8; N]` 类型。" #: src/std/str.md:67 msgid "" "Generally special characters are escaped with a backslash character: `\\`. " "This way you can add any character to your string, even unprintable ones and " "ones that you don't know how to type. If you want a literal backslash, " "escape it with another one: `\\\\`" msgstr "" "通常，特殊字符用反斜杠（`\\`）进行转义。这样你可以在字符串中添加任何字符，包" "括不可打印的字符和你不知道如何输入的字符。如果你想要一个字面的反斜杠，用另一" "个反斜杠转义它：`\\\\`" #: src/std/str.md:72 msgid "" "String or character literal delimiters occurring within a literal must be " "escaped: `\"\\\"\"`, `'\\''`." msgstr "" "出现在字面值内的字符串或字符字面值分隔符必须被转义：`\"\\\"\"` 和 `'\\''`。" #: src/std/str.md:76 msgid "// You can use escapes to write bytes by their hexadecimal values...\n" msgstr "// 你可以使用转义来通过十六进制值写入字节...\n" #: src/std/str.md:77 msgid "\"I'm writing \\x52\\x75\\x73\\x74!\"" msgstr "\"我正在写 \\x52\\x75\\x73\\x74！\"" #: src/std/str.md:78 msgid "\"What are you doing\\x3F (\\\\x3F means ?) {}\"" msgstr "\"你在做什么\\x3F（\\\\x3F 表示 ?）{}\"" #: src/std/str.md:80 msgid "// ...or Unicode code points.\n" msgstr "// ...或 Unicode 码点。\n" #: src/std/str.md:81 msgid "\"\\u{211D}\"" msgstr "\"\\u{211D}\"" #: src/std/str.md:82 msgid "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\"" msgstr "\"\\\"双线大写 R\\\"\"" #: src/std/str.md:84 msgid "\"Unicode character {} (U+211D) is called {}\"" msgstr "\"Unicode 字符 {} (U+211D) 被称为 {}\"" #: src/std/str.md:88 msgid "" "\"String literals\n" " can span multiple lines.\n" " The linebreak and indentation here ->\\\n" " <- can be escaped too!\"" msgstr "" "\"字符串字面值\n" " 可以跨越多行。\n" " 这里的换行和缩进 ->\\\n" " <- 也可以被转义！\"" #: src/std/str.md:96 msgid "" "Sometimes there are just too many characters that need to be escaped or it's " "just much more convenient to write a string out as-is. This is where raw " "string literals come into play." msgstr "" "有时需要转义的字符太多，或者直接按原样写出字符串会更方便。这时就可以使用原始" "字符串字面值。" #: src/std/str.md:101 msgid "r\"Escapes don't work here: \\x3F \\u{211D}\"" msgstr "r\"转义在这里不起作用：\\x3F \\u{211D}\"" #: src/std/str.md:104 msgid "// If you need quotes in a raw string, add a pair of #s\n" msgstr "// 如果你需要在原始字符串中使用引号，可以添加一对 #\n" #: src/std/str.md:105 msgid "r#\"And then I said: \"There is no escape!\"\"#" msgstr "r#\"然后我说：\"无处可逃！\"\"#" #: src/std/str.md:108 msgid "" "// If you need \"# in your string, just use more #s in the delimiter.\n" " // You can use up to 255 #s.\n" msgstr "" "// 如果你需要在字符串中使用 \"#，只需在分隔符中使用更多的 #。\n" " // 你最多可以使用 255 个 #。\n" #: src/std/str.md:110 msgid "r###\"A string with \"# in it. And even \"##!\"###" msgstr "r###\"一个包含 \"# 的字符串。甚至还有 \"##！\"###" #: src/std/str.md:115 msgid "" "Want a string that's not UTF-8? (Remember, `str` and `String` must be valid " "UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings " "to the rescue!" msgstr "" "想要一个非 UTF-8 的字符串吗？（请记住，`str` 和 `String` 必须是有效的 " "UTF-8）。或者你想要一个主要是文本的字节数组？字节字符串来帮忙！" #: src/std/str.md:122 msgid "// Note that this is not actually a `&str`\n" msgstr "// 注意，这实际上不是一个 `&str`\n" #: src/std/str.md:123 msgid "b\"this is a byte string\"" msgstr "b\"这是一个字节字符串\"" #: src/std/str.md:125 msgid "" "// Byte arrays don't have the `Display` trait, so printing them is a bit " "limited\n" msgstr "// 字节数组没有 `Display` trait，所以打印它们有一些限制\n" #: src/std/str.md:126 msgid "\"A byte string: {:?}\"" msgstr "\"一个字节字符串：{:?}\"" #: src/std/str.md:128 msgid "// Byte strings can have byte escapes...\n" msgstr "// 字节字符串可以包含字节转义...\n" #: src/std/str.md:129 msgid "b\"\\x52\\x75\\x73\\x74 as bytes\"" msgstr "b\"\\x52\\x75\\x73\\x74 作为字节\"" #: src/std/str.md:130 msgid "" "// ...but no unicode escapes\n" " // let escaped = b\"\\u{211D} is not allowed\";\n" msgstr "" "// ...但不允许 Unicode 转义\n" " // let escaped = b\"\\u{211D} 是不允许的\";\n" #: src/std/str.md:132 msgid "\"Some escaped bytes: {:?}\"" msgstr "\"一些转义的字节：{:?}\"" #: src/std/str.md:135 msgid "// Raw byte strings work just like raw strings\n" msgstr "// 原始字节字符串的工作方式与原始字符串相同\n" #: src/std/str.md:136 msgid "br\"\\u{211D} is not escaped here\"" msgstr "br\"\\u{211D} 在这里不会被转义\"" #: src/std/str.md:139 msgid "// Converting a byte array to `str` can fail\n" msgstr "// 将字节数组转换为 `str` 可能会失败\n" #: src/std/str.md:141 msgid "\"And the same as text: '{}'\"" msgstr "\"作为文本的相同内容：'{}'\"" #: src/std/str.md:144 msgid "" "br#\"You can also use \"fancier\" formatting, \\\n" " like with normal raw strings\"#" msgstr "" "br#\"你也可以使用\"更花哨的\"格式，\\\n" " 就像普通的原始字符串一样\"#" #: src/std/str.md:147 msgid "// Byte strings don't have to be UTF-8\n" msgstr "// 字节字符串不必是 UTF-8 编码\n" #: src/std/str.md:148 msgid "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" msgstr "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\"" #: src/std/str.md:148 msgid "// \"ようこそ\" in SHIFT-JIS\n" msgstr "// SHIFT-JIS 编码的 \"ようこそ\"\n" #: src/std/str.md:150 msgid "// But then they can't always be converted to `str`\n" msgstr "// 但它们并不总是能被转换为 `str`\n" #: src/std/str.md:152 msgid "\"Conversion successful: '{}'\"" msgstr "\"转换成功：'{}'\"" #: src/std/str.md:153 msgid "\"Conversion failed: {:?}\"" msgstr "\"转换失败：{:?}\"" #: src/std/str.md:158 msgid "" "For conversions between character encodings check out the [encoding](https://" "crates.io/crates/encoding) crate." msgstr "" "对于字符编码之间的转换，请查看 [encoding](https://crates.io/crates/encoding) " "crate。" #: src/std/str.md:160 msgid "" "A more detailed listing of the ways to write string literals and escape " "characters is given in the ['Tokens' chapter](https://doc.rust-lang.org/" "reference/tokens.html) of the Rust Reference." msgstr "" "关于编写字符串字面值和转义字符的更详细说明，请参阅 Rust 参考手册的[「标记」章" "节](https://doc.rust-lang.org/reference/tokens.html)。" #: src/std/option.md:3 msgid "" "Sometimes it's desirable to catch the failure of some parts of a program " "instead of calling `panic!`; this can be accomplished using the `Option` " "enum." msgstr "" "有时我们希望捕获程序某些部分的失败，而不是调用 `panic!`。这可以通过使用 " "`Option` 枚举来实现。" #: src/std/option.md:6 msgid "The `Option` enum has two variants:" msgstr "`Option` 枚举有两个变体：" #: src/std/option.md:8 msgid "`None`, to indicate failure or lack of value, and" msgstr "`None`：表示失败或缺少值，以及" #: src/std/option.md:9 msgid "`Some(value)`, a tuple struct that wraps a `value` with type `T`." msgstr "`Some(value)`：一个元组结构体，包装了类型为 `T` 的 `value`。" #: src/std/option.md:12 msgid "// An integer division that doesn't `panic!`\n" msgstr "// 一个不会触发 `panic!` 的整数除法\n" #: src/std/option.md:15 msgid "// Failure is represented as the `None` variant\n" msgstr "// 失败用 `None` 变体表示\n" #: src/std/option.md:18 msgid "// Result is wrapped in a `Some` variant\n" msgstr "// 结果被包装在 `Some` 变体中\n" #: src/std/option.md:22 msgid "// This function handles a division that may not succeed\n" msgstr "// 这个函数处理可能不成功的除法运算\n" #: src/std/option.md:25 msgid "// `Option` values can be pattern matched, just like other enums\n" msgstr "// `Option` 值可以进行模式匹配，就像其他枚举一样\n" #: src/std/option.md:27 msgid "\"{} / {} failed!\"" msgstr "\"{} / {} 失败！\"" #: src/std/option.md:29 msgid "\"{} / {} = {}\"" msgstr "\"{} / {} = {}\"" #: src/std/option.md:38 msgid "// Binding `None` to a variable needs to be type annotated\n" msgstr "// 将 `None` 绑定到变量时需要进行类型注解\n" #: src/std/option.md:44 msgid "// Unwrapping a `Some` variant will extract the value wrapped.\n" msgstr "// 解包 `Some` 变体将提取其中包装的值。\n" #: src/std/option.md:45 src/std/option.md:48 msgid "\"{:?} unwraps to {:?}\"" msgstr "\"{:?} 解包后得到 {:?}\"" #: src/std/option.md:47 msgid "// Unwrapping a `None` variant will `panic!`\n" msgstr "// 解包 `None` 变体将触发 `panic!`\n" #: src/std/result.md:3 msgid "" "We've seen that the `Option` enum can be used as a return value from " "functions that may fail, where `None` can be returned to indicate failure. " "However, sometimes it is important to express _why_ an operation failed. To " "do this we have the `Result` enum." msgstr "" "我们已经看到 `Option` 枚举可以用作可能失败的函数的返回值，其中 `None` 用于表" "示失败。\n" "然而，有时表达操作失败的**原因**很重要。为此，我们有 `Result` 枚举。" #: src/std/result.md:8 msgid "The `Result` enum has two variants:" msgstr "`Result` 枚举有两个变体：" #: src/std/result.md:10 msgid "" "`Ok(value)` which indicates that the operation succeeded, and wraps the " "`value` returned by the operation. (`value` has type `T`)" msgstr "" "`Ok(value)`：表示操作成功，并包装了操作返回的 `value`。（`value` 的类型为 " "`T`）" #: src/std/result.md:12 msgid "" "`Err(why)`, which indicates that the operation failed, and wraps `why`, " "which (hopefully) explains the cause of the failure. (`why` has type `E`)" msgstr "" "`Err(why)`：表示操作失败，并包装了 `why`，它（希望）解释了失败的原因。" "（`why` 的类型为 `E`）" #: src/std/result.md:17 msgid "// Mathematical \"errors\" we want to catch\n" msgstr "// 我们想要捕获的数学\"错误\"\n" #: src/std/result.md:29 msgid "" "// This operation would `fail`, instead let's return the reason of\n" " // the failure wrapped in `Err`\n" msgstr "// 这个操作会\"失败\"，所以我们返回包装在 `Err` 中的失败原因\n" #: src/std/result.md:33 msgid "// This operation is valid, return the result wrapped in `Ok`\n" msgstr "// 这个操作是有效的，返回包装在 `Ok` 中的结果\n" #: src/std/result.md:54 msgid "// `op(x, y)` === `sqrt(ln(x / y))`\n" msgstr "// `op(x, y)` === `sqrt(ln(x / y))`\n" #: src/std/result.md:57 msgid "// This is a three level match pyramid!\n" msgstr "// 这是一个三层的匹配金字塔！\n" #: src/std/result.md:71 msgid "// Will this fail?\n" msgstr "// 这会失败吗？\n" #: src/std/result/question_mark.md:3 msgid "" "Chaining results using match can get pretty untidy; luckily, the `?` " "operator can be used to make things pretty again. `?` is used at the end of " "an expression returning a `Result`, and is equivalent to a match expression, " "where the `Err(err)` branch expands to an early `return " "Err(From::from(err))`, and the `Ok(ok)` branch expands to an `ok` expression." msgstr "" "使用 match 链式处理结果可能会变得相当混乱；幸运的是，我们可以使用 `?` 运算符" "来让代码变得整洁。`?` 运算符用在返回 `Result` 的表达式末尾，等效于一个 match " "表达式。在这个表达式中，`Err(err)` 分支会展开为提前返回的 `return " "Err(From::from(err))`，而 `Ok(ok)` 分支则展开为 `ok` 表达式。" #: src/std/result/question_mark.md:44 msgid "// Intermediate function\n" msgstr "// 中间函数\n" #: src/std/result/question_mark.md:46 msgid "// if `div` \"fails\", then `DivisionByZero` will be `return`ed\n" msgstr "// 如果 `div` \"失败\"，则会 `return` `DivisionByZero`\n" #: src/std/result/question_mark.md:49 msgid "// if `ln` \"fails\", then `NonPositiveLogarithm` will be `return`ed\n" msgstr "// 如果 `ln` \"失败\"，则会 `return` `NonPositiveLogarithm`\n" #: src/std/result/question_mark.md:59 msgid "\"logarithm of non-positive number\"" msgstr "\"非正数的对数\"" #: src/std/result/question_mark.md:61 src/std/panic.md:15 msgid "\"division by zero\"" msgstr "\"除以零\"" #: src/std/result/question_mark.md:63 msgid "\"square root of negative number\"" msgstr "\"负数的平方根\"" #: src/std/result/question_mark.md:75 msgid "" "Be sure to check the [documentation](https://doc.rust-lang.org/std/result/" "index.html), as there are many methods to map/compose `Result`." msgstr "" "请务必查阅 [文档](https://doc.rust-lang.org/std/result/index.html)，其中包含" "了许多用于映射和组合 `Result` 的方法。" #: src/std/panic.md:3 msgid "" "The `panic!` macro can be used to generate a panic and start unwinding its " "stack. While unwinding, the runtime will take care of freeing all the " "resources _owned_ by the thread by calling the destructor of all its objects." msgstr "" "`panic!` 宏可用于生成一个 panic 并开始展开其栈。在展开过程中，运行时会通过调" "用该线程所有对象的析构函数来释放线程**拥有**的所有资源。" #: src/std/panic.md:7 msgid "" "Since we are dealing with programs with only one thread, `panic!` will cause " "the program to report the panic message and exit." msgstr "" "由于我们处理的是只有一个线程的程序，`panic!` 会导致程序报告 panic 消息并退" "出。" #: src/std/panic.md:11 msgid "// Re-implementation of integer division (/)\n" msgstr "// 重新实现整数除法（/）\n" #: src/std/panic.md:14 msgid "// Division by zero triggers a panic\n" msgstr "// 除以零会触发 panic\n" #: src/std/panic.md:20 msgid "// The `main` task\n" msgstr "// `main` 任务\n" #: src/std/panic.md:23 msgid "// Heap allocated integer\n" msgstr "// 堆分配的整数\n" #: src/std/panic.md:26 msgid "// This operation will trigger a task failure\n" msgstr "// 这个操作将触发任务失败\n" #: src/std/panic.md:29 msgid "\"This point won't be reached!\"" msgstr "\"这个点不会被执行到！\"" #: src/std/panic.md:31 msgid "// `_x` should get destroyed at this point\n" msgstr "// `_x` 应该在此处被销毁\n" #: src/std/panic.md:35 msgid "Let's check that `panic!` doesn't leak memory." msgstr "让我们验证 `panic!` 不会导致内存泄漏。" #: src/std/hash.md:3 msgid "" "Where vectors store values by an integer index, `HashMap`s store values by " "key. `HashMap` keys can be booleans, integers, strings, or any other type " "that implements the `Eq` and `Hash` traits. More on this in the next section." msgstr "" "向量（Vector）通过整数索引存储值，而 `HashMap` 则通过键存储值。`HashMap` 的键" "可以是布尔值、整数、字符串，或任何其他实现了 `Eq` 和 `Hash` trait 的类型。下" "一节将详细介绍这一点。" #: src/std/hash.md:8 msgid "" "Like vectors, `HashMap`s are growable, but HashMaps can also shrink " "themselves when they have excess space. You can create a HashMap with a " "certain starting capacity using `HashMap::with_capacity(uint)`, or use " "`HashMap::new()` to get a HashMap with a default initial capacity " "(recommended)." msgstr "" "与向量类似，`HashMap` 也可以增长，但当有多余空间时，HashMap 还能自动收缩。你" "可以使用 `HashMap::with_capacity(uint)` 创建一个具有指定初始容量的 HashMap，" "或使用 `HashMap::new()` 来获得一个具有默认初始容量的 HashMap（推荐）。" #: src/std/hash.md:19 src/std/hash.md:30 msgid "\"798-1364\"" msgstr "\"798-1364\"" #: src/std/hash.md:19 msgid "" "\"We're sorry, the call cannot be completed as dialed.\n" " Please hang up and try again.\"" msgstr "" "\"很抱歉，无法接通您拨打的电话。\n" " 请挂机后重试。\"" #: src/std/hash.md:21 src/std/hash.md:31 msgid "\"645-7689\"" msgstr "\"645-7689\"" #: src/std/hash.md:21 msgid "" "\"Hello, this is Mr. Awesome's Pizza. My name is Fred.\n" " What can I get for you today?\"" msgstr "" "\"您好，这里是 Awesome 先生的披萨店。我是 Fred。\n" " 请问今天您想点些什么？\"" #: src/std/hash.md:23 msgid "\"Hi! Who is this again?\"" msgstr "\"嗨！请问是哪位？\"" #: src/std/hash.md:30 src/std/hash.md:36 src/std/hash.md:43 msgid "\"Daniel\"" msgstr "\"Daniel\"" #: src/std/hash.md:31 src/std/hash.md:45 src/std/hash.md:50 msgid "\"Ashley\"" msgstr "\"Ashley\"" #: src/std/hash.md:32 msgid "\"Katie\"" msgstr "\"Katie\"" #: src/std/hash.md:32 msgid "\"435-8291\"" msgstr "\"435-8291\"" #: src/std/hash.md:33 msgid "\"Robert\"" msgstr "\"Robert\"" #: src/std/hash.md:33 msgid "\"956-1745\"" msgstr "\"956-1745\"" #: src/std/hash.md:35 msgid "// Takes a reference and returns Option<&V>\n" msgstr "// 接受一个引用并返回 Option<&V>\n" #: src/std/hash.md:37 msgid "\"Calling Daniel: {}\"" msgstr "\"正在呼叫 Daniel：{}\"" #: src/std/hash.md:38 msgid "\"Don't have Daniel's number.\"" msgstr "\"没有 Daniel 的电话号码。\"" #: src/std/hash.md:41 msgid "" "// `HashMap::insert()` returns `None`\n" " // if the inserted value is new, `Some(value)` otherwise\n" msgstr "" "// 如果插入的值是新的，`HashMap::insert()` 返回 `None`\n" " // 否则返回 `Some(value)`\n" #: src/std/hash.md:43 msgid "\"164-6743\"" msgstr "\"164-6743\"" #: src/std/hash.md:46 msgid "\"Calling Ashley: {}\"" msgstr "\"正在呼叫 Ashley：{}\"" #: src/std/hash.md:47 msgid "\"Don't have Ashley's number.\"" msgstr "\"没有 Ashley 的电话号码。\"" #: src/std/hash.md:52 msgid "" "// `HashMap::iter()` returns an iterator that yields\n" " // (&'a key, &'a value) pairs in arbitrary order.\n" msgstr "" "// `HashMap::iter()` 返回一个迭代器，该迭代器以任意顺序生成\n" " // (&'a key, &'a value) 键值对。\n" #: src/std/hash.md:55 msgid "\"Calling {}: {}\"" msgstr "\"正在呼叫{}：{}\"" #: src/std/hash.md:60 msgid "" "For more information on how hashing and hash maps (sometimes called hash " "tables) work, have a look at [Hash Table Wikipedia](https://en.wikipedia.org/" "wiki/Hash_table)" msgstr "" "要了解更多关于哈希和哈希映射（有时称为哈希表）的工作原理，请参阅[哈希表的维基" "百科页面](https://en.wikipedia.org/wiki/Hash_table)" #: src/std/hash/alt_key_types.md:3 msgid "" "Any type that implements the `Eq` and `Hash` traits can be a key in " "`HashMap`. This includes:" msgstr "" "任何实现了 `Eq` 和 `Hash` trait 的类型都可以作为 `HashMap` 的键。这包括：" #: src/std/hash/alt_key_types.md:6 msgid "`bool` (though not very useful since there are only two possible keys)" msgstr "`bool`（虽然用处不大，因为只有两个可能的键值）" #: src/std/hash/alt_key_types.md:7 msgid "`int`, `uint`, and all variations thereof" msgstr "`int`、`uint` 及其所有变体" #: src/std/hash/alt_key_types.md:8 msgid "" "`String` and `&str` (protip: you can have a `HashMap` keyed by `String` and " "call `.get()` with an `&str`)" msgstr "" "`String` 和 `&str`（专业提示：你可以使用 `String` 作为 `HashMap` 的键，并用 " "`&str` 调用 `.get()` 方法）" #: src/std/hash/alt_key_types.md:11 msgid "" "Note that `f32` and `f64` do _not_ implement `Hash`, likely because " "[floating-point precision errors](https://en.wikipedia.org/wiki/" "Floating_point#Accuracy_problems) would make using them as hashmap keys " "horribly error-prone." msgstr "" "注意，`f32` 和 `f64` **并未**实现 `Hash` trait，这很可能是因为[浮点数精度误" "差](https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems)会导致将它" "们用作哈希映射的键时极易出错。" #: src/std/hash/alt_key_types.md:15 msgid "" "All collection classes implement `Eq` and `Hash` if their contained type " "also respectively implements `Eq` and `Hash`. For example, `Vec` will " "implement `Hash` if `T` implements `Hash`." msgstr "" "如果集合类中包含的类型分别实现了 `Eq` 和 `Hash`，那么这些集合类也会实现 `Eq` " "和 `Hash`。例如，如果 `T` 实现了 `Hash`，那么 `Vec` 也会实现 `Hash`。" #: src/std/hash/alt_key_types.md:19 msgid "" "You can easily implement `Eq` and `Hash` for a custom type with just one " "line: `#[derive(PartialEq, Eq, Hash)]`" msgstr "" "你可以通过一行代码轻松地为自定义类型实现 `Eq` 和 `Hash`：" "`#[derive(PartialEq, Eq, Hash)]`" #: src/std/hash/alt_key_types.md:22 msgid "" "The compiler will do the rest. If you want more control over the details, " "you can implement `Eq` and/or `Hash` yourself. This guide will not cover the " "specifics of implementing `Hash`." msgstr "" "编译器会完成剩余的工作。如果你想对细节有更多控制，可以自己实现 `Eq` 和/或 " "`Hash`。本指南不会涉及实现 `Hash` 的具体细节。" #: src/std/hash/alt_key_types.md:26 msgid "" "To play around with using a `struct` in `HashMap`, let's try making a very " "simple user logon system:" msgstr "" "为了尝试在 `HashMap` 中使用 `struct`，让我们来创建一个非常简单的用户登录系" "统：" #: src/std/hash/alt_key_types.md:31 msgid "// Eq requires that you derive PartialEq on the type.\n" msgstr "// Eq 要求你在类型上派生 PartialEq。\n" #: src/std/hash/alt_key_types.md:48 msgid "\"Username: {}\"" msgstr "\"用户名：{}\"" #: src/std/hash/alt_key_types.md:49 msgid "\"Password: {}\"" msgstr "\"密码：{}\"" #: src/std/hash/alt_key_types.md:50 msgid "\"Attempting logon...\"" msgstr "\"正在尝试登录...\"" #: src/std/hash/alt_key_types.md:59 msgid "\"Successful logon!\"" msgstr "\"登录成功！\"" #: src/std/hash/alt_key_types.md:60 msgid "\"Name: {}\"" msgstr "\"姓名：{}\"" #: src/std/hash/alt_key_types.md:61 msgid "\"Email: {}\"" msgstr "\"电子邮箱：{}\"" #: src/std/hash/alt_key_types.md:63 msgid "\"Login failed!\"" msgstr "\"登录失败！\"" #: src/std/hash/alt_key_types.md:71 src/std/hash/alt_key_types.md:82 #: src/std/hash/alt_key_types.md:84 msgid "\"j.everyman\"" msgstr "\"j.everyman\"" #: src/std/hash/alt_key_types.md:72 src/std/hash/alt_key_types.md:84 msgid "\"password123\"" msgstr "\"password123\"" #: src/std/hash/alt_key_types.md:76 msgid "\"John Everyman\"" msgstr "\"John Everyman\"" #: src/std/hash/alt_key_types.md:77 msgid "\"j.everyman@email.com\"" msgstr "\"j.everyman@email.com\"" #: src/std/hash/alt_key_types.md:82 msgid "\"psasword123\"" msgstr "\"psasword123\"" #: src/std/hash/hashset.md:3 msgid "" "Consider a `HashSet` as a `HashMap` where we just care about the keys " "( `HashSet` is, in actuality, just a wrapper around `HashMap`)." msgstr "" "可以将 `HashSet` 视为一个只关心键的 `HashMap`（实际上，`HashSet` 只是 " "`HashMap` 的封装）。" #: src/std/hash/hashset.md:6 msgid "" "\"What's the point of that?\" you ask. \"I could just store the keys in a " "`Vec`.\"" msgstr "你可能会问：\"这有什么意义？我可以直接把键存储在 `Vec` 中啊。\"" #: src/std/hash/hashset.md:8 msgid "" "A `HashSet`'s unique feature is that it is guaranteed to not have duplicate " "elements. That's the contract that any set collection fulfills. `HashSet` is " "just one implementation. (see also: [`BTreeSet`](https://doc.rust-lang.org/" "std/collections/struct.BTreeSet.html))" msgstr "" "`HashSet` 的独特之处在于它保证不会有重复元素。这是所有集合类型都应满足的约" "定。`HashSet` 只是其中一种实现。（另请参阅：[`BTreeSet`](https://doc.rust-" "lang.org/std/collections/struct.BTreeSet.html)）" #: src/std/hash/hashset.md:13 msgid "" "If you insert a value that is already present in the `HashSet`, (i.e. the " "new value is equal to the existing and they both have the same hash), then " "the new value will replace the old." msgstr "" "如果你插入一个已存在于 `HashSet` 中的值（即新值等于现有值，且它们的哈希值相" "同），那么新值将替换旧值。" #: src/std/hash/hashset.md:17 msgid "" "This is great for when you never want more than one of something, or when " "you want to know if you've already got something." msgstr "" "当你不希望某个元素出现多次，或者想知道是否已经拥有某个元素时，这非常有用。" #: src/std/hash/hashset.md:20 msgid "But sets can do more than that." msgstr "但是集合的功能不仅限于此。" #: src/std/hash/hashset.md:22 msgid "" "Sets have 4 primary operations (all of the following calls return an " "iterator):" msgstr "集合有 4 种主要操作（以下所有调用都返回一个迭代器）：" #: src/std/hash/hashset.md:24 msgid "`union`: get all the unique elements in both sets." msgstr "并集（`union`）：获取两个集合中的所有唯一元素。" #: src/std/hash/hashset.md:26 msgid "" "`difference`: get all the elements that are in the first set but not the " "second." msgstr "" "差集（`difference`）：获取存在于第一个集合但不在第二个集合中的所有元素。" #: src/std/hash/hashset.md:28 msgid "`intersection`: get all the elements that are only in _both_ sets." msgstr "交集（`intersection`）：获取**同时**存在于两个集合中的所有元素。" #: src/std/hash/hashset.md:30 msgid "" "`symmetric_difference`: get all the elements that are in one set or the " "other, but _not_ both." msgstr "" "对称差（`symmetric_difference`）：获取存在于其中一个集合中，但**不**同时存在" "于两个集合中的所有元素。" #: src/std/hash/hashset.md:33 msgid "Try all of these in the following example:" msgstr "在下面的例子中尝试这些操作：" #: src/std/hash/hashset.md:45 msgid "" "// `HashSet::insert()` returns false if\n" " // there was a value already present.\n" msgstr "// 如果集合中已存在该值，`HashSet::insert()` 将返回 false。\n" #: src/std/hash/hashset.md:47 msgid "\"Value 4 is already in set B!\"" msgstr "\"值 4 已存在于集合 B 中！\"" #: src/std/hash/hashset.md:52 msgid "" "// If a collection's element type implements `Debug`,\n" " // then the collection implements `Debug`.\n" " // It usually prints its elements in the format `[elem1, elem2, ...]`\n" msgstr "" "// 如果集合的元素类型实现了 `Debug` 特征，\n" " // 那么该集合也会实现 `Debug` 特征。\n" " // 通常会以 `[elem1, elem2, ...]` 的格式打印其元素\n" #: src/std/hash/hashset.md:55 msgid "\"A: {:?}\"" msgstr "\"A：{:?}\"" #: src/std/hash/hashset.md:56 msgid "\"B: {:?}\"" msgstr "\"B：{:?}\"" #: src/std/hash/hashset.md:58 msgid "// Print [1, 2, 3, 4, 5] in arbitrary order\n" msgstr "// 以任意顺序打印 [1, 2, 3, 4, 5]\n" #: src/std/hash/hashset.md:59 msgid "\"Union: {:?}\"" msgstr "\"并集：{:?}\"" #: src/std/hash/hashset.md:61 msgid "// This should print [1]\n" msgstr "// 这里应该打印 [1]\n" #: src/std/hash/hashset.md:62 msgid "\"Difference: {:?}\"" msgstr "\"差集：{:?}\"" #: src/std/hash/hashset.md:64 msgid "// Print [2, 3, 4] in arbitrary order.\n" msgstr "// 以任意顺序打印 [2, 3, 4]\n" #: src/std/hash/hashset.md:65 msgid "\"Intersection: {:?}\"" msgstr "\"交集：{:?}\"" #: src/std/hash/hashset.md:67 msgid "// Print [1, 5]\n" msgstr "// 打印 [1, 5]\n" #: src/std/hash/hashset.md:68 msgid "\"Symmetric Difference: {:?}\"" msgstr "\"对称差：{:?}\"" #: src/std/hash/hashset.md:73 msgid "" "(Examples are adapted from the [documentation.](https://doc.rust-lang.org/" "std/collections/struct.HashSet.html#method.difference))" msgstr "" "（示例改编自[官方文档](https://doc.rust-lang.org/std/collections/" "struct.HashSet.html#method.difference)）" #: src/std/rc.md:3 msgid "" "When multiple ownership is needed, `Rc`(Reference Counting) can be used. " "`Rc` keeps track of the number of the references which means the number of " "owners of the value wrapped inside an `Rc`." msgstr "" "当需要多重所有权时，可以使用 `Rc`（引用计数，Reference Counting）。`Rc` 会跟" "踪引用的数量，即包裹在 `Rc` 内部的值的所有者数量。" #: src/std/rc.md:7 msgid "" "Reference count of an `Rc` increases by 1 whenever an `Rc` is cloned, and " "decreases by 1 whenever one cloned `Rc` is dropped out of the scope. When an " "`Rc`'s reference count becomes zero (which means there are no remaining " "owners), both the `Rc` and the value are all dropped." msgstr "" "每当克隆一个 `Rc` 时，其引用计数就会增加 1；每当一个克隆的 `Rc` 离开作用域" "时，引用计数就会减少 1。当 `Rc` 的引用计数变为零（意味着没有剩余的所有者）" "时，`Rc` 及其包含的值都会被丢弃。" #: src/std/rc.md:12 msgid "" "Cloning an `Rc` never performs a deep copy. Cloning creates just another " "pointer to the wrapped value, and increments the count." msgstr "" "克隆 `Rc` 从不执行深拷贝。克隆只是创建另一个指向被包裹值的指针，并增加计数。" #: src/std/rc.md:19 msgid "\"Rc examples\"" msgstr "\"Rc 示例\"" #: src/std/rc.md:21 msgid "\"--- rc_a is created ---\"" msgstr "\"--- rc_a 已创建 ---\"" #: src/std/rc.md:24 src/std/rc.md:31 src/std/rc.md:43 msgid "\"Reference Count of rc_a: {}\"" msgstr "\"rc_a 的引用计数：{}\"" #: src/std/rc.md:27 msgid "\"--- rc_a is cloned to rc_b ---\"" msgstr "\"--- rc_a 被克隆为 rc_b ---\"" #: src/std/rc.md:30 msgid "\"Reference Count of rc_b: {}\"" msgstr "\"rc_b 的引用计数：{}\"" #: src/std/rc.md:33 msgid "// Two `Rc`s are equal if their inner values are equal\n" msgstr "// 两个 `Rc` 如果内部值相等，则它们相等\n" #: src/std/rc.md:34 msgid "\"rc_a and rc_b are equal: {}\"" msgstr "\"rc_a 和 rc_b 是否相等：{}\"" #: src/std/rc.md:36 msgid "// We can use methods of a value directly\n" msgstr "// 我们可以直接使用值的方法\n" #: src/std/rc.md:37 msgid "\"Length of the value inside rc_a: {}\"" msgstr "\"rc_a 内部值的长度：{}\"" #: src/std/rc.md:38 msgid "\"Value of rc_b: {}\"" msgstr "\"rc_b 的值：{}\"" #: src/std/rc.md:40 msgid "\"--- rc_b is dropped out of scope ---\"" msgstr "\"--- rc_b 超出作用域被释放 ---\"" #: src/std/rc.md:45 msgid "\"--- rc_a is dropped out of scope ---\"" msgstr "\"--- rc_a 超出作用域被释放 ---\"" #: src/std/rc.md:48 msgid "" "// Error! `rc_examples` already moved into `rc_a`\n" " // And when `rc_a` is dropped, `rc_examples` is dropped together\n" " // println!(\"rc_examples: {}\", rc_examples);\n" " // TODO ^ Try uncommenting this line\n" msgstr "" "// 错误！`rc_examples` 已经被移动到 `rc_a` 中\n" " // 当 `rc_a` 被释放时，`rc_examples` 也会一同被释放\n" " // println!(\"rc_examples: {}\", rc_examples);\n" " // TODO：尝试取消注释上面这行\n" #: src/std/rc.md:57 msgid "" "[std::rc](https://doc.rust-lang.org/std/rc/index.html) and [std::sync::arc]" "(https://doc.rust-lang.org/std/sync/struct.Arc.html)." msgstr "" "[`std::rc`](https://doc.rust-lang.org/std/rc/index.html) 和 " "[`std::sync::arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html)。" #: src/std/arc.md:1 msgid "Arc" msgstr "Arc（原子引用计数）" #: src/std/arc.md:3 msgid "" "When shared ownership between threads is needed, `Arc`(Atomically Reference " "Counted) can be used. This struct, via the `Clone` implementation can create " "a reference pointer for the location of a value in the memory heap while " "increasing the reference counter. As it shares ownership between threads, " "when the last reference pointer to a value is out of scope, the variable is " "dropped." msgstr "" "当需要在线程间共享所有权时，可以使用 `Arc`（原子引用计数，Atomically " "Reference Counted）。通过 `Clone` 实现，这个结构体可以为堆内存中值的位置创建" "一个引用指针，同时增加引用计数。由于它在线程间共享所有权，当指向某个值的最后" "一个引用指针超出作用域时，该变量就会被释放。" #: src/std/arc.md:15 msgid "// This variable declaration is where its value is specified.\n" msgstr "// 在这个变量声明中指定了它的值。\n" #: src/std/arc.md:16 msgid "\"the same apple\"" msgstr "\"同一个苹果\"" #: src/std/arc.md:19 msgid "" "// Here there is no value specification as it is a pointer to a\n" " // reference in the memory heap.\n" msgstr "// 这里没有指定值，因为它是指向堆内存中引用的指针。\n" #: src/std/arc.md:24 msgid "" "// As Arc was used, threads can be spawned using the value allocated\n" " // in the Arc variable pointer's location.\n" msgstr "// 由于使用了 Arc，可以使用 Arc 变量指针所指向的值来生成线程。\n" #: src/std/arc.md:30 msgid "// Make sure all Arc instances are printed from spawned threads.\n" msgstr "// 确保所有 Arc 实例都从生成的线程中打印出来。\n" #: src/std_misc.md:3 msgid "" "Many other types are provided by the std library to support things such as:" msgstr "标准库提供了许多其他类型来支持各种功能，例如：" #: src/std_misc.md:10 msgid "These expand beyond what the [primitives](primitives.md) provide." msgstr "这些类型扩展了[基本类型](primitives.md)所提供的功能。" #: src/std_misc/threads.md:3 msgid "" "Rust provides a mechanism for spawning native OS threads via the `spawn` " "function, the argument of this function is a moving closure." msgstr "" "Rust 通过 `spawn` 函数提供了一种生成原生操作系统线程的机制，该函数的参数是一" "个移动闭包。" #: src/std_misc/threads.md:10 src/std_misc/threads/testcase_mapreduce.md:28 msgid "// This is the `main` thread\n" msgstr "// 这是主线程\n" #: src/std_misc/threads.md:13 msgid "// Make a vector to hold the children which are spawned.\n" msgstr "// 创建一个向量来存储生成的子线程\n" #: src/std_misc/threads.md:17 msgid "// Spin up another thread\n" msgstr "// 启动一个新线程\n" #: src/std_misc/threads.md:19 msgid "\"this is thread number {}\"" msgstr "\"这是第 {} 号线程\"" #: src/std_misc/threads.md:24 msgid "// Wait for the thread to finish. Returns a result.\n" msgstr "// 等待线程完成，返回一个结果\n" #: src/std_misc/threads.md:30 msgid "These threads will be scheduled by the OS." msgstr "这些线程将由操作系统进行调度。" #: src/std_misc/threads/testcase_mapreduce.md:3 msgid "" "Rust makes it very easy to parallelize data processing, without many of the " "headaches traditionally associated with such an attempt." msgstr "Rust 使并行数据处理变得非常简单，避免了传统并行处理中常见的诸多问题。" #: src/std_misc/threads/testcase_mapreduce.md:5 msgid "" "The standard library provides great threading primitives out of the box. " "These, combined with Rust's concept of Ownership and aliasing rules, " "automatically prevent data races." msgstr "" "标准库提供了开箱即用的优秀线程原语。这些原语结合 Rust 的所有权概念和别名规" "则，自动防止了数据竞争。" #: src/std_misc/threads/testcase_mapreduce.md:9 msgid "" "The aliasing rules (one writable reference XOR many readable references) " "automatically prevent you from manipulating state that is visible to other " "threads. (Where synchronization is needed, there are synchronization " "primitives like `Mutex`es or `Channel`s.)" msgstr "" "别名规则（一个可写引用异或多个可读引用）自动防止你操作对其他线程可见的状态。" "（在需要同步的情况下，可以使用 `Mutex` 或 `Channel` 等同步原语。）" #: src/std_misc/threads/testcase_mapreduce.md:14 msgid "" "In this example, we will calculate the sum of all digits in a block of " "numbers. We will do this by parcelling out chunks of the block into " "different threads. Each thread will sum its tiny block of digits, and " "subsequently we will sum the intermediate sums produced by each thread." msgstr "" "在这个例子中，我们将计算一个数字块中所有数字的总和。我们通过将数字块分成小块" "并分配给不同的线程来完成这个任务。每个线程将计算其小块数字的总和，随后我们将" "汇总每个线程产生的中间结果。" #: src/std_misc/threads/testcase_mapreduce.md:19 msgid "" "Note that, although we're passing references across thread boundaries, Rust " "understands that we're only passing read-only references, and that thus no " "unsafety or data races can occur. Also because the references we're passing " "have `'static` lifetimes, Rust understands that our data won't be destroyed " "while these threads are still running. (When you need to share non-`static` " "data between threads, you can use a smart pointer like `Arc` to keep the " "data alive and avoid non-`static` lifetimes.)" msgstr "" "注意，尽管我们在线程间传递引用，但 Rust 理解我们只是传递只读引用，因此不会发" "生不安全操作或数据竞争。此外，由于我们传递的引用具有 `'static` 生命周期，" "Rust 确保这些线程运行时数据不会被销毁。（当需要在线程间共享非 `static` 数据" "时，可以使用 `Arc` 等智能指针来保持数据存活并避免非 `static` 生命周期。）" #: src/std_misc/threads/testcase_mapreduce.md:32 msgid "" "// This is our data to process.\n" " // We will calculate the sum of all digits via a threaded map-reduce " "algorithm.\n" " // Each whitespace separated chunk will be handled in a different " "thread.\n" " //\n" " // TODO: see what happens to the output if you insert spaces!\n" msgstr "" "// 这是我们要处理的数据\n" " // 我们将通过一个线程化的 map-reduce 算法计算所有数字的总和\n" " // 每个由空格分隔的块将在不同的线程中处理\n" " //\n" " // TODO：试试插入空格会对输出有什么影响！\n" #: src/std_misc/threads/testcase_mapreduce.md:37 msgid "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" msgstr "" "\"86967897737416471853297327050364959\n" "11861322575564723963297542624962850\n" "70856234701860851907960690014725639\n" "38397966707106094172783238747669219\n" "52380795257888236525459303330302837\n" "58495327135744041048897885734297812\n" "69920216438980873548808413720956532\n" "16278424637452589860345374828574668\"" #: src/std_misc/threads/testcase_mapreduce.md:46 msgid "// Make a vector to hold the child-threads which we will spawn.\n" msgstr "// 创建一个向量来存储我们将要生成的子线程。\n" #: src/std_misc/threads/testcase_mapreduce.md:49 msgid "" "/*************************************************************************\n" " * \"Map\" phase\n" " *\n" " * Divide our data into segments, and apply initial processing\n" " ************************************************************************/" msgstr "" "/*************************************************************************\n" " * \"Map\"阶段\n" " *\n" " * 将数据分割成多个段，并进行初步处理\n" " ************************************************************************/" #: src/std_misc/threads/testcase_mapreduce.md:55 msgid "" "// split our data into segments for individual calculation\n" " // each chunk will be a reference (&str) into the actual data\n" msgstr "" "// 将数据分割成多个段以进行单独计算\n" " // 每个数据块都是指向实际数据的引用（&str）\n" #: src/std_misc/threads/testcase_mapreduce.md:59 msgid "" "// Iterate over the data segments.\n" " // .enumerate() adds the current loop index to whatever is iterated\n" " // the resulting tuple \"(index, element)\" is then immediately\n" " // \"destructured\" into two variables, \"i\" and \"data_segment\" with " "a\n" " // \"destructuring assignment\"\n" msgstr "" "// 遍历数据段\n" " // .enumerate() 为迭代的每个元素添加当前循环索引\n" " // 生成的元组\"(索引, 元素)\"随后立即通过\n" " // \"解构赋值\"被\"解构\"为两个变量：\"i\"和\"data_segment\"\n" " // \n" #: src/std_misc/threads/testcase_mapreduce.md:65 msgid "\"data segment {} is \\\"{}\\\"\"" msgstr "\"数据段 {} 是\\\"{}\\\"\"" #: src/std_misc/threads/testcase_mapreduce.md:67 msgid "" "// Process each data segment in a separate thread\n" " //\n" " // spawn() returns a handle to the new thread,\n" " // which we MUST keep to access the returned value\n" " //\n" " // 'move || -> u32' is syntax for a closure that:\n" " // * takes no arguments ('||')\n" " // * takes ownership of its captured variables ('move') and\n" " // * returns an unsigned 32-bit integer ('-> u32')\n" " //\n" " // Rust is smart enough to infer the '-> u32' from\n" " // the closure itself so we could have left that out.\n" " //\n" " // TODO: try removing the 'move' and see what happens\n" msgstr "" "// 在单独的线程中处理每个数据段\n" " //\n" " // spawn() 返回新线程的句柄，\n" " // 我们必须保留该句柄以访问返回值\n" " //\n" " // 'move || -> u32' 是一个闭包的语法，它：\n" " // * 不接受参数（'||'）\n" " // * 获取其捕获变量的所有权（'move'）\n" " // * 返回一个无符号 32 位整数（'-> u32'）\n" " //\n" " // Rust 足够智能，能从闭包本身推断出 '-> u32'，\n" " // 所以我们可以省略它。\n" " //\n" " // TODO：尝试移除 'move' 并观察结果\n" #: src/std_misc/threads/testcase_mapreduce.md:82 msgid "// Calculate the intermediate sum of this segment:\n" msgstr "// 计算此段的中间和：\n" #: src/std_misc/threads/testcase_mapreduce.md:84 msgid "// iterate over the characters of our segment..\n" msgstr "// 遍历此段中的字符...\n" #: src/std_misc/threads/testcase_mapreduce.md:86 msgid "// .. convert text-characters to their number value..\n" msgstr "// ...将文本字符转换为对应的数值...\n" #: src/std_misc/threads/testcase_mapreduce.md:87 msgid "\"should be a digit\"" msgstr "\"应该是一个数字\"" #: src/std_misc/threads/testcase_mapreduce.md:88 msgid "// .. and sum the resulting iterator of numbers\n" msgstr "// ...并对结果数字迭代器求和\n" #: src/std_misc/threads/testcase_mapreduce.md:91 msgid "// println! locks stdout, so no text-interleaving occurs\n" msgstr "// println! 会锁定标准输出，因此不会出现文本交错\n" #: src/std_misc/threads/testcase_mapreduce.md:92 msgid "\"processed segment {}, result={}\"" msgstr "\"已处理段 {}，结果={}\"" #: src/std_misc/threads/testcase_mapreduce.md:94 msgid "" "// \"return\" not needed, because Rust is an \"expression language\", the\n" " // last evaluated expression in each block is automatically its " "value.\n" msgstr "" "// 不需要使用 \"return\"，因为 Rust 是一种\"表达式语言\"，\n" "// 每个代码块中最后求值的表达式会自动成为该块的返回值。\n" #: src/std_misc/threads/testcase_mapreduce.md:102 msgid "" "/*************************************************************************\n" " * \"Reduce\" phase\n" " *\n" " * Collect our intermediate results, and combine them into a final " "result\n" " ************************************************************************/" msgstr "" "/*************************************************************************\n" " * \"归约\"阶段\n" " *\n" " * 收集中间结果，并将它们合并成最终结果\n" " ************************************************************************/" #: src/std_misc/threads/testcase_mapreduce.md:108 msgid "" "// combine each thread's intermediate results into a single final sum.\n" " //\n" " // we use the \"turbofish\" ::<> to provide sum() with a type hint.\n" " //\n" " // TODO: try without the turbofish, by instead explicitly\n" " // specifying the type of final_result\n" msgstr "" "// 将每个线程的中间结果合并成一个最终总和。\n" " //\n" " // 我们使用 \"turbofish\" ::<> 为 sum() 提供类型提示。\n" " //\n" " // TODO：尝试不使用 turbofish，而是显式\n" " // 指定 final_result 的类型\n" #: src/std_misc/threads/testcase_mapreduce.md:116 msgid "\"Final sum result: {}\"" msgstr "\"最终求和结果：{}\"" #: src/std_misc/threads/testcase_mapreduce.md:120 msgid "Assignments" msgstr "练习" #: src/std_misc/threads/testcase_mapreduce.md:122 msgid "" "It is not wise to let our number of threads depend on user inputted data. " "What if the user decides to insert a lot of spaces? Do we _really_ want to " "spawn 2,000 threads? Modify the program so that the data is always chunked " "into a limited number of chunks, defined by a static constant at the " "beginning of the program." msgstr "" "让线程数量依赖于用户输入的数据并不明智。如果用户决定插入大量空格，我们真的想" "要创建 2,000 个线程吗？修改程序，使数据始终被分割成固定数量的块，这个数量应由" "程序开头定义的静态常量来确定。" #: src/std_misc/threads/testcase_mapreduce.md:129 msgid "[Threads](../threads.md)" msgstr "[线程](../threads.md)" #: src/std_misc/threads/testcase_mapreduce.md:130 msgid "[vectors](../../std/vec.md) and [iterators](../../trait/iter.md)" msgstr "[向量](../../std/vec.md)和[迭代器](../../trait/iter.md)" #: src/std_misc/threads/testcase_mapreduce.md:131 msgid "" "[closures](../../fn/closures.md), [move](../../scope/move.md) semantics and " "[`move` closures](https://doc.rust-lang.org/book/ch13-01-" "closures.html#closures-can-capture-their-environment)" msgstr "" "[闭包](../../fn/closures.md)、[move](../../scope/move.md) 语义和 [`move` 闭" "包](https://doc.rust-lang.org/book/ch13-01-closures.html#closures-can-" "capture-their-environment)" #: src/std_misc/threads/testcase_mapreduce.md:132 msgid "" "[destructuring](https://doc.rust-lang.org/book/ch18-03-pattern-" "syntax.html#destructuring-to-break-apart-values) assignments" msgstr "" "[解构](https://doc.rust-lang.org/book/ch18-03-pattern-" "syntax.html#destructuring-to-break-apart-values)赋值" #: src/std_misc/threads/testcase_mapreduce.md:133 msgid "" "[turbofish notation](https://doc.rust-lang.org/book/appendix-02-" "operators.html?highlight=turbofish) to help type inference" msgstr "" "[涡轮鱼符号](https://doc.rust-lang.org/book/appendix-02-operators.html?" "highlight=turbofish)用于辅助类型推断" #: src/std_misc/threads/testcase_mapreduce.md:134 msgid "[unwrap vs. expect](../../error/option_unwrap.md)" msgstr "[unwrap 与 expect](../../error/option_unwrap.md)" #: src/std_misc/threads/testcase_mapreduce.md:135 msgid "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" msgstr "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)" #: src/std_misc/channels.md:3 msgid "" "Rust provides asynchronous `channels` for communication between threads. " "Channels allow a unidirectional flow of information between two end-points: " "the `Sender` and the `Receiver`." msgstr "" "Rust 提供异步通道（`channels`）用于线程间通信。通道允许信息在两个端点之间单向" "流动：发送端（`Sender`）和接收端（`Receiver`）。" #: src/std_misc/channels.md:15 msgid "" "// Channels have two endpoints: the `Sender` and the `Receiver`,\n" " // where `T` is the type of the message to be transferred\n" " // (type annotation is superfluous)\n" msgstr "" "// 通道有两个端点：`Sender` 和 `Receiver`，\n" " // 其中 `T` 是要传输的消息类型\n" " // （此处的类型注解是多余的）\n" #: src/std_misc/channels.md:22 msgid "// The sender endpoint can be copied\n" msgstr "// 发送端可以被复制\n" #: src/std_misc/channels.md:25 msgid "// Each thread will send its id via the channel\n" msgstr "// 每个线程将通过通道发送其 ID\n" #: src/std_misc/channels.md:27 msgid "" "// The thread takes ownership over `thread_tx`\n" " // Each thread queues a message in the channel\n" msgstr "" "// 线程获取 `thread_tx` 的所有权\n" " // 每个线程在通道中排队一条消息\n" #: src/std_misc/channels.md:31 msgid "" "// Sending is a non-blocking operation, the thread will continue\n" " // immediately after sending its message\n" msgstr "" "// 发送是非阻塞操作，线程在发送消息后\n" " // 会立即继续执行\n" #: src/std_misc/channels.md:33 msgid "\"thread {} finished\"" msgstr "\"线程 {} 已完成\"" #: src/std_misc/channels.md:39 msgid "// Here, all the messages are collected\n" msgstr "// 在这里收集所有消息\n" #: src/std_misc/channels.md:42 msgid "" "// The `recv` method picks a message from the channel\n" " // `recv` will block the current thread if there are no messages " "available\n" msgstr "" "// `recv` 方法从通道中获取一条消息\n" " // 如果没有可用消息，`recv` 将阻塞当前线程\n" #: src/std_misc/channels.md:47 msgid "// Wait for the threads to complete any remaining work\n" msgstr "// 等待线程完成所有剩余工作\n" #: src/std_misc/channels.md:49 msgid "\"oops! the child thread panicked\"" msgstr "\"糟糕！子线程发生了 panic\"" #: src/std_misc/channels.md:52 msgid "// Show the order in which the messages were sent\n" msgstr "// 显示消息发送的顺序\n" #: src/std_misc/path.md:3 msgid "" "The `Path` struct represents file paths in the underlying filesystem. There " "are two flavors of `Path`: `posix::Path`, for UNIX-like systems, and " "`windows::Path`, for Windows. The prelude exports the appropriate platform-" "specific `Path` variant." msgstr "" "`Path` 结构体表示底层文件系统中的文件路径。`Path` 有两种变体：用于类 UNIX 系" "统的 `posix::Path` 和用于 Windows 的 `windows::Path`。prelude 会导出适合特定" "平台的 `Path` 变体。" #: src/std_misc/path.md:8 msgid "" "A `Path` can be created from an `OsStr`, and provides several methods to get " "information from the file/directory the path points to." msgstr "" "`Path` 可以从 `OsStr` 创建，并提供多种方法来获取路径所指向的文件或目录的信" "息。" #: src/std_misc/path.md:11 msgid "" "A `Path` is immutable. The owned version of `Path` is `PathBuf`. The " "relation between `Path` and `PathBuf` is similar to that of `str` and " "`String`: a `PathBuf` can be mutated in-place, and can be dereferenced to a " "`Path`." msgstr "" "`Path` 是不可变的。`Path` 的所有权版本是 `PathBuf`。`Path` 和 `PathBuf` 之间" "的关系类似于 `str` 和 `String`：`PathBuf` 可以原地修改，并且可以解引用为 " "`Path`。" #: src/std_misc/path.md:15 msgid "" "Note that a `Path` is _not_ internally represented as an UTF-8 string, but " "instead is stored as an `OsString`. Therefore, converting a `Path` to a " "`&str` is _not_ free and may fail (an `Option` is returned). However, a " "`Path` can be freely converted to an `OsString` or `&OsStr` using " "`into_os_string` and `as_os_str`, respectively." msgstr "" "注意，`Path` 在内部**并非**表示为 UTF-8 字符串，而是存储为 `OsString`。因此，" "将 `Path` 转换为 `&str` **并非**零开销操作，且可能失败（返回一个 `Option`）。" "然而，`Path` 可以自由地转换为 `OsString` 或 `&OsStr`，分别使用 " "`into_os_string` 和 `as_os_str` 方法。" #: src/std_misc/path.md:25 msgid "// Create a `Path` from an `&'static str`\n" msgstr "// 从 `&'static str` 创建一个 `Path`\n" #: src/std_misc/path.md:26 msgid "\".\"" msgstr "\".\"" #: src/std_misc/path.md:28 msgid "// The `display` method returns a `Display`able structure\n" msgstr "// `display` 方法返回一个可用于显示的结构体\n" #: src/std_misc/path.md:31 msgid "" "// `join` merges a path with a byte container using the OS specific\n" " // separator, and returns a `PathBuf`\n" msgstr "" "// `join` 使用操作系统特定的分隔符将路径与字节容器合并，\n" " // 并返回一个 `PathBuf`\n" #: src/std_misc/path.md:35 msgid "// `push` extends the `PathBuf` with a `&Path`\n" msgstr "// `push` 使用 `&Path` 扩展 `PathBuf`\n" #: src/std_misc/path.md:37 msgid "\"myfile.tar.gz\"" msgstr "\"myfile.tar.gz\"" #: src/std_misc/path.md:39 msgid "// `set_file_name` updates the file name of the `PathBuf`\n" msgstr "// `set_file_name` 更新 `PathBuf` 的文件名\n" #: src/std_misc/path.md:40 msgid "\"package.tgz\"" msgstr "\"package.tgz\"" #: src/std_misc/path.md:42 msgid "// Convert the `PathBuf` into a string slice\n" msgstr "// 将 `PathBuf` 转换为字符串切片\n" #: src/std_misc/path.md:44 msgid "\"new path is not a valid UTF-8 sequence\"" msgstr "\"新路径不是有效的 UTF-8 序列\"" #: src/std_misc/path.md:45 msgid "\"new path is {}\"" msgstr "\"新路径是 {}\"" #: src/std_misc/path.md:50 msgid "" "Be sure to check at other `Path` methods (`posix::Path` or `windows::Path`) " "and the `Metadata` struct." msgstr "" "请务必查看其他 `Path` 方法（`posix::Path` 或 `windows::Path`）以及 " "`Metadata` 结构体。" #: src/std_misc/path.md:55 msgid "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) and [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)." msgstr "" "[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) 和 [Metadata]" "(https://doc.rust-lang.org/std/fs/struct.Metadata.html)。" #: src/std_misc/file.md:3 msgid "" "The `File` struct represents a file that has been opened (it wraps a file " "descriptor), and gives read and/or write access to the underlying file." msgstr "" "`File` 结构体表示一个已打开的文件（它封装了一个文件描述符），并提供对底层文件" "的读取和/或写入访问。" #: src/std_misc/file.md:6 msgid "" "Since many things can go wrong when doing file I/O, all the `File` methods " "return the `io::Result` type, which is an alias for `Result`." msgstr "" "由于文件 I/O 操作可能会出现多种错误，所有 `File` 方法都返回 `io::Result` " "类型，这是 `Result` 的别名。" #: src/std_misc/file.md:9 msgid "" "This makes the failure of all I/O operations _explicit_. Thanks to this, the " "programmer can see all the failure paths, and is encouraged to handle them " "in a proactive manner." msgstr "" "这使得所有 I/O 操作的失败都变得**显式**。得益于此，程序员可以看到所有可能的失" "败路径，并被鼓励主动处理这些情况。" #: src/std_misc/file/open.md:3 msgid "The `open` function can be used to open a file in read-only mode." msgstr "`open` 函数可用于以只读模式打开文件。" #: src/std_misc/file/open.md:5 msgid "" "A `File` owns a resource, the file descriptor and takes care of closing the " "file when it is `drop`ed." msgstr "`File` 拥有一个资源（即文件描述符），并在被 `drop` 时负责关闭文件。" #: src/std_misc/file/open.md:14 msgid "// Create a path to the desired file\n" msgstr "// 创建指向目标文件的路径\n" #: src/std_misc/file/open.md:15 msgid "\"hello.txt\"" msgstr "\"hello.txt\"" #: src/std_misc/file/open.md:18 msgid "// Open the path in read-only mode, returns `io::Result`\n" msgstr "// 以只读模式打开路径，返回 `io::Result`\n" #: src/std_misc/file/open.md:20 msgid "\"couldn't open {}: {}\"" msgstr "\"无法打开 {}: {}\"" #: src/std_misc/file/open.md:24 msgid "// Read the file contents into a string, returns `io::Result`\n" msgstr "// 将文件内容读入字符串，返回 `io::Result`\n" #: src/std_misc/file/open.md:27 msgid "\"couldn't read {}: {}\"" msgstr "\"无法读取 {}: {}\"" #: src/std_misc/file/open.md:28 msgid "\"{} contains:\\n{}\"" msgstr "\"{} 的内容：\\n{}\"" #: src/std_misc/file/open.md:31 msgid "// `file` goes out of scope, and the \"hello.txt\" file gets closed\n" msgstr "// `file` 超出作用域，\"hello.txt\" 文件随之关闭\n" #: src/std_misc/file/open.md:35 src/std_misc/file/create.md:39 #: src/std_misc/fs.md:108 msgid "Here's the expected successful output:" msgstr "以下是预期的成功输出：" #: src/std_misc/file/open.md:37 msgid "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt contains:\n" "Hello World!\n" "```" msgstr "" "```shell\n" "$ echo \"Hello World!\" > hello.txt\n" "$ rustc open.rs && ./open\n" "hello.txt 的内容：\n" "Hello World!\n" "```" #: src/std_misc/file/open.md:44 msgid "" "(You are encouraged to test the previous example under different failure " "conditions: `hello.txt` doesn't exist, or `hello.txt` is not readable, etc.)" msgstr "" "（建议您在不同的失败情况下测试上述示例：例如 `hello.txt` 不存在，或 " "`hello.txt` 不可读等。）" #: src/std_misc/file/create.md:3 msgid "" "The `create` function opens a file in write-only mode. If the file already " "existed, the old content is destroyed. Otherwise, a new file is created." msgstr "" "`create` 函数以只写模式打开文件。如果文件已存在，旧内容会被清除；否则，会创建" "一个新文件。" #: src/std_misc/file/create.md:9 msgid "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" msgstr "" "\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n" "tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim " "veniam,\n" "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n" "consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n" "cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat " "non\n" "proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n" "\"" #: src/std_misc/file/create.md:22 msgid "\"lorem_ipsum.txt\"" msgstr "\"lorem_ipsum.txt\"" #: src/std_misc/file/create.md:25 msgid "// Open a file in write-only mode, returns `io::Result`\n" msgstr "// 以只写模式打开文件，返回 `io::Result`\n" #: src/std_misc/file/create.md:27 msgid "\"couldn't create {}: {}\"" msgstr "\"无法创建 {}: {}\"" #: src/std_misc/file/create.md:31 msgid "// Write the `LOREM_IPSUM` string to `file`, returns `io::Result<()>`\n" msgstr "// 将 `LOREM_IPSUM` 字符串写入 `file`，返回 `io::Result<()>`\n" #: src/std_misc/file/create.md:33 msgid "\"couldn't write to {}: {}\"" msgstr "\"无法写入 {}: {}\"" #: src/std_misc/file/create.md:34 msgid "\"successfully wrote to {}\"" msgstr "\"成功写入 {}\"" #: src/std_misc/file/create.md:54 msgid "" "(As in the previous example, you are encouraged to test this example under " "failure conditions.)" msgstr "（与前面的示例类似，建议您在失败情况下测试此示例。）" #: src/std_misc/file/create.md:57 msgid "" "The [`OpenOptions`](https://doc.rust-lang.org/std/fs/" "struct.OpenOptions.html) struct can be used to configure how a file is " "opened." msgstr "" "[`OpenOptions`](https://doc.rust-lang.org/std/fs/struct.OpenOptions.html) 结" "构体可用于配置文件的打开方式。" #: src/std_misc/file/read_lines.md:3 msgid "A naive approach" msgstr "一种简单的方法" #: src/std_misc/file/read_lines.md:5 msgid "" "This might be a reasonable first attempt for a beginner's first " "implementation for reading lines from a file." msgstr "对于初学者来说，这可能是从文件中读取行的一个合理的初步尝试。" #: src/std_misc/file/read_lines.md:22 msgid "" "Since the method `lines()` returns an iterator over the lines in the file, " "we can also perform a map inline and collect the results, yielding a more " "concise and fluent expression." msgstr "" "由于 `lines()` 方法返回文件中各行的迭代器，我们可以内联执行 map 并收集结果，" "从而得到一个更简洁流畅的表达式。" #: src/std_misc/file/read_lines.md:31 msgid "// panic on possible file-reading errors\n" msgstr "// 遇到可能的文件读取错误时 panic\n" #: src/std_misc/file/read_lines.md:32 msgid "// split the string into an iterator of string slices\n" msgstr "// 将字符串分割成字符串切片的迭代器\n" #: src/std_misc/file/read_lines.md:33 msgid "// make each slice into a string\n" msgstr "// 将每个切片转换为字符串\n" #: src/std_misc/file/read_lines.md:34 msgid "// gather them together into a vector\n" msgstr "// 将它们收集到一个向量中\n" #: src/std_misc/file/read_lines.md:38 msgid "" "Note that in both examples above, we must convert the `&str` reference " "returned from `lines()` to the owned type `String`, using `.to_string()` and " "`String::from` respectively." msgstr "" "注意，在上述两个示例中，我们都必须将 `lines()` 返回的 `&str` 引用转换为拥有所" "有权的 `String` 类型，分别使用 `.to_string()` 和 `String::from`。" #: src/std_misc/file/read_lines.md:42 msgid "A more efficient approach" msgstr "一种更高效的方法" #: src/std_misc/file/read_lines.md:44 msgid "" "Here we pass ownership of the open `File` to a `BufReader` struct. " "`BufReader` uses an internal buffer to reduce intermediate allocations." msgstr "" "在这里，我们将打开的 `File` 的所有权传递给 `BufReader` 结构体。`BufReader` 使" "用内部缓冲区来减少中间分配。" #: src/std_misc/file/read_lines.md:47 msgid "" "We also update `read_lines` to return an iterator instead of allocating new " "`String` objects in memory for each line." msgstr "" "我们还对 `read_lines` 函数进行了改进，使其返回一个迭代器，而不是为每行内容在" "内存中分配新的 `String` 对象。" #: src/std_misc/file/read_lines.md:56 msgid "// File hosts.txt must exist in the current path\n" msgstr "// 文件 hosts.txt 必须存在于当前路径下\n" #: src/std_misc/file/read_lines.md:57 msgid "\"./hosts.txt\"" msgstr "\"./hosts.txt\"" #: src/std_misc/file/read_lines.md:58 msgid "// Consumes the iterator, returns an (Optional) String\n" msgstr "// 消耗迭代器，返回一个（可选的）String\n" #: src/std_misc/file/read_lines.md:64 msgid "" "// The output is wrapped in a Result to allow matching on errors.\n" "// Returns an Iterator to the Reader of the lines of the file.\n" msgstr "" "// 输出被包装在 Result 中以便于错误匹配。\n" "// 返回一个指向文件行读取器的迭代器。\n" #: src/std_misc/file/read_lines.md:74 msgid "Running this program simply prints the lines individually." msgstr "运行此程序将逐行打印文件内容。" #: src/std_misc/file/read_lines.md:76 msgid "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" msgstr "" "```shell\n" "$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n" "$ rustc read_lines.rs && ./read_lines\n" "127.0.0.1\n" "192.168.0.1\n" "```" #: src/std_misc/file/read_lines.md:83 msgid "" "(Note that since `File::open` expects a generic `AsRef` as argument, " "we define our generic `read_lines()` method with the same generic " "constraint, using the `where` keyword.)" msgstr "" "（注意，由于 `File::open` 需要一个泛型 `AsRef` 作为参数，我们使用 " "`where` 关键字为 `read_lines()` 方法定义了相同的泛型约束。）" #: src/std_misc/file/read_lines.md:86 msgid "" "This process is more efficient than creating a `String` in memory with all " "of the file's contents. This can especially cause performance issues when " "working with larger files." msgstr "" "这种方法比在内存中创建包含整个文件内容的 `String` 更加高效。特别是在处理大文" "件时，后者可能会导致性能问题。" #: src/std_misc/process.md:3 msgid "" "The `process::Output` struct represents the output of a finished child " "process, and the `process::Command` struct is a process builder." msgstr "" "`process::Output` 结构体表示已完成子进程的输出，而 `process::Command` 结构体" "是一个进程构建器。" #: src/std_misc/process.md:10 msgid "\"rustc\"" msgstr "\"rustc\"" #: src/std_misc/process.md:11 msgid "\"--version\"" msgstr "\"--version\"" #: src/std_misc/process.md:13 msgid "\"failed to execute process: {}\"" msgstr "\"执行进程失败：{}\"" #: src/std_misc/process.md:19 msgid "\"rustc succeeded and stdout was:\\n{}\"" msgstr "\"rustc 执行成功，标准输出为：\\n{}\"" #: src/std_misc/process.md:23 msgid "\"rustc failed and stderr was:\\n{}\"" msgstr "\"rustc 执行失败，标准错误输出为：\\n{}\"" #: src/std_misc/process.md:28 msgid "" "(You are encouraged to try the previous example with an incorrect flag " "passed to `rustc`)" msgstr "（建议您尝试在上述示例中向 `rustc` 传递一个错误的标志）" #: src/std_misc/process/pipe.md:3 msgid "" "The `std::process::Child` struct represents a child process, and exposes the " "`stdin`, `stdout` and `stderr` handles for interaction with the underlying " "process via pipes." msgstr "" "`std::process::Child` 结构体代表一个子进程，它暴露了 `stdin`、`stdout` 和 " "`stderr` 句柄，允许通过管道与底层进程进行交互。" #: src/std_misc/process/pipe.md:11 msgid "\"the quick brown fox jumps over the lazy dog\\n\"" msgstr "\"the quick brown fox jumps over the lazy dog\\n\"" #: src/std_misc/process/pipe.md:15 msgid "// Spawn the `wc` command\n" msgstr "// 启动 `wc` 命令\n" #: src/std_misc/process/pipe.md:16 src/std_misc/fs.md:12 src/std_misc/fs.md:73 #: src/std_misc/ffi.md:11 msgid "\"windows\"" msgstr "\"windows\"" #: src/std_misc/process/pipe.md:17 msgid "\"powershell\"" msgstr "\"powershell\"" #: src/std_misc/process/pipe.md:18 msgid "\"-Command\"" msgstr "\"-Command\"" #: src/std_misc/process/pipe.md:18 msgid "\"$input | Measure-Object -Line -Word -Character\"" msgstr "\"$input | Measure-Object -Line -Word -Character\"" #: src/std_misc/process/pipe.md:21 msgid "\"wc\"" msgstr "\"wc\"" #: src/std_misc/process/pipe.md:27 msgid "\"couldn't spawn wc: {}\"" msgstr "\"无法启动 wc：{}\"" #: src/std_misc/process/pipe.md:31 msgid "" "// Write a string to the `stdin` of `wc`.\n" " //\n" " // `stdin` has type `Option`, but since we know this " "instance\n" " // must have one, we can directly `unwrap` it.\n" msgstr "" "// 向 `wc` 的 `stdin` 写入字符串。\n" " //\n" " // `stdin` 的类型是 `Option`，但我们知道这个实例\n" " // 必定存在，所以可以直接 `unwrap` 它。\n" #: src/std_misc/process/pipe.md:36 msgid "\"couldn't write to wc stdin: {}\"" msgstr "\"无法写入 wc 的标准输入：{}\"" #: src/std_misc/process/pipe.md:37 msgid "\"sent pangram to wc\"" msgstr "\"已将 pangram 发送给 wc\"" #: src/std_misc/process/pipe.md:40 msgid "" "// Because `stdin` does not live after the above calls, it is `drop`ed,\n" " // and the pipe is closed.\n" " //\n" " // This is very important, otherwise `wc` wouldn't start processing the\n" " // input we just sent.\n" msgstr "" "// 由于 `stdin` 在上述调用后不再存活，它会被 `drop`，\n" " // 管道随之关闭。\n" " //\n" " // 这一点非常重要，否则 `wc` 不会开始处理\n" " // 我们刚刚发送的输入。\n" #: src/std_misc/process/pipe.md:46 msgid "" "// The `stdout` field also has type `Option` so must be " "unwrapped.\n" msgstr "// `stdout` 字段的类型也是 `Option`，因此必须解包。\n" #: src/std_misc/process/pipe.md:49 msgid "\"couldn't read wc stdout: {}\"" msgstr "\"无法读取 wc 的标准输出：{}\"" #: src/std_misc/process/pipe.md:50 msgid "\"wc responded with:\\n{}\"" msgstr "\"wc 的响应为：\\n{}\"" #: src/std_misc/process/wait.md:3 msgid "" "If you'd like to wait for a `process::Child` to finish, you must call " "`Child::wait`, which will return a `process::ExitStatus`." msgstr "" "如果你想等待一个 `process::Child` 完成，你必须调用 `Child::wait`，它会返回一" "个 `process::ExitStatus`。" #: src/std_misc/process/wait.md:10 msgid "\"sleep\"" msgstr "\"sleep\"" #: src/std_misc/process/wait.md:13 msgid "\"reached end of main\"" msgstr "\"到达 main 函数末尾\"" #: src/std_misc/process/wait.md:18 msgid "" "# `wait` keeps running for 5 seconds until the `sleep 5` command finishes\n" msgstr "# `wait` 会持续运行 5 秒，直到 `sleep 5` 命令执行完毕\n" #: src/std_misc/fs.md:3 msgid "" "The `std::fs` module contains several functions that deal with the " "filesystem." msgstr "`std::fs` 模块包含多个用于处理文件系统的函数。" #: src/std_misc/fs.md:10 src/std_misc/fs.md:68 src/std_misc/ffi.md:20 msgid "\"unix\"" msgstr "\"unix\"" #: src/std_misc/fs.md:15 msgid "// A simple implementation of `% cat path`\n" msgstr "// `% cat path` 命令的简单实现\n" #: src/std_misc/fs.md:25 msgid "// A simple implementation of `% echo s > path`\n" msgstr "// `% echo s > path` 命令的简单实现\n" #: src/std_misc/fs.md:32 msgid "// A simple implementation of `% touch path` (ignores existing files)\n" msgstr "// `% touch path` 命令的简单实现（忽略已存在的文件）\n" #: src/std_misc/fs.md:42 msgid "\"`mkdir a`\"" msgstr "\"`mkdir a`\"" #: src/std_misc/fs.md:43 msgid "// Create a directory, returns `io::Result<()>`\n" msgstr "// 创建目录，返回 `io::Result<()>`\n" #: src/std_misc/fs.md:45 src/std_misc/fs.md:52 src/std_misc/fs.md:58 #: src/std_misc/fs.md:63 src/std_misc/fs.md:70 src/std_misc/fs.md:75 #: src/std_misc/fs.md:81 src/std_misc/fs.md:88 src/std_misc/fs.md:97 #: src/std_misc/fs.md:103 msgid "\"! {:?}\"" msgstr "\"! {:?}\"" #: src/std_misc/fs.md:49 msgid "\"`echo hello > a/b.txt`\"" msgstr "\"`echo hello > a/b.txt`\"" #: src/std_misc/fs.md:50 msgid "" "// The previous match can be simplified using the `unwrap_or_else` method\n" msgstr "// 可以使用 `unwrap_or_else` 方法简化之前的匹配\n" #: src/std_misc/fs.md:51 msgid "\"a/b.txt\"" msgstr "\"a/b.txt\"" #: src/std_misc/fs.md:55 msgid "\"`mkdir -p a/c/d`\"" msgstr "\"`mkdir -p a/c/d`\"" #: src/std_misc/fs.md:56 msgid "// Recursively create a directory, returns `io::Result<()>`\n" msgstr "// 递归创建目录，返回 `io::Result<()>`\n" #: src/std_misc/fs.md:57 src/std_misc/fs.md:102 msgid "\"a/c/d\"" msgstr "\"a/c/d\"" #: src/std_misc/fs.md:61 msgid "\"`touch a/c/e.txt`\"" msgstr "\"`touch a/c/e.txt`\"" #: src/std_misc/fs.md:62 src/std_misc/fs.md:96 msgid "\"a/c/e.txt\"" msgstr "\"a/c/e.txt\"" #: src/std_misc/fs.md:66 msgid "\"`ln -s ../b.txt a/c/b.txt`\"" msgstr "\"`ln -s ../b.txt a/c/b.txt`\"" #: src/std_misc/fs.md:67 msgid "// Create a symbolic link, returns `io::Result<()>`\n" msgstr "// 创建符号链接，返回 `io::Result<()>`\n" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 msgid "\"../b.txt\"" msgstr "\"../b.txt\"" #: src/std_misc/fs.md:69 src/std_misc/fs.md:74 src/std_misc/fs.md:80 msgid "\"a/c/b.txt\"" msgstr "\"a/c/b.txt\"" #: src/std_misc/fs.md:79 msgid "\"`cat a/c/b.txt`\"" msgstr "\"`cat a/c/b.txt`\"" #: src/std_misc/fs.md:85 msgid "\"`ls a`\"" msgstr "\"`ls a`\"" #: src/std_misc/fs.md:86 msgid "// Read the contents of a directory, returns `io::Result>`\n" msgstr "// 读取目录内容，返回 `io::Result>`\n" #: src/std_misc/fs.md:94 msgid "\"`rm a/c/e.txt`\"" msgstr "\"`rm a/c/e.txt`\"" #: src/std_misc/fs.md:95 msgid "// Remove a file, returns `io::Result<()>`\n" msgstr "// 删除文件，返回 `io::Result<()>`\n" #: src/std_misc/fs.md:100 msgid "\"`rmdir a/c/d`\"" msgstr "\"`rmdir a/c/d`\"" #: src/std_misc/fs.md:101 msgid "// Remove an empty directory, returns `io::Result<()>`\n" msgstr "// 删除空目录，返回 `io::Result<()>`\n" #: src/std_misc/fs.md:110 msgid "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" msgstr "" "```shell\n" "$ rustc fs.rs && ./fs\n" "`mkdir a`\n" "`echo hello > a/b.txt`\n" "`mkdir -p a/c/d`\n" "`touch a/c/e.txt`\n" "`ln -s ../b.txt a/c/b.txt`\n" "`cat a/c/b.txt`\n" "> hello\n" "`ls a`\n" "> \"a/b.txt\"\n" "> \"a/c\"\n" "`rm a/c/e.txt`\n" "`rmdir a/c/d`\n" "```" #: src/std_misc/fs.md:126 msgid "And the final state of the `a` directory is:" msgstr "最终 `a` 目录的状态如下：" #: src/std_misc/fs.md:138 msgid "An alternative way to define the function `cat` is with `?` notation:" msgstr "另一种定义 `cat` 函数的方法是使用 `?` 运算符：" #: src/std_misc/fs.md:151 msgid "[`cfg!`](../attribute/cfg.md)" msgstr "[`cfg!`](../attribute/cfg.md)" #: src/std_misc/arg.md:3 msgid "Standard Library" msgstr "标准库" #: src/std_misc/arg.md:5 msgid "" "The command line arguments can be accessed using `std::env::args`, which " "returns an iterator that yields a `String` for each argument:" msgstr "" "可以使用 `std::env::args` 访问命令行参数，它返回一个迭代器，为每个参数生成一" "个 `String`：" #: src/std_misc/arg.md:14 msgid "// The first argument is the path that was used to call the program.\n" msgstr "// 第一个参数是用于调用程序的路径\n" #: src/std_misc/arg.md:15 msgid "\"My path is {}.\"" msgstr "\"我的路径是 {}。\"" #: src/std_misc/arg.md:17 msgid "" "// The rest of the arguments are the passed command line parameters.\n" " // Call the program like this:\n" " // $ ./args arg1 arg2\n" msgstr "" "// 其余参数是传递的命令行参数\n" " // 像这样调用程序：\n" " // $ ./args arg1 arg2\n" #: src/std_misc/arg.md:20 msgid "\"I got {:?} arguments: {:?}.\"" msgstr "\"我获得了 {:?} 个参数：{:?}。\"" #: src/std_misc/arg.md:24 msgid "" "```shell\n" "$ ./args 1 2 3\n" "My path is ./args.\n" "I got 3 arguments: [\"1\", \"2\", \"3\"].\n" "```" msgstr "" "```shell\n" "$ ./args 1 2 3\n" "程序路径：./args\n" "接收到 3 个参数：[\"1\"、\"2\"、\"3\"]\n" "```" #: src/std_misc/arg.md:32 msgid "" "Alternatively, there are numerous crates that can provide extra " "functionality when creating command-line applications. One of the more " "popular command line argument crates being [`clap`](https://rust-" "cli.github.io/book/tutorial/cli-args.html#parsing-cli-arguments-with-clap)." msgstr "" "此外，在开发命令行应用程序时，还有许多 crate 可以提供额外的功能。其中，" "[`clap`](https://rust-cli.github.io/book/tutorial/cli-args.html#parsing-cli-" "arguments-with-clap) 是一个广受欢迎的命令行参数处理 crate。" #: src/std_misc/arg/matching.md:3 msgid "Matching can be used to parse simple arguments:" msgstr "可以使用模式匹配来解析简单的参数：" #: src/std_misc/arg/matching.md:17 msgid "" "\"usage:\n" "match_args \n" " Check whether given string is the answer.\n" "match_args {{increase|decrease}} \n" " Increase or decrease given integer by one.\"" msgstr "" "\"用法：\n" "match_args <字符串>\n" " 检查给定的字符串是否为正确答案。\n" "match_args {{increase|decrease}} <整数>\n" " 将给定的整数增加或减少 1。\"" #: src/std_misc/arg/matching.md:28 msgid "// no arguments passed\n" msgstr "// 未传递参数\n" #: src/std_misc/arg/matching.md:30 msgid "\"My name is 'match_args'. Try passing some arguments!\"" msgstr "\"我的名字是 'match_args'。试试传递一些参数吧！\"" #: src/std_misc/arg/matching.md:32 msgid "// one argument passed\n" msgstr "// 传递了一个参数\n" #: src/std_misc/arg/matching.md:35 msgid "\"This is the answer!\"" msgstr "\"这就是正确答案！\"" #: src/std_misc/arg/matching.md:36 msgid "\"This is not the answer.\"" msgstr "\"这不是正确答案。\"" #: src/std_misc/arg/matching.md:39 msgid "// one command and one argument passed\n" msgstr "// 传递了一个命令和一个参数\n" #: src/std_misc/arg/matching.md:43 msgid "// parse the number\n" msgstr "// 解析数字\n" #: src/std_misc/arg/matching.md:49 msgid "\"error: second argument not an integer\"" msgstr "\"错误：第二个参数不是整数\"" #: src/std_misc/arg/matching.md:54 msgid "// parse the command\n" msgstr "// 解析命令\n" #: src/std_misc/arg/matching.md:56 msgid "\"increase\"" msgstr "\"increase\"" #: src/std_misc/arg/matching.md:57 msgid "\"decrease\"" msgstr "\"decrease\"" #: src/std_misc/arg/matching.md:59 msgid "\"error: invalid command\"" msgstr "\"错误：无效的命令\"" #: src/std_misc/arg/matching.md:64 msgid "// all the other cases\n" msgstr "// 所有其他情况\n" #: src/std_misc/arg/matching.md:66 msgid "// show a help message\n" msgstr "// 显示帮助信息\n" #: src/std_misc/arg/matching.md:73 msgid "" "If you named your program `match_args.rs` and compile it like this `rustc " "match_args.rs`, you can execute it as follows:" msgstr "" "如果你将程序命名为 `match_args.rs` 并使用 `rustc match_args.rs` 编译它，你可" "以按以下方式执行：" #: src/std_misc/ffi.md:3 msgid "" "Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign " "functions must be declared inside an `extern` block annotated with a " "`#[link]` attribute containing the name of the foreign library." msgstr "" "Rust 提供了与 C 库交互的外部函数接口（FFI）。外部函数必须在 `extern` 块内声" "明，并使用 `#[link]` 属性标注外部库的名称。" #: src/std_misc/ffi.md:9 msgid "// this extern block links to the libm library\n" msgstr "// 此 extern 块链接到 libm 库\n" #: src/std_misc/ffi.md:12 msgid "\"msvcrt\"" msgstr "\"msvcrt\"" #: src/std_misc/ffi.md:14 src/std_misc/ffi.md:23 msgid "" "// this is a foreign function\n" " // that computes the square root of a single precision complex number\n" msgstr "" "// 这是一个外部函数\n" " // 用于计算单精度复数的平方根\n" #: src/std_misc/ffi.md:21 msgid "\"m\"" msgstr "\"m\"" #: src/std_misc/ffi.md:29 msgid "" "// Since calling foreign functions is considered unsafe,\n" "// it's common to write safe wrappers around them.\n" msgstr "" "// 由于调用外部函数被认为是不安全的，\n" "// 通常会为它们编写安全的包装函数。\n" #: src/std_misc/ffi.md:37 msgid "// z = -1 + 0i\n" msgstr "// z = -1 + 0i\n" #: src/std_misc/ffi.md:40 msgid "// calling a foreign function is an unsafe operation\n" msgstr "// 调用外部函数是一个不安全的操作\n" #: src/std_misc/ffi.md:43 msgid "\"the square root of {:?} is {:?}\"" msgstr "\"{:?} 的平方根是 {:?}\"" #: src/std_misc/ffi.md:45 msgid "// calling safe API wrapped around unsafe operation\n" msgstr "// 调用封装了不安全操作的安全 API\n" #: src/std_misc/ffi.md:46 msgid "\"cos({:?}) = {:?}\"" msgstr "\"cos({:?}) = {:?}\"" #: src/std_misc/ffi.md:48 msgid "// Minimal implementation of single precision complex numbers\n" msgstr "// 单精度复数的最小实现\n" #: src/std_misc/ffi.md:60 msgid "\"{}-{}i\"" msgstr "\"{}-{}i\"" #: src/std_misc/ffi.md:62 msgid "\"{}+{}i\"" msgstr "\"{}+{}i\"" #: src/testing.md:3 msgid "" "Rust is a programming language that cares a lot about correctness and it " "includes support for writing software tests within the language itself." msgstr "Rust 是一种非常注重正确性的编程语言，它内置了编写软件测试的支持。" #: src/testing.md:6 msgid "Testing comes in three styles:" msgstr "测试分为三种类型：" #: src/testing.md:8 msgid "[Unit](testing/unit_testing.md) testing." msgstr "[单元测试](testing/unit_testing.md)" #: src/testing.md:9 msgid "[Doc](testing/doc_testing.md) testing." msgstr "[文档测试](testing/doc_testing.md)" #: src/testing.md:10 msgid "[Integration](testing/integration_testing.md) testing." msgstr "[集成测试](testing/integration_testing.md)" #: src/testing.md:12 msgid "Also Rust has support for specifying additional dependencies for tests:" msgstr "此外，Rust 还支持为测试指定额外的依赖项：" #: src/testing.md:14 msgid "[Dev-dependencies](testing/dev_dependencies.md)" msgstr "[开发依赖](testing/dev_dependencies.md)" #: src/testing.md:18 msgid "" "[The Book](https://doc.rust-lang.org/book/ch11-00-testing.html) chapter on " "testing" msgstr "" "《Rust 程序设计语言》中[关于测试的章节](https://doc.rust-lang.org/book/" "ch11-00-testing.html)" #: src/testing.md:19 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on doc-testing" msgstr "" "API 指南中[关于文档测试的内容](https://rust-lang-nursery.github.io/api-" "guidelines/documentation.html)" #: src/testing/unit_testing.md:3 msgid "" "Tests are Rust functions that verify that the non-test code is functioning " "in the expected manner. The bodies of test functions typically perform some " "setup, run the code we want to test, then assert whether the results are " "what we expect." msgstr "" "测试是 Rust 函数，用于验证非测试代码是否按预期方式运行。测试函数的主体通常包" "括一些准备工作，运行待测试的代码，然后断言结果是否符合预期。" #: src/testing/unit_testing.md:8 msgid "" "Most unit tests go into a `tests` [mod](../mod.md) with the `#[cfg(test)]` " "[attribute](../attribute.md). Test functions are marked with the `#[test]` " "attribute." msgstr "" "大多数单元测试都放在带有 `#[cfg(test)]` [属性](../attribute.md)的 `tests` [模" "块](../mod.md)中。测试函数用 `#[test]` 属性标记。" #: src/testing/unit_testing.md:11 msgid "" "Tests fail when something in the test function [panics](../std/panic.md). " "There are some helper [macros](../macros.md):" msgstr "" "当测试函数中出现[恐慌（panic）](../std/panic.md)时，测试就会失败。以下是一些" "辅助[宏](../macros.md)：" #: src/testing/unit_testing.md:14 msgid "`assert!(expression)` - panics if expression evaluates to `false`." msgstr "`assert!(expression)` - 如果表达式求值为 `false`，则会触发 panic。" #: src/testing/unit_testing.md:15 msgid "" "`assert_eq!(left, right)` and `assert_ne!(left, right)` - testing left and " "right expressions for equality and inequality respectively." msgstr "" "`assert_eq!(left, right)` 和 `assert_ne!(left, right)` - 分别用于测试左右表达" "式的相等性和不相等性。" #: src/testing/unit_testing.md:22 msgid "" "// This is a really bad adding function, its purpose is to fail in this\n" "// example.\n" msgstr "// 这是一个非常糟糕的加法函数，它的目的是在这个例子中失败。\n" #: src/testing/unit_testing.md:32 msgid "" "// Note this useful idiom: importing names from outer (for mod tests) " "scope.\n" msgstr "" "// 注意这个有用的惯用法：从外部作用域（对于 mod tests 而言）导入名称。\n" #: src/testing/unit_testing.md:42 msgid "" "// This assert would fire and test will fail.\n" " // Please note, that private functions can be tested too!\n" msgstr "" "// 这个断言会触发，测试将失败。\n" " // 请注意，私有函数也可以被测试！\n" #: src/testing/unit_testing.md:49 msgid "Tests can be run with `cargo test`." msgstr "可以使用 `cargo test` 命令运行测试。" #: src/testing/unit_testing.md:73 msgid "Tests and `?`" msgstr "测试与 `?` 运算符" #: src/testing/unit_testing.md:75 msgid "" "None of the previous unit test examples had a return type. But in Rust 2018, " "your unit tests can return `Result<()>`, which lets you use `?` in them! " "This can make them much more concise." msgstr "" "之前的单元测试示例都没有返回类型。但在 Rust 2018 版本中，你的单元测试可以返" "回 `Result<()>`，这使得你可以在测试中使用 `?` 运算符！这可以使测试代码更加简" "洁。" #: src/testing/unit_testing.md:84 msgid "\"negative floats don't have square roots\"" msgstr "\"负浮点数没有平方根\"" #: src/testing/unit_testing.md:101 msgid "" "See [\"The Edition Guide\"](https://doc.rust-lang.org/edition-guide/" "rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html) " "for more details." msgstr "" "更多详情请参阅[《版本指南》](https://doc.rust-lang.org/edition-guide/" "rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html)。" #: src/testing/unit_testing.md:103 msgid "Testing panics" msgstr "测试 panic" #: src/testing/unit_testing.md:105 msgid "" "To check functions that should panic under certain circumstances, use " "attribute `#[should_panic]`. This attribute accepts optional parameter " "`expected = ` with the text of the panic message. If your function can panic " "in multiple ways, it helps make sure your test is testing the correct panic." msgstr "" "要检查在某些情况下应该触发恐慌的函数，可以使用 `#[should_panic]` 属性。这个属" "性接受可选参数 `expected = `，用于指定预期的恐慌消息文本。如果你的函数可能以" "多种方式触发 panic，这有助于确保你的测试正在检查正确的 panic 情况。" #: src/testing/unit_testing.md:110 msgid "" "**Note**: Rust also allows a shorthand form `#[should_panic = \"message\"]`, " "which works exactly like `#[should_panic(expected = \"message\")]`. Both are " "valid; the latter is more commonly used and is considered more explicit." msgstr "" "**注意**：Rust 还允许使用简写形式 `#[should_panic = \"message\"]`，其功能与 " "`#[should_panic(expected = \"message\")]` 完全相同。两种形式都有效；后者更常" "用，被认为更明确。" #: src/testing/unit_testing.md:117 src/testing/doc_testing.md:46 msgid "\"Divide-by-zero error\"" msgstr "\"除以零错误\"" #: src/testing/unit_testing.md:119 src/testing/unit_testing.md:140 #: src/testing/unit_testing.md:146 msgid "\"Divide result is zero\"" msgstr "\"除法结果为零\"" #: src/testing/unit_testing.md:146 msgid "// This also works\n" msgstr "// 这样也可以\n" #: src/testing/unit_testing.md:153 msgid "Running these tests gives us:" msgstr "运行这些测试会得到以下结果：" #: src/testing/unit_testing.md:173 msgid "Running specific tests" msgstr "运行特定测试" #: src/testing/unit_testing.md:175 msgid "" "To run specific tests one may specify the test name to `cargo test` command." msgstr "要运行特定的测试，可以在 `cargo test` 命令中指定测试名称。" #: src/testing/unit_testing.md:191 msgid "" "To run multiple tests one may specify part of a test name that matches all " "the tests that should be run." msgstr "" "要运行多个测试，可以指定测试名称的一部分，该部分匹配所有应该运行的测试。" #: src/testing/unit_testing.md:209 msgid "Ignoring tests" msgstr "忽略测试" #: src/testing/unit_testing.md:211 msgid "" "Tests can be marked with the `#[ignore]` attribute to exclude some tests. Or " "to run them with command `cargo test -- --ignored`" msgstr "" "可以使用 `#[ignore]` 属性标记测试以排除某些测试。或者使用命令 `cargo test -- " "--ignored` 来运行这些被忽略的测试。" #: src/testing/doc_testing.md:3 msgid "" "The primary way of documenting a Rust project is through annotating the " "source code. Documentation comments are written in [CommonMark Markdown " "specification](https://commonmark.org/) and support code blocks in them. " "Rust takes care about correctness, so these code blocks are compiled and " "used as documentation tests." msgstr "" "Rust 项目的主要文档编写方式是通过在源代码中添加注释。文档注释使用 " "[CommonMark Markdown 规范](https://commonmark.org/)编写，并支持其中的代码块。" "Rust 注重正确性，因此这些代码块会被编译并用作文档测试。" #: src/testing/doc_testing.md:10 msgid "" "/// First line is a short summary describing function.\n" "///\n" "/// The next lines present detailed documentation. Code blocks start with\n" "/// triple backquotes and have implicit `fn main()` inside\n" "/// and `extern crate `. Assume we're testing a `playground` " "library\n" "/// crate or using the Playground's Test action:\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" msgstr "" "/// 第一行是函数的简要描述。\n" "///\n" "/// 接下来的几行是详细文档。代码块以三个反引号开始，\n" "/// 并隐含了 `fn main()` 函数和 `extern crate ` 声明。\n" "/// 假设我们正在测试 `playground` crate：\n" "///\n" "/// ```\n" "/// let result = playground::add(2, 3);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" #: src/testing/doc_testing.md:24 msgid "" "/// Usually doc comments may include sections \"Examples\", \"Panics\" and " "\"Failures\".\n" "///\n" "/// The next function divides two numbers.\n" "///\n" "/// # Examples\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # Panics\n" "///\n" "/// The function panics if the second argument is zero.\n" "///\n" "/// ```rust,should_panic\n" "/// // panics on division by zero\n" "/// playground::div(10, 0);\n" "/// ```\n" msgstr "" "/// 文档注释通常包含\"示例\"、\"异常\"和\"错误\"等部分。\n" "///\n" "/// 下面的函数用于两数相除。\n" "///\n" "/// # 示例\n" "///\n" "/// ```\n" "/// let result = playground::div(10, 2);\n" "/// assert_eq!(result, 5);\n" "/// ```\n" "///\n" "/// # 异常\n" "///\n" "/// 当第二个参数为零时，函数会触发异常。\n" "///\n" "/// ```rust,should_panic\n" "/// // 除以零会触发异常\n" "/// playground::div(10, 0);\n" "/// ```\n" #: src/testing/doc_testing.md:53 msgid "" "Code blocks in documentation are automatically tested when running the " "regular `cargo test` command:" msgstr "运行常规的 `cargo test` 命令时，文档中的代码块会自动进行测试：" #: src/testing/doc_testing.md:72 msgid "Motivation behind documentation tests" msgstr "文档测试的动机" #: src/testing/doc_testing.md:74 msgid "" "The main purpose of documentation tests is to serve as examples that " "exercise the functionality, which is one of the most important [guidelines]" "(https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html#examples-use--not-try-not-unwrap-c-question-mark). It " "allows using examples from docs as complete code snippets. But using `?` " "makes compilation fail since `main` returns `unit`. The ability to hide some " "source lines from documentation comes to the rescue: one may write `fn " "try_main() -> Result<(), ErrorType>`, hide it and `unwrap` it in hidden " "`main`. Sounds complicated? Here's an example:" msgstr "" "文档测试的主要目的是提供功能演示的示例，这是最重要的[指导原则](https://rust-" "lang-nursery.github.io/api-guidelines/documentation.html#examples-use--not-" "try-not-unwrap-c-question-mark)之一。它允许将文档中的示例作为完整的代码片段使" "用。但是使用 `?` 会导致编译失败，因为 `main` 函数返回 `unit` 类型。这时，隐藏" "文档中的某些源代码行就派上用场了：可以编写 `fn try_main() -> Result<(), " "ErrorType>`，将其隐藏，并在隐藏的 `main` 函数中 `unwrap` 它。听起来很复杂？这" "里有一个例子：" #: src/testing/doc_testing.md:83 msgid "" "/// Using hidden `try_main` in doc tests.\n" "///\n" "/// ```\n" "/// # // hidden lines start with `#` symbol, but they're still compilable!\n" "/// # fn try_main() -> Result<(), String> { // line that wraps the body " "shown in doc\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // returning from try_main\n" "/// # }\n" "/// # fn main() { // starting main that'll unwrap()\n" "/// # try_main().unwrap(); // calling try_main and unwrapping\n" "/// # // so that test will panic in case of error\n" "/// # }\n" "/// ```\n" msgstr "" "/// 在文档测试中使用隐藏的 `try_main` 函数。\n" "///\n" "/// ```\n" "/// # // 以 `#` 开头的行在文档中是隐藏的，但它们仍然可以编译！\n" "/// # fn try_main() -> Result<(), String> { // 这行包装了文档中显示的函数体\n" "/// let res = playground::try_div(10, 2)?;\n" "/// # Ok(()) // 从 try_main 返回\n" "/// # }\n" "/// # fn main() { // 开始会调用 unwrap() 的 main 函数\n" "/// # try_main().unwrap(); // 调用 try_main 并解包\n" "/// # // 这样在出错时测试会触发 panic\n" "/// # }\n" "/// ```\n" #: src/testing/doc_testing.md:98 msgid "\"Divide-by-zero\"" msgstr "\"除以零错误\"" #: src/testing/doc_testing.md:107 msgid "" "[RFC505](https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-" "conventions.md) on documentation style" msgstr "" "关于文档风格的 [RFC505](https://github.com/rust-lang/rfcs/blob/master/text/" "0505-api-comment-conventions.md)" #: src/testing/doc_testing.md:108 msgid "" "[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html) on documentation guidelines" msgstr "" "关于文档指南的 [API 指南](https://rust-lang-nursery.github.io/api-guidelines/" "documentation.html)" #: src/testing/integration_testing.md:3 msgid "" "[Unit tests](unit_testing.md) are testing one module in isolation at a time: " "they're small and can test private code. Integration tests are external to " "your crate and use only its public interface in the same way any other code " "would. Their purpose is to test that many parts of your library work " "correctly together." msgstr "" "[单元测试](unit_testing.md)每次只隔离测试一个模块：它们规模小，可以测试私有代" "码。集成测试则位于 crate 外部，仅使用其公共接口，就像其他代码一样。集成测试的" "目的是验证库的多个部分能否正确协同工作。" #: src/testing/integration_testing.md:8 msgid "Cargo looks for integration tests in `tests` directory next to `src`." msgstr "Cargo 在 `src` 目录旁的 `tests` 目录中查找集成测试。" #: src/testing/integration_testing.md:10 src/testing/dev_dependencies.md:17 msgid "File `src/lib.rs`:" msgstr "文件 `src/lib.rs`：" #: src/testing/integration_testing.md:13 msgid "// Define this in a crate called `adder`.\n" msgstr "// 在名为 `adder` 的 crate 中定义此内容。\n" #: src/testing/integration_testing.md:19 msgid "File with test: `tests/integration_test.rs`:" msgstr "测试文件：`tests/integration_test.rs`：" #: src/testing/integration_testing.md:28 msgid "Running tests with `cargo test` command:" msgstr "使用 `cargo test` 命令运行测试：" #: src/testing/integration_testing.md:50 msgid "" "Each Rust source file in the `tests` directory is compiled as a separate " "crate. In order to share some code between integration tests we can make a " "module with public functions, importing and using it within tests." msgstr "" "`tests` 目录中的每个 Rust 源文件都被编译为独立的 crate。为了在集成测试之间共" "享代码，我们可以创建一个包含公共函数的模块，然后在测试中导入并使用它。" #: src/testing/integration_testing.md:54 msgid "File `tests/common/mod.rs`:" msgstr "文件 `tests/common/mod.rs`：" #: src/testing/integration_testing.md:58 msgid "" "// some setup code, like creating required files/directories, starting\n" " // servers, etc.\n" msgstr "" "// 一些设置代码，如创建必要的文件/目录，启动\n" " // 服务器等。\n" #: src/testing/integration_testing.md:63 msgid "File with test: `tests/integration_test.rs`" msgstr "测试文件：`tests/integration_test.rs`" #: src/testing/integration_testing.md:66 msgid "// importing common module.\n" msgstr "// 导入 common 模块。\n" #: src/testing/integration_testing.md:71 msgid "// using common code.\n" msgstr "// 使用公共代码。\n" #: src/testing/integration_testing.md:77 msgid "" "Creating the module as `tests/common.rs` also works, but is not recommended " "because the test runner will treat the file as a test crate and try to run " "tests inside it." msgstr "" "将模块创建为 `tests/common.rs` 也可行，但不推荐，因为测试运行器会将该文件视为" "测试 crate 并尝试运行其中的测试。" #: src/testing/dev_dependencies.md:1 msgid "Development dependencies" msgstr "开发依赖" #: src/testing/dev_dependencies.md:3 msgid "" "Sometimes there is a need to have dependencies for tests (or examples, or " "benchmarks) only. Such dependencies are added to `Cargo.toml` in the `[dev-" "dependencies]` section. These dependencies are not propagated to other " "packages which depend on this package." msgstr "" "有时我们需要仅用于测试（或示例、基准测试）的依赖项。这些依赖项添加在 " "`Cargo.toml` 的 `[dev-dependencies]` 部分。这些依赖项不会传递给依赖于本包的其" "他包。" #: src/testing/dev_dependencies.md:8 msgid "" "One such example is [`pretty_assertions`](https://docs.rs/pretty_assertions/" "1.0.0/pretty_assertions/index.html), which extends standard `assert_eq!` and " "`assert_ne!` macros, to provide colorful diff. File `Cargo.toml`:" msgstr "" "例如 [`pretty_assertions`](https://docs.rs/pretty_assertions/1.0.0/" "pretty_assertions/index.html)，它扩展了标准的 `assert_eq!` 和 `assert_ne!` " "宏，提供彩色差异对比。 \n" "文件 `Cargo.toml`：" #: src/testing/dev_dependencies.md:11 msgid "" "```toml\n" "# standard crate data is left out\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" msgstr "" "```toml\n" "# 省略标准的 crate 数据\n" "[dev-dependencies]\n" "pretty_assertions = \"1\"\n" "```" #: src/testing/dev_dependencies.md:27 msgid "// crate for test-only use. Cannot be used in non-test code.\n" msgstr "// 仅用于测试的 crate。不能在非测试代码中使用。\n" #: src/testing/dev_dependencies.md:38 msgid "" "[Cargo](http://doc.crates.io/specifying-dependencies.html) docs on " "specifying dependencies." msgstr "" "[Cargo 文档](http://doc.crates.io/specifying-dependencies.html)中关于指定依赖" "项的说明。" #: src/unsafe.md:3 msgid "" "As an introduction to this section, to borrow from [the official docs]" "(https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html), \"one should try " "to minimize the amount of unsafe code in a code base.\" With that in mind, " "let's get started! Unsafe annotations in Rust are used to bypass protections " "put in place by the compiler; specifically, there are four primary things " "that unsafe is used for:" msgstr "" "作为本节的引言，借用[官方文档](https://doc.rust-lang.org/book/ch19-01-unsafe-" "rust.html)的话说：\"应该尽量减少代码库中不安全代码的数量。\"牢记这一点，让我" "们开始吧！Rust 中的不安全标注用于绕过编译器设置的保护机制。具体来说，不安全主" "要用于以下四个方面：" #: src/unsafe.md:9 msgid "dereferencing raw pointers" msgstr "解引用裸指针" #: src/unsafe.md:10 msgid "" "calling functions or methods which are `unsafe` (including calling a " "function over FFI, see [a previous chapter](std_misc/ffi.md) of the book)" msgstr "" "调用被标记为 `unsafe` 的函数或方法（包括通过 FFI 调用函数，参见本书[前面的章" "节](std_misc/ffi.md)）" #: src/unsafe.md:12 msgid "accessing or modifying static mutable variables" msgstr "访问或修改静态可变变量" #: src/unsafe.md:13 msgid "implementing unsafe traits" msgstr "实现不安全特征" #: src/unsafe.md:15 msgid "Raw Pointers" msgstr "裸指针" #: src/unsafe.md:17 msgid "" "Raw pointers `*` and references `&T` function similarly, but references are " "always safe because they are guaranteed to point to valid data due to the " "borrow checker. Dereferencing a raw pointer can only be done through an " "unsafe block." msgstr "" "裸指针 `*` 和引用 `&T` 的功能类似，但引用总是安全的，因为借用检查器保证它们指" "向有效数据。解引用裸指针只能在 unsafe 块中进行。" #: src/unsafe.md:32 msgid "Calling Unsafe Functions" msgstr "调用不安全函数" #: src/unsafe.md:34 msgid "" "Some functions can be declared as `unsafe`, meaning it is the programmer's " "responsibility to ensure correctness instead of the compiler's. One example " "of this is [`std::slice::from_raw_parts`](https://doc.rust-lang.org/std/" "slice/fn.from_raw_parts.html) which will create a slice given a pointer to " "the first element and a length." msgstr "" "某些函数可以被声明为 `unsafe`，这意味着确保其正确性是程序员的责任，而不是编译" "器的责任。一个例子是 [`std::slice::from_raw_parts`](https://doc.rust-" "lang.org/std/slice/fn.from_raw_parts.html)，它根据指向第一个元素的指针和长度" "创建一个切片。" #: src/unsafe.md:56 msgid "" "For `slice::from_raw_parts`, one of the assumptions which _must_ be upheld " "is that the pointer passed in points to valid memory and that the memory " "pointed to is of the correct type. If these invariants aren't upheld then " "the program's behaviour is undefined and there is no knowing what will " "happen." msgstr "" "对于 `slice::from_raw_parts`，**必须**遵守的一个假设是：传入的指针指向有效内" "存，且指向的内存类型正确。如果这些不变量未被遵守，那么程序的行为将是未定义" "的，无法预知会发生什么。" #: src/unsafe/asm.md:3 msgid "" "Rust provides support for inline assembly via the `asm!` macro. It can be " "used to embed handwritten assembly in the assembly output generated by the " "compiler. Generally this should not be necessary, but might be where the " "required performance or timing cannot be otherwise achieved. Accessing low " "level hardware primitives, e.g. in kernel code, may also demand this " "functionality." msgstr "" "Rust 通过 `asm!` 宏提供了内联汇编支持。它可以用于在编译器生成的汇编输出中嵌入" "手写的汇编代码。通常这不是必需的，但在无法通过其他方式实现所需性能或时序要求" "时可能会用到。访问底层硬件原语（例如在内核代码中）也可能需要这个功能。" #: src/unsafe/asm.md:8 msgid "" "**Note**: the examples here are given in x86/x86-64 assembly, but other " "architectures are also supported." msgstr "**注意**：这里的示例使用 x86/x86-64 汇编，但也支持其他架构。" #: src/unsafe/asm.md:10 msgid "Inline assembly is currently supported on the following architectures:" msgstr "目前支持内联汇编的架构包括：" #: src/unsafe/asm.md:12 msgid "x86 and x86-64" msgstr "x86 和 x86-64" #: src/unsafe/asm.md:13 msgid "ARM" msgstr "ARM" #: src/unsafe/asm.md:14 msgid "AArch64" msgstr "AArch64" #: src/unsafe/asm.md:15 msgid "RISC-V" msgstr "RISC-V" #: src/unsafe/asm.md:17 msgid "Basic usage" msgstr "基本用法" #: src/unsafe/asm.md:19 msgid "Let us start with the simplest possible example:" msgstr "让我们从最简单的例子开始：" #: src/unsafe/asm.md:22 src/unsafe/asm.md:42 src/unsafe/asm.md:69 #: src/unsafe/asm.md:107 src/unsafe/asm.md:124 src/unsafe/asm.md:149 #: src/unsafe/asm.md:183 src/unsafe/asm.md:204 src/unsafe/asm.md:221 #: src/unsafe/asm.md:260 src/unsafe/asm.md:296 src/unsafe/asm.md:312 #: src/unsafe/asm.md:338 src/unsafe/asm.md:376 src/unsafe/asm.md:403 #: src/unsafe/asm.md:427 src/unsafe/asm.md:465 msgid "\"x86_64\"" msgstr "\"x86_64\"" #: src/unsafe/asm.md:26 msgid "\"nop\"" msgstr "\"nop\"" #: src/unsafe/asm.md:31 msgid "" "This will insert a NOP (no operation) instruction into the assembly " "generated by the compiler. Note that all `asm!` invocations have to be " "inside an `unsafe` block, as they could insert arbitrary instructions and " "break various invariants. The instructions to be inserted are listed in the " "first argument of the `asm!` macro as a string literal." msgstr "" "这将在编译器生成的汇编代码中插入一条 NOP（无操作）指令。请注意，所有 `asm!` " "调用都必须放在 `unsafe` 块内，因为它们可能插入任意指令并破坏各种不变量。要插" "入的指令以字符串字面量的形式列在 `asm!` 宏的第一个参数中。" #: src/unsafe/asm.md:36 msgid "Inputs and outputs" msgstr "输入和输出" #: src/unsafe/asm.md:38 msgid "" "Now inserting an instruction that does nothing is rather boring. Let us do " "something that actually acts on data:" msgstr "插入一个什么都不做的指令相当无聊。让我们来做些实际操作数据的事情：" #: src/unsafe/asm.md:47 msgid "\"mov {}, 5\"" msgstr "\"mov {}, 5\"" #: src/unsafe/asm.md:53 msgid "" "This will write the value `5` into the `u64` variable `x`. You can see that " "the string literal we use to specify instructions is actually a template " "string. It is governed by the same rules as Rust [format strings](https://" "doc.rust-lang.org/std/fmt/#syntax). The arguments that are inserted into the " "template however look a bit different than you may be familiar with. First " "we need to specify if the variable is an input or an output of the inline " "assembly. In this case it is an output. We declared this by writing `out`. " "We also need to specify in what kind of register the assembly expects the " "variable. In this case we put it in an arbitrary general purpose register by " "specifying `reg`. The compiler will choose an appropriate register to insert " "into the template and will read the variable from there after the inline " "assembly finishes executing." msgstr "" "这将把值 `5` 写入 `u64` 类型的变量 `x`。你可以看到，我们用来指定指令的字符串" "字面量实际上是一个模板字符串。它遵循与 Rust [格式化字符串](https://doc.rust-" "lang.org/std/fmt/#syntax)相同的规则。然而，插入到模板中的参数看起来可能与你熟" "悉的有些不同。首先，我们需要指定变量是内联汇编的输入还是输出。在这个例子中，" "它是一个输出。我们通过写 `out` 来声明这一点。我们还需要指定汇编期望变量在什么" "类型的寄存器中。这里我们通过指定 `reg` 将其放在任意通用寄存器中。编译器将选择" "一个合适的寄存器插入到模板中，并在内联汇编执行完成后从该寄存器读取变量的值。" #: src/unsafe/asm.md:66 msgid "Let us see another example that also uses an input:" msgstr "让我们再看一个使用输入的例子：" #: src/unsafe/asm.md:76 msgid "\"mov {0}, {1}\"" msgstr "\"mov {0}, {1}\"" #: src/unsafe/asm.md:77 src/unsafe/asm.md:112 src/unsafe/asm.md:130 msgid "\"add {0}, 5\"" msgstr "\"add {0}, 5\"" #: src/unsafe/asm.md:86 msgid "" "This will add `5` to the input in variable `i` and write the result to " "variable `o`. The particular way this assembly does this is first copying " "the value from `i` to the output, and then adding `5` to it." msgstr "" "这段代码会将 `5` 加到变量 `i` 的值上，然后将结果写入变量 `o`。具体的汇编实现" "是先将 `i` 的值复制到输出寄存器，然后再加上 `5`。" #: src/unsafe/asm.md:90 msgid "The example shows a few things:" msgstr "这个例子展示了几个要点：" #: src/unsafe/asm.md:92 msgid "" "First, we can see that `asm!` allows multiple template string arguments; " "each one is treated as a separate line of assembly code, as if they were all " "joined together with newlines between them. This makes it easy to format " "assembly code." msgstr "" "`asm!` 宏支持多个模板字符串参数，每个参数都被视为独立的汇编代码行，就像它们之" "间用换行符连接一样。这使得格式化汇编代码变得简单。" #: src/unsafe/asm.md:97 msgid "" "Second, we can see that inputs are declared by writing `in` instead of `out`." msgstr "其次，我们可以看到输入参数使用 `in` 声明，而不是 `out`。" #: src/unsafe/asm.md:99 msgid "" "Third, we can see that we can specify an argument number, or name as in any " "format string. For inline assembly templates this is particularly useful as " "arguments are often used more than once. For more complex inline assembly " "using this facility is generally recommended, as it improves readability, " "and allows reordering instructions without changing the argument order." msgstr "" "第三，我们可以像在任何格式字符串中一样指定参数编号或名称。这在内联汇编模板中" "特别有用，因为参数通常会被多次使用。对于更复杂的内联汇编，建议使用这种方式，" "因为它提高了可读性，并且允许在不改变参数顺序的情况下重新排列指令。" #: src/unsafe/asm.md:104 msgid "We can further refine the above example to avoid the `mov` instruction:" msgstr "我们可以进一步优化上面的例子，避免使用 `mov` 指令：" #: src/unsafe/asm.md:118 msgid "" "We can see that `inout` is used to specify an argument that is both input " "and output. This is different from specifying an input and output separately " "in that it is guaranteed to assign both to the same register." msgstr "" "我们可以看到 `inout` 用于指定既作为输入又作为输出的参数。这与分别指定输入和输" "出不同，它保证将两者分配到同一个寄存器。" #: src/unsafe/asm.md:121 msgid "" "It is also possible to specify different variables for the input and output " "parts of an `inout` operand:" msgstr "也可以为 `inout` 操作数的输入和输出部分指定不同的变量：" #: src/unsafe/asm.md:136 msgid "Late output operands" msgstr "延迟输出操作数" #: src/unsafe/asm.md:138 msgid "" "The Rust compiler is conservative with its allocation of operands. It is " "assumed that an `out` can be written at any time, and can therefore not " "share its location with any other argument. However, to guarantee optimal " "performance it is important to use as few registers as possible, so they " "won't have to be saved and reloaded around the inline assembly block. To " "achieve this Rust provides a `lateout` specifier. This can be used on any " "output that is written only after all inputs have been consumed. There is " "also an `inlateout` variant of this specifier." msgstr "" "Rust 编译器在分配操作数时采取保守策略。它假设 `out` 可以在任何时候被写入，因" "此不能与其他参数共享位置。然而，为了保证最佳性能，使用尽可能少的寄存器很重" "要，这样就不必在内联汇编块前后保存和重新加载寄存器。为此，Rust 提供了 " "`lateout` 说明符。这可以用于任何在所有输入被消耗后才写入的输出。此外还有一个 " "`inlateout` 变体。" #: src/unsafe/asm.md:146 msgid "" "Here is an example where `inlateout` _cannot_ be used in `release` mode or " "other optimized cases:" msgstr "" "以下是一个在 `release` 模式或其他优化情况下 _不能_ 使用 `inlateout` 的例子：" #: src/unsafe/asm.md:157 src/unsafe/asm.md:189 src/unsafe/asm.md:472 msgid "\"add {0}, {1}\"" msgstr "\"add {0}, {1}\"" #: src/unsafe/asm.md:158 msgid "\"add {0}, {2}\"" msgstr "\"add {0}, {2}\"" #: src/unsafe/asm.md:168 msgid "" "In unoptimized cases (e.g. `Debug` mode), replacing `inout(reg) a` with " "`inlateout(reg) a` in the above example can continue to give the expected " "result. However, with `release` mode or other optimized cases, using " "`inlateout(reg) a` can instead lead to the final value `a = 16`, causing the " "assertion to fail." msgstr "" "在未优化的情况下（如 `Debug` 模式），将上述例子中的 `inout(reg) a` 替换为 " "`inlateout(reg) a` 仍能得到预期结果。但在 `release` 模式或其他优化情况下，使" "用 `inlateout(reg) a` 可能导致最终值 `a = 16`，使断言失败。" #: src/unsafe/asm.md:173 msgid "" "This is because in optimized cases, the compiler is free to allocate the " "same register for inputs `b` and `c` since it knows that they have the same " "value. Furthermore, when `inlateout` is used, `a` and `c` could be allocated " "to the same register, in which case the first `add` instruction would " "overwrite the initial load from variable `c`. This is in contrast to how " "using `inout(reg) a` ensures a separate register is allocated for `a`." msgstr "" "这是因为在优化情况下，编译器可以为输入 `b` 和 `c` 分配相同的寄存器，因为它知" "道它们具有相同的值。此外，当使用 `inlateout` 时，`a` 和 `c` 可能被分配到同一" "个寄存器，这种情况下，第一条 `add` 指令会覆盖从变量 `c` 初始加载的值。相比之" "下，使用 `inout(reg) a` 可以确保为 `a` 分配一个单独的寄存器。" #: src/unsafe/asm.md:179 msgid "" "However, the following example can use `inlateout` since the output is only " "modified after all input registers have been read:" msgstr "" "然而，以下示例可以使用 `inlateout`，因为输出仅在读取所有输入寄存器后才被修" "改：" #: src/unsafe/asm.md:195 msgid "" "As you can see, this assembly fragment will still work correctly if `a` and " "`b` are assigned to the same register." msgstr "" "如你所见，即使 `a` 和 `b` 被分配到同一个寄存器，这段汇编代码片段仍能正确运" "行。" #: src/unsafe/asm.md:197 msgid "Explicit register operands" msgstr "显式寄存器操作数" #: src/unsafe/asm.md:199 msgid "" "Some instructions require that the operands be in a specific register. " "Therefore, Rust inline assembly provides some more specific constraint " "specifiers. While `reg` is generally available on any architecture, explicit " "registers are highly architecture specific. E.g. for x86 the general purpose " "registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi` among others " "can be addressed by their name." msgstr "" "某些指令要求操作数必须位于特定寄存器中。因此，Rust 内联汇编提供了一些更具体的" "约束说明符。虽然 `reg` 通常适用于任何架构，但显式寄存器高度依赖于特定架构。例" "如，对于 x86 架构，通用寄存器如 `eax`、`ebx`、`ecx`、`edx`、`ebp`、`esi` 和 " "`edi` 等可以直接通过名称进行寻址。" #: src/unsafe/asm.md:209 msgid "\"out 0x64, eax\"" msgstr "\"out 0x64, eax\"" #: src/unsafe/asm.md:209 src/unsafe/asm.md:285 msgid "\"eax\"" msgstr "\"eax\"" #: src/unsafe/asm.md:214 msgid "" "In this example we call the `out` instruction to output the content of the " "`cmd` variable to port `0x64`. Since the `out` instruction only accepts " "`eax` (and its sub registers) as operand we had to use the `eax` constraint " "specifier." msgstr "" "在这个例子中，我们调用 `out` 指令将 `cmd` 变量的内容输出到端口 `0x64`。由于 " "`out` 指令只接受 `eax`（及其子寄存器）作为操作数，我们必须使用 `eax` 约束说明" "符。" #: src/unsafe/asm.md:216 msgid "" "**Note**: unlike other operand types, explicit register operands cannot be " "used in the template string: you can't use `{}` and should write the " "register name directly instead. Also, they must appear at the end of the " "operand list after all other operand types." msgstr "" "**注意**：与其他操作数类型不同，显式寄存器操作数不能在模板字符串中使用。你不" "能使用 `{}`，而应直接写入寄存器名称。此外，它们必须出现在操作数列表的末尾，位" "于所有其他操作数类型之后。" #: src/unsafe/asm.md:218 msgid "Consider this example which uses the x86 `mul` instruction:" msgstr "考虑以下使用 x86 `mul` 指令的例子：" #: src/unsafe/asm.md:230 msgid "" "// The x86 mul instruction takes rax as an implicit input and writes\n" " // the 128-bit result of the multiplication to rax:rdx.\n" " \"mul {}\"" msgstr "" "// x86 的 mul 指令将 rax 作为隐式输入，\n" " // 并将乘法的 128 位结果写入 rax:rdx。\n" " \"mul {}\"" #: src/unsafe/asm.md:234 src/unsafe/asm.md:356 msgid "\"rax\"" msgstr "\"rax\"" #: src/unsafe/asm.md:235 msgid "\"rdx\"" msgstr "\"rdx\"" #: src/unsafe/asm.md:244 msgid "" "This uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit " "result. The only explicit operand is a register, that we fill from the " "variable `a`. The second operand is implicit, and must be the `rax` " "register, which we fill from the variable `b`. The lower 64 bits of the " "result are stored in `rax` from which we fill the variable `lo`. The higher " "64 bits are stored in `rdx` from which we fill the variable `hi`." msgstr "" "这里使用 `mul` 指令将两个 64 位输入相乘，得到一个 128 位的结果。唯一的显式操" "作数是一个寄存器，我们用变量 `a` 填充它。第二个操作数是隐式的，必须是 `rax` " "寄存器，我们用变量 `b` 填充它。结果的低 64 位存储在 `rax` 中，用于填充变量 " "`lo`。高 64 位存储在 `rdx` 中，用于填充变量 `hi`。" #: src/unsafe/asm.md:250 msgid "Clobbered registers" msgstr "被破坏的寄存器" #: src/unsafe/asm.md:252 msgid "" "In many cases inline assembly will modify state that is not needed as an " "output. Usually this is either because we have to use a scratch register in " "the assembly or because instructions modify state that we don't need to " "further examine. This state is generally referred to as being \"clobbered\". " "We need to tell the compiler about this since it may need to save and " "restore this state around the inline assembly block." msgstr "" "在许多情况下，内联汇编会修改不需要作为输出的状态。这通常是因为我们必须在汇编" "中使用临时寄存器，或者因为指令修改了我们不需要进一步检查的状态。这种状态通常" "被称为\"被破坏\"。我们需要告知编译器这一点，因为它可能需要在内联汇编块前后保" "存和恢复这种状态。" #: src/unsafe/asm.md:262 msgid "// three entries of four bytes each\n" msgstr "// 三个条目，每个四字节\n" #: src/unsafe/asm.md:264 msgid "" "// String is stored as ascii in ebx, edx, ecx in order\n" " // Because ebx is reserved, the asm needs to preserve the value of it.\n" " // So we push and pop it around the main asm.\n" " // 64 bit mode on 64 bit processors does not allow pushing/popping of\n" " // 32 bit registers (like ebx), so we have to use the extended rbx " "register instead.\n" msgstr "" "// 字符串按顺序以 ASCII 格式存储在 ebx、edx、ecx 中\n" " // 由于 ebx 是保留寄存器，汇编需要保留其值\n" " // 因此我们在主要汇编代码前后执行 push 和 pop 操作\n" " // 64 位处理器的 64 位模式不允许对 32 位寄存器（如 ebx）进行 push/pop 操" "作\n" " // 所以我们必须使用扩展的 rbx 寄存器\n" #: src/unsafe/asm.md:272 msgid "\"push rbx\"" msgstr "\"push rbx\"" #: src/unsafe/asm.md:273 msgid "\"cpuid\"" msgstr "\"cpuid\"" #: src/unsafe/asm.md:274 msgid "\"mov [rdi], ebx\"" msgstr "\"mov [rdi], ebx\"" #: src/unsafe/asm.md:275 msgid "\"mov [rdi + 4], edx\"" msgstr "\"mov [rdi + 4], edx\"" #: src/unsafe/asm.md:276 msgid "\"mov [rdi + 8], ecx\"" msgstr "\"mov [rdi + 8], ecx\"" #: src/unsafe/asm.md:277 msgid "\"pop rbx\"" msgstr "\"pop rbx\"" #: src/unsafe/asm.md:278 msgid "" "// We use a pointer to an array for storing the values to simplify\n" " // the Rust code at the cost of a couple more asm instructions\n" " // This is more explicit with how the asm works however, as " "opposed\n" " // to explicit register outputs such as `out(\"ecx\") val`\n" " // The *pointer itself* is only an input even though it's " "written behind\n" msgstr "" "// 我们使用指向数组的指针来存储值，以简化 Rust 代码\n" " // 虽然这会增加几条汇编指令，但更清晰地展示了汇编的工作方式\n" " // 相比于使用显式寄存器输出（如 `out(\"ecx\") val`）\n" " // *指针本身*只是一个输入，尽管它在背后被写入\n" #: src/unsafe/asm.md:283 src/unsafe/asm.md:354 msgid "\"rdi\"" msgstr "\"rdi\"" #: src/unsafe/asm.md:284 msgid "// select cpuid 0, also specify eax as clobbered\n" msgstr "// 选择 cpuid 0，同时指定 eax 为被修改寄存器\n" #: src/unsafe/asm.md:286 msgid "// cpuid clobbers these registers too\n" msgstr "// cpuid 也会修改这些寄存器\n" #: src/unsafe/asm.md:287 msgid "\"ecx\"" msgstr "\"ecx\"" #: src/unsafe/asm.md:288 msgid "\"edx\"" msgstr "\"edx\"" #: src/unsafe/asm.md:293 msgid "\"CPU Manufacturer ID: {}\"" msgstr "\"CPU 制造商 ID：{}\"" #: src/unsafe/asm.md:300 msgid "" "In the example above we use the `cpuid` instruction to read the CPU " "manufacturer ID. This instruction writes to `eax` with the maximum supported " "`cpuid` argument and `ebx`, `edx`, and `ecx` with the CPU manufacturer ID as " "ASCII bytes in that order." msgstr "" "在上面的示例中，我们使用 `cpuid` 指令读取 CPU 制造商 ID。该指令将最大支持的 " "`cpuid` 参数写入 `eax`，并按顺序将 CPU 制造商 ID 的 ASCII 字节写入 `ebx`、" "`edx` 和 `ecx`。" #: src/unsafe/asm.md:303 msgid "" "Even though `eax` is never read we still need to tell the compiler that the " "register has been modified so that the compiler can save any values that " "were in these registers before the asm. This is done by declaring it as an " "output but with `_` instead of a variable name, which indicates that the " "output value is to be discarded." msgstr "" "尽管 `eax` 从未被读取，我们仍需要告知编译器该寄存器已被修改，这样编译器就可以" "保存汇编前这些寄存器中的任何值。我们通过将其声明为输出来实现这一点，但使用 " "`_` 而非变量名，表示输出值将被丢弃。" #: src/unsafe/asm.md:305 msgid "" "This code also works around the limitation that `ebx` is a reserved register " "by LLVM. That means that LLVM assumes that it has full control over the " "register and it must be restored to its original state before exiting the " "asm block, so it cannot be used as an input or output **except** if the " "compiler uses it to fulfill a general register class (e.g. `in(reg)`). This " "makes `reg` operands dangerous when using reserved registers as we could " "unknowingly corrupt our input or output because they share the same register." msgstr "" "这段代码还解决了 LLVM 将 `ebx` 视为保留寄存器的限制。这意味着 LLVM 假定它对该" "寄存器拥有完全控制权，并且必须在退出汇编块之前将其恢复到原始状态。因此，" "`ebx` 不能用作输入或输出，**除非**编译器将其用于满足通用寄存器类（如 " "`in(reg)`）。这使得在使用保留寄存器时，`reg` 操作数变得危险，因为我们可能会在" "不知情的情况下破坏输入或输出，原因是它们共享同一个寄存器。" #: src/unsafe/asm.md:307 msgid "" "To work around this we use `rdi` to store the pointer to the output array, " "save `ebx` via `push`, read from `ebx` inside the asm block into the array " "and then restore `ebx` to its original state via `pop`. The `push` and `pop` " "use the full 64-bit `rbx` version of the register to ensure that the entire " "register is saved. On 32 bit targets the code would instead use `ebx` in the " "`push`/`pop`." msgstr "" "为了解决这个问题，我们采用以下策略：使用 `rdi` 存储输出数组的指针；通过 " "`push` 保存 `ebx`；在汇编块内从 `ebx` 读取数据到数组中；然后通过 `pop` 将 " "`ebx` 恢复到原始状态。`push` 和 `pop` 操作使用完整的 64 位 `rbx` 寄存器版本，" "以确保整个寄存器被保存。在 32 位目标上，代码会在 `push`/`pop` 操作中使用 " "`ebx`。" #: src/unsafe/asm.md:309 msgid "" "This can also be used with a general register class to obtain a scratch " "register for use inside the asm code:" msgstr "" "这种技术还可以与通用寄存器类一起使用，以获得一个临时寄存器在汇编代码内使用：" #: src/unsafe/asm.md:314 msgid "// Multiply x by 6 using shifts and adds\n" msgstr "// 使用移位和加法将 x 乘以 6\n" #: src/unsafe/asm.md:319 msgid "\"mov {tmp}, {x}\"" msgstr "\"mov {tmp}, {x}\"" #: src/unsafe/asm.md:320 msgid "\"shl {tmp}, 1\"" msgstr "\"shl {tmp}, 1\"" #: src/unsafe/asm.md:321 msgid "\"shl {x}, 2\"" msgstr "\"shl {x}, 2\"" #: src/unsafe/asm.md:322 msgid "\"add {x}, {tmp}\"" msgstr "\"add {x}, {tmp}\"" #: src/unsafe/asm.md:331 msgid "Symbol operands and ABI clobbers" msgstr "符号操作数和 ABI 破坏" #: src/unsafe/asm.md:333 msgid "" "By default, `asm!` assumes that any register not specified as an output will " "have its contents preserved by the assembly code. The [`clobber_abi`]" "(https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-" "clobbers) argument to `asm!` tells the compiler to automatically insert the " "necessary clobber operands according to the given calling convention ABI: " "any register which is not fully preserved in that ABI will be treated as " "clobbered. Multiple `clobber_abi` arguments may be provided and all " "clobbers from all specified ABIs will be inserted." msgstr "" "默认情况下，`asm!` 假定汇编代码会保留所有未指定为输出的寄存器的内容。`asm!` " "的 [`clobber_abi`](https://doc.rust-lang.org/stable/reference/inline-" "assembly.html#abi-clobbers) 参数告诉编译器根据给定的调用约定 ABI 自动插入必要" "的破坏操作数：任何在该 ABI 中未完全保留的寄存器都将被视为被破坏。可以提供多" "个 `clobber_abi` 参数，所有指定 ABI 的破坏都将被插入。" #: src/unsafe/asm.md:341 src/unsafe/asm.md:359 msgid "\"C\"" msgstr "\"C\"" #: src/unsafe/asm.md:342 msgid "\"arg = {}\"" msgstr "\"arg = {}\"" #: src/unsafe/asm.md:350 msgid "\"call {}\"" msgstr "\"call {}\"" #: src/unsafe/asm.md:351 msgid "// Function pointer to call\n" msgstr "// 要调用的函数指针\n" #: src/unsafe/asm.md:353 msgid "// 1st argument in rdi\n" msgstr "// 第一个参数在 rdi 中\n" #: src/unsafe/asm.md:355 msgid "// Return value in rax\n" msgstr "// 返回值在 rax 中\n" #: src/unsafe/asm.md:357 msgid "" "// Mark all registers which are not preserved by the \"C\" calling\n" " // convention as clobbered.\n" msgstr "" "// 将所有不被 \"C\" 调用约定保留的寄存器\n" " // 标记为被破坏\n" #: src/unsafe/asm.md:367 msgid "Register template modifiers" msgstr "寄存器模板修饰符" #: src/unsafe/asm.md:369 msgid "" "In some cases, fine control is needed over the way a register name is " "formatted when inserted into the template string. This is needed when an " "architecture's assembly language has several names for the same register, " "each typically being a \"view\" over a subset of the register (e.g. the low " "32 bits of a 64-bit register)." msgstr "" "在某些情况下，需要对寄存器名称插入模板字符串时的格式进行精细控制。当一个架构" "的汇编语言对同一个寄存器有多个名称时，这种控制尤为必要。每个名称通常代表寄存" "器的一个子集\"视图\"（例如，64 位寄存器的低 32 位）。" #: src/unsafe/asm.md:371 msgid "" "By default the compiler will always choose the name that refers to the full " "register size (e.g. `rax` on x86-64, `eax` on x86, etc)." msgstr "" "默认情况下，编译器总是会选择引用完整寄存器大小的名称（例如，在 x86-64 上是 " "`rax`，在 x86 上是 `eax` 等）。" #: src/unsafe/asm.md:373 msgid "" "This default can be overridden by using modifiers on the template string " "operands, just like you would with format strings:" msgstr "" "可以通过在模板字符串操作数上使用修饰符来覆盖这个默认设置，类似于格式字符串的" "用法：" #: src/unsafe/asm.md:382 msgid "\"mov {0:h}, {0:l}\"" msgstr "\"mov {0:h}, {0:l}\"" #: src/unsafe/asm.md:389 msgid "" "In this example, we use the `reg_abcd` register class to restrict the " "register allocator to the 4 legacy x86 registers (`ax`, `bx`, `cx`, `dx`) of " "which the first two bytes can be addressed independently." msgstr "" "在这个例子中，我们使用 `reg_abcd` 寄存器类来限制寄存器分配器只使用 4 个传统" "的 x86 寄存器（`ax`、`bx`、`cx`、`dx`）。这些寄存器的前两个字节可以独立寻址。" #: src/unsafe/asm.md:391 msgid "" "Let us assume that the register allocator has chosen to allocate `x` in the " "`ax` register. The `h` modifier will emit the register name for the high " "byte of that register and the `l` modifier will emit the register name for " "the low byte. The asm code will therefore be expanded as `mov ah, al` which " "copies the low byte of the value into the high byte." msgstr "" "假设寄存器分配器选择将 `x` 分配到 `ax` 寄存器。`h` 修饰符将生成该寄存器高字节" "的名称，而 `l` 修饰符将生成低字节的名称。因此，汇编代码将被展开为 `mov ah, " "al`，这条指令将值的低字节复制到高字节。" #: src/unsafe/asm.md:394 msgid "" "If you use a smaller data type (e.g. `u16`) with an operand and forget to " "use template modifiers, the compiler will emit a warning and suggest the " "correct modifier to use." msgstr "" "如果你对操作数使用较小的数据类型（例如 `u16`）并忘记使用模板修饰符，编译器将" "发出警告并建议使用正确的修饰符。" #: src/unsafe/asm.md:396 msgid "Memory address operands" msgstr "内存地址操作数" #: src/unsafe/asm.md:398 msgid "" "Sometimes assembly instructions require operands passed via memory addresses/" "memory locations. You have to manually use the memory address syntax " "specified by the target architecture. For example, on x86/x86_64 using Intel " "assembly syntax, you should wrap inputs/outputs in `[]` to indicate they are " "memory operands:" msgstr "" "有时汇编指令需要通过内存地址或内存位置传递操作数。你必须手动使用目标架构指定" "的内存地址语法。例如，在使用 Intel 汇编语法的 x86/x86_64 架构上，你应该用 " "`[]` 包裹输入/输出，以表明它们是内存操作数：" #: src/unsafe/asm.md:408 msgid "\"fldcw [{}]\"" msgstr "\"fldcw [{}]\"" #: src/unsafe/asm.md:414 msgid "Labels" msgstr "标签" #: src/unsafe/asm.md:416 msgid "" "Any reuse of a named label, local or otherwise, can result in an assembler " "or linker error or may cause other strange behavior. Reuse of a named label " "can happen in a variety of ways including:" msgstr "" "重复使用命名标签（无论是局部的还是其他类型的）可能导致汇编器或链接器错误，或" "引起其他异常行为。命名标签的重用可能以多种方式发生，包括：" #: src/unsafe/asm.md:418 msgid "" "explicitly: using a label more than once in one `asm!` block, or multiple " "times across blocks." msgstr "显式重用：在一个 `asm!` 块中多次使用同一标签，或在多个块之间重复使用。" #: src/unsafe/asm.md:419 msgid "" "implicitly via inlining: the compiler is allowed to instantiate multiple " "copies of an `asm!` block, for example when the function containing it is " "inlined in multiple places." msgstr "" "通过内联隐式重用：编译器可能会创建 `asm!` 块的多个副本，例如当包含该块的函数" "在多处被内联时。" #: src/unsafe/asm.md:420 msgid "" "implicitly via LTO: LTO can cause code from _other crates_ to be placed in " "the same codegen unit, and so could bring in arbitrary labels." msgstr "" "通过 LTO 隐式重用：链接时优化（LTO）可能导致**其他 crate** 的代码被放置在同一" "代码生成单元中，从而可能引入任意标签。" #: src/unsafe/asm.md:422 msgid "" "As a consequence, you should only use GNU assembler **numeric** [local " "labels](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-" "Labels) inside inline assembly code. Defining symbols in assembly code may " "lead to assembler and/or linker errors due to duplicate symbol definitions." msgstr "" "因此，你应该只在内联汇编代码中使用 GNU 汇编器的**数字**[局部标签](https://" "sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels)。在汇编代码中" "定义符号可能会由于重复的符号定义而导致汇编器和/或链接器错误。" #: src/unsafe/asm.md:424 msgid "" "Moreover, on x86 when using the default Intel syntax, due to [an LLVM bug]" "(https://bugs.llvm.org/show_bug.cgi?id=36144), you shouldn't use labels " "exclusively made of `0` and `1` digits, e.g. `0`, `11` or `101010`, as they " "may end up being interpreted as binary values. Using `options(att_syntax)` " "will avoid any ambiguity, but that affects the syntax of the _entire_ `asm!` " "block. (See [Options](#options), below, for more on `options`.)" msgstr "" "此外，在 x86 架构上使用默认的 Intel 语法时，由于[一个 LLVM 的 bug](https://" "bugs.llvm.org/show_bug.cgi?id=36144)，你不应使用仅由 `0` 和 `1` 组成的标签，" "如 `0`、`11` 或 `101010`，因为它们可能被误解为二进制值。使用 " "`options(att_syntax)` 可以避免这种歧义，但这会影响*整个* `asm!` 块的语法。" "（关于 `options` 的更多信息，请参见下文的[选项](#options)。）" #: src/unsafe/asm.md:433 msgid "\"mov {0}, 10\"" msgstr "\"mov {0}, 10\"" #: src/unsafe/asm.md:434 src/unsafe/asm.md:439 msgid "\"2:\"" msgstr "\"2:\"" #: src/unsafe/asm.md:435 msgid "\"sub {0}, 1\"" msgstr "\"sub {0}, 1\"" #: src/unsafe/asm.md:436 msgid "\"cmp {0}, 3\"" msgstr "\"cmp {0}, 3\"" #: src/unsafe/asm.md:437 msgid "\"jle 2f\"" msgstr "\"jle 2f\"" #: src/unsafe/asm.md:438 msgid "\"jmp 2b\"" msgstr "\"jmp 2b\"" #: src/unsafe/asm.md:440 msgid "\"add {0}, 2\"" msgstr "\"add {0}, 2\"" #: src/unsafe/asm.md:448 msgid "" "This will decrement the `{0}` register value from 10 to 3, then add 2 and " "store it in `a`." msgstr "" "这段代码会将 `{0}` 寄存器的值从 10 递减到 3，然后加 2 并将结果存储在 `a` 中。" #: src/unsafe/asm.md:450 msgid "This example shows a few things:" msgstr "这个例子展示了几个要点：" #: src/unsafe/asm.md:452 msgid "" "First, that the same number can be used as a label multiple times in the " "same inline block." msgstr "首先，同一个数字可以在同一个内联块中多次用作标签。" #: src/unsafe/asm.md:453 msgid "" "Second, that when a numeric label is used as a reference (as an instruction " "operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) " "should be added to the numeric label. It will then refer to the nearest " "label defined by this number in this direction." msgstr "" "其次，当数字标签被用作引用（例如作为指令操作数）时，应在数字标签后添加后缀 " "\"b\"（\"backward\"，向后）或 \"f\"（\"forward\"，向前）。这样它将引用该方向" "上由这个数字定义的最近的标签。" #: src/unsafe/asm.md:458 msgid "Options" msgstr "选项" #: src/unsafe/asm.md:460 msgid "" "By default, an inline assembly block is treated the same way as an external " "FFI function call with a custom calling convention: it may read/write " "memory, have observable side effects, etc. However, in many cases it is " "desirable to give the compiler more information about what the assembly code " "is actually doing so that it can optimize better." msgstr "" "默认情况下，内联汇编块的处理方式与具有自定义调用约定的外部 FFI 函数调用相同：" "它可能读写内存，产生可观察的副作用等。然而，在许多情况下，我们希望向编译器提" "供更多关于汇编代码实际行为的信息，以便编译器能够进行更好的优化。" #: src/unsafe/asm.md:462 msgid "Let's take our previous example of an `add` instruction:" msgstr "让我们回顾一下之前 `add` 指令的例子：" #: src/unsafe/asm.md:481 msgid "" "Options can be provided as an optional final argument to the `asm!` macro. " "We specified three options here:" msgstr "" "可以将选项作为可选的最后一个参数传递给 `asm!` 宏。在这个例子中，我们指定了三" "个选项：" #: src/unsafe/asm.md:483 msgid "" "`pure` means that the asm code has no observable side effects and that its " "output depends only on its inputs. This allows the compiler optimizer to " "call the inline asm fewer times or even eliminate it entirely." msgstr "" "`pure`：表示汇编代码没有可观察的副作用，其输出仅依赖于输入。这使得编译器优化" "器能够减少内联汇编的调用次数，甚至完全消除它。" #: src/unsafe/asm.md:484 msgid "" "`nomem` means that the asm code does not read or write to memory. By default " "the compiler will assume that inline assembly can read or write any memory " "address that is accessible to it (e.g. through a pointer passed as an " "operand, or a global)." msgstr "" "`nomem`：表示汇编代码不读取或写入内存。默认情况下，编译器会假设内联汇编可以读" "写任何它可访问的内存地址（例如通过作为操作数传递的指针或全局变量）。" #: src/unsafe/asm.md:485 msgid "" "`nostack` means that the asm code does not push any data onto the stack. " "This allows the compiler to use optimizations such as the stack red zone on " "x86-64 to avoid stack pointer adjustments." msgstr "" "`nostack`：表示汇编代码不会向栈中压入任何数据。这允许编译器使用诸如 x86-64 上" "的栈红区等优化技术，以避免栈指针调整。" #: src/unsafe/asm.md:487 msgid "" "These allow the compiler to better optimize code using `asm!`, for example " "by eliminating pure `asm!` blocks whose outputs are not needed." msgstr "" "这些选项使编译器能够更好地优化使用 `asm!` 的代码，例如消除那些输出未被使用的" "纯 `asm!` 块。" #: src/unsafe/asm.md:489 msgid "" "See the [reference](https://doc.rust-lang.org/stable/reference/inline-" "assembly.html) for the full list of available options and their effects." msgstr "" "有关可用选项的完整列表及其效果，请参阅[参考文档](https://doc.rust-lang.org/" "stable/reference/inline-assembly.html)。" #: src/compatibility.md:3 msgid "" "The Rust language is evolving rapidly, and because of this certain " "compatibility issues can arise, despite efforts to ensure forwards-" "compatibility wherever possible." msgstr "" "Rust 语言正在快速发展，因此某些兼容性问题可能会出现，尽管我们努力确保尽可能的" "向前兼容。" #: src/compatibility.md:7 msgid "[Raw identifiers](compatibility/raw_identifiers.md)" msgstr "[原始标识符](compatibility/raw_identifiers.md)" #: src/compatibility/raw_identifiers.md:3 msgid "" "Rust, like many programming languages, has the concept of \"keywords\". " "These identifiers mean something to the language, and so you cannot use them " "in places like variable names, function names, and other places. Raw " "identifiers let you use keywords where they would not normally be allowed. " "This is particularly useful when Rust introduces new keywords, and a library " "using an older edition of Rust has a variable or function with the same name " "as a keyword introduced in a newer edition." msgstr "" "Rust 和许多编程语言一样，有\"关键字\"的概念。这些标识符在语言中具有特殊含义，" "因此你不能在变量名、函数名等地方使用它们。原始标识符允许你在通常不允许使用关" "键字的地方使用它们。这在 Rust 引入新关键字，而使用旧版本 Rust 的库中有与新版" "本引入的关键字同名的变量或函数时特别有用。" #: src/compatibility/raw_identifiers.md:11 msgid "" "For example, consider a crate `foo` compiled with the 2015 edition of Rust " "that exports a function named `try`. This keyword is reserved for a new " "feature in the 2018 edition, so without raw identifiers, we would have no " "way to name the function." msgstr "" "例如，假设有一个使用 Rust 2015 版编译的 crate `foo`，它导出了一个名为 `try` " "的函数。这个关键字在 2018 版中被保留用于新特性，如果没有原始标识符，我们就无" "法命名这个函数。" #: src/compatibility/raw_identifiers.md:24 msgid "You'll get this error:" msgstr "你会得到这个错误：" #: src/compatibility/raw_identifiers.md:34 msgid "You can write this with a raw identifier:" msgstr "你可以使用原始标识符这样写：" #: src/meta.md:3 msgid "" "Some topics aren't exactly relevant to how you program runs but provide you " "tooling or infrastructure support which just makes things better for " "everyone. These topics include:" msgstr "" "有些主题虽然与程序如何运行不直接相关，但它们提供了工具或基础设施支持，使得整" "个开发生态变得更好。这些主题包括：" #: src/meta.md:7 msgid "" "[Documentation](meta/doc.md): Generate library documentation for users via " "the included `rustdoc`." msgstr "[文档](meta/doc.md)：使用内置的 `rustdoc` 为用户生成库文档。" #: src/meta.md:9 msgid "" "[Playground](meta/playground.md): Integrate the Rust Playground in your " "documentation." msgstr "[Playground](meta/playground.md)：在文档中集成 Rust Playground。" #: src/meta/doc.md:3 msgid "" "Use `cargo doc` to build documentation in `target/doc`, `cargo doc --open` " "will automatically open it in your web browser." msgstr "" "使用 `cargo doc` 在 `target/doc` 目录下构建文档。运行 `cargo doc --open` 将自" "动在浏览器中打开文档。" #: src/meta/doc.md:6 msgid "" "Use `cargo test` to run all tests (including documentation tests), and " "`cargo test --doc` to only run documentation tests." msgstr "" "使用 `cargo test` 运行所有测试（包括文档测试）。如果只想运行文档测试，请使用 " "`cargo test --doc`。" #: src/meta/doc.md:9 msgid "" "These commands will appropriately invoke `rustdoc` (and `rustc`) as required." msgstr "这些命令会根据需要适当地调用 `rustdoc`（和 `rustc`）。" #: src/meta/doc.md:11 msgid "Doc comments" msgstr "文档注释" #: src/meta/doc.md:13 msgid "" "Doc comments are very useful for big projects that require documentation. " "When running `rustdoc`, these are the comments that get compiled into " "documentation. They are denoted by a `///`, and support [Markdown](https://" "en.wikipedia.org/wiki/Markdown)." msgstr "" "文档注释对需要文档的大型项目非常有用。运行 `rustdoc` 时，这些注释会被编译成文" "档。文档注释以 `///` 开头，并支持 [Markdown](https://zh.wikipedia.org/wiki/" "Markdown) 语法。" #: src/meta/doc.md:18 msgid "\"doc\"" msgstr "\"doc\"" #: src/meta/doc.md:19 msgid "/// A human being is represented here\n" msgstr "/// 这里表示一个人类\n" #: src/meta/doc.md:22 msgid "/// A person must have a name, no matter how much Juliet may hate it\n" msgstr "/// 一个人必须有名字，不管朱丽叶有多么讨厌这一点\n" #: src/meta/doc.md:27 msgid "" "/// Creates a person with the given name.\n" " ///\n" " /// # Examples\n" " ///\n" " /// ```\n" " /// // You can have rust code between fences inside the comments\n" " /// // If you pass --test to `rustdoc`, it will even test it for you!\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" msgstr "" "/// 创建一个具有给定名字的人。\n" " ///\n" " /// # 示例\n" " ///\n" " /// ```\n" " /// // 你可以在注释中的代码块里编写 Rust 代码\n" " /// // 如果向 `rustdoc` 传递 --test 参数，它甚至会为你测试这段代码！\n" " /// use doc::Person;\n" " /// let person = Person::new(\"name\");\n" " /// ```\n" #: src/meta/doc.md:43 msgid "" "/// Gives a friendly hello!\n" " ///\n" " /// Says \"Hello, [name](Person::name)\" to the `Person` it is called " "on.\n" msgstr "" "/// 给出友好的问候！\n" " ///\n" " /// 对调用此方法的 `Person` 说 \"Hello, [name](Person::name)\"。\n" #: src/meta/doc.md:47 msgid "\"Hello, {}!\"" msgstr "\"Hello, {}!\"" #: src/meta/doc.md:52 msgid "\"John\"" msgstr "\"John\"" #: src/meta/doc.md:58 msgid "" "To run the tests, first build the code as a library, then tell `rustdoc` " "where to find the library so it can link it into each doctest program:" msgstr "" "要运行测试，首先将代码构建为库，然后告诉 `rustdoc` 库的位置，以便它可以将库链" "接到每个文档测试程序中：" #: src/meta/doc.md:61 msgid "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" msgstr "" "```shell\n" "$ rustc doc.rs --crate-type lib\n" "$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n" "```" #: src/meta/doc.md:66 msgid "Doc attributes" msgstr "文档属性" #: src/meta/doc.md:68 msgid "" "Below are a few examples of the most common `#[doc]` attributes used with " "`rustdoc`." msgstr "以下是几个与 `rustdoc` 配合使用的最常见 `#[doc]` 属性示例。" #: src/meta/doc.md:71 msgid "`inline`" msgstr "`inline`" #: src/meta/doc.md:73 msgid "Used to inline docs, instead of linking out to separate page." msgstr "用于内联文档，而非链接到单独的页面。" #: src/meta/doc.md:78 msgid "/// bar docs\n" msgstr "/// bar 的文档\n" #: src/meta/doc.md:81 msgid "/// the docs for Bar\n" msgstr "/// Bar 的文档\n" #: src/meta/doc.md:86 msgid "`no_inline`" msgstr "`no_inline`" #: src/meta/doc.md:88 msgid "Used to prevent linking out to separate page or anywhere." msgstr "用于防止链接到单独页面或其他任何地方。" #: src/meta/doc.md:91 msgid "// Example from libcore/prelude\n" msgstr "// libcore/prelude 中的示例\n" #: src/meta/doc.md:96 msgid "`hidden`" msgstr "`hidden`" #: src/meta/doc.md:98 msgid "Using this tells `rustdoc` not to include this in documentation:" msgstr "使用此属性告诉 `rustdoc` 不要在文档中包含此内容：" #: src/meta/doc.md:101 msgid "// Example from the futures-rs library\n" msgstr "// futures-rs 库中的示例\n" #: src/meta/doc.md:106 msgid "" "For documentation, `rustdoc` is widely used by the community. It's what is " "used to generate the [std library docs](https://doc.rust-lang.org/std/)." msgstr "" "在文档生成方面，`rustdoc` 被社区广泛使用。它是用来生成 [标准库文档](https://" "doc.rust-lang.org/std/) 的工具。" #: src/meta/doc.md:111 msgid "" "[The Rust Book: Making Useful Documentation Comments](https://doc.rust-" "lang.org/book/ch14-02-publishing-to-crates-io.html#making-useful-" "documentation-comments)" msgstr "" "[《Rust 程序设计语言》：编写有用的文档注释](https://doc.rust-lang.org/book/" "ch14-02-publishing-to-crates-io.html#making-useful-documentation-comments)" #: src/meta/doc.md:112 msgid "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/index.html)" msgstr "[rustdoc 手册](https://doc.rust-lang.org/rustdoc/index.html)" #: src/meta/doc.md:113 msgid "" "[The Reference: Doc comments](https://doc.rust-lang.org/stable/reference/" "comments.html#doc-comments)" msgstr "" "[Rust 参考手册：文档注释](https://doc.rust-lang.org/stable/reference/" "comments.html#doc-comments)" #: src/meta/doc.md:114 msgid "" "[RFC 1574: API Documentation Conventions](https://rust-lang.github.io/rfcs/" "1574-more-api-documentation-conventions.html#appendix-a-full-conventions-" "text)" msgstr "" "[RFC 1574：API 文档约定](https://rust-lang.github.io/rfcs/1574-more-api-" "documentation-conventions.html#appendix-a-full-conventions-text)" #: src/meta/doc.md:115 msgid "" "[RFC 1946: Relative links to other items from doc comments (intra-rustdoc " "links)](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)" msgstr "" "[RFC 1946：文档注释中的相对链接（rustdoc 内部链接）](https://rust-" "lang.github.io/rfcs/1946-intra-rustdoc-links.html)" #: src/meta/doc.md:116 msgid "" "[Is there any documentation style guide for comments? (reddit)](https://" "www.reddit.com/r/rust/comments/ahb50s/" "is_there_any_documentation_style_guide_for/)" msgstr "" "[有关注释的文档风格指南？（Reddit 讨论）](https://www.reddit.com/r/rust/" "comments/ahb50s/is_there_any_documentation_style_guide_for/)" #: src/meta/playground.md:3 msgid "" "The [Rust Playground](https://play.rust-lang.org/) is a way to experiment " "with Rust code through a web interface." msgstr "" "[Rust Playground](https://play.rust-lang.org/) 是一个通过网页界面体验 Rust 代" "码的平台。" #: src/meta/playground.md:6 msgid "Using it with `mdbook`" msgstr "在 `mdbook` 中使用 Playground" #: src/meta/playground.md:8 msgid "" "In [`mdbook`](https://github.com/rust-lang/mdBook), you can make code " "examples playable and editable." msgstr "" "在 [`mdbook`](https://github.com/rust-lang/mdBook) 中，你可以让代码示例变得可" "运行和可编辑。" #: src/meta/playground.md:16 msgid "" "This allows the reader to both run your code sample, but also modify and " "tweak it. The key here is the adding of the word `editable` to your " "codefence block separated by a comma." msgstr "" "这不仅允许读者运行你的代码示例，还能修改和调整它。关键是在代码块标记中添加 " "`editable` 关键字，用逗号分隔。" #: src/meta/playground.md:26 msgid "" "Additionally, you can add `ignore` if you want `mdbook` to skip your code " "when it builds and tests." msgstr "" "此外，如果你希望 `mdbook` 在构建和测试时跳过某段代码，可以添加 `ignore` 关键" "字。" #: src/meta/playground.md:35 msgid "Using it with docs" msgstr "在文档中使用 Playground" #: src/meta/playground.md:37 msgid "" "You may have noticed in some of the [official Rust docs](https://doc.rust-" "lang.org/core/) a button that says \"Run\", which opens the code sample up " "in a new tab in Rust Playground. This feature is enabled if you use the " "`#[doc]` attribute called [`html_playground_url`](https://doc.rust-lang.org/" "rustdoc/write-documentation/the-doc-attribute.html#html_playground_url)." msgstr "" "你可能注意到在一些[官方 Rust 文档](https://doc.rust-lang.org/core/)中有一个" "\"运行\"按钮，点击后会在 Rust Playground 的新标签页中打开代码示例。要启用此功" "能，需要使用 `#[doc]` 属性中的 [`html_playground_url`](https://doc.rust-" "lang.org/rustdoc/write-documentation/the-doc-" "attribute.html#html_playground_url)。" #: src/meta/playground.md:42 msgid "" "````text\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" msgstr "" "````text\n" "#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n" "//! ```\n" "//! println!(\"Hello World\");\n" "//! ```\n" "````" #: src/meta/playground.md:51 msgid "[The Rust Playground](https://play.rust-lang.org/)" msgstr "[Rust Playground](https://play.rust-lang.org/)" #: src/meta/playground.md:52 msgid "" "[The Rust Playground On Github](https://github.com/integer32llc/rust-" "playground/)" msgstr "" "[GitHub 上的 Rust Playground](https://github.com/integer32llc/rust-" "playground/)" #: src/meta/playground.md:53 msgid "" "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)" msgstr "[rustdoc 手册](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)" ================================================ FILE: src/SUMMARY.md ================================================ # Summary [Introduction](index.md) - [Hello World](hello.md) - [Comments](hello/comment.md) - [Formatted print](hello/print.md) - [Debug](hello/print/print_debug.md) - [Display](hello/print/print_display.md) - [Testcase: List](hello/print/print_display/testcase_list.md) - [Formatting](hello/print/fmt.md) - [Primitives](primitives.md) - [Literals and operators](primitives/literals.md) - [Tuples](primitives/tuples.md) - [Arrays and Slices](primitives/array.md) - [Custom Types](custom_types.md) - [Structures](custom_types/structs.md) - [Enums](custom_types/enum.md) - [use](custom_types/enum/enum_use.md) - [C-like](custom_types/enum/c_like.md) - [Testcase: linked-list](custom_types/enum/testcase_linked_list.md) - [constants](custom_types/constants.md) - [Variable Bindings](variable_bindings.md) - [Mutability](variable_bindings/mut.md) - [Scope and Shadowing](variable_bindings/scope.md) - [Declare first](variable_bindings/declare.md) - [Freezing](variable_bindings/freeze.md) - [Types](types.md) - [Casting](types/cast.md) - [Literals](types/literals.md) - [Inference](types/inference.md) - [Aliasing](types/alias.md) - [Conversion](conversion.md) - [`From` and `Into`](conversion/from_into.md) - [`TryFrom` and `TryInto`](conversion/try_from_try_into.md) - [To and from `String`s](conversion/string.md) - [Expressions](expression.md) - [Flow of Control](flow_control.md) - [if/else](flow_control/if_else.md) - [loop](flow_control/loop.md) - [Nesting and labels](flow_control/loop/nested.md) - [Returning from loops](flow_control/loop/return.md) - [while](flow_control/while.md) - [for and range](flow_control/for.md) - [match](flow_control/match.md) - [Destructuring](flow_control/match/destructuring.md) - [tuples](flow_control/match/destructuring/destructure_tuple.md) - [arrays/slices](flow_control/match/destructuring/destructure_slice.md) - [enums](flow_control/match/destructuring/destructure_enum.md) - [pointers/ref](flow_control/match/destructuring/destructure_pointers.md) - [structs](flow_control/match/destructuring/destructure_structures.md) - [Guards](flow_control/match/guard.md) - [Binding](flow_control/match/binding.md) - [if let](flow_control/if_let.md) - [let-else](flow_control/let_else.md) - [while let](flow_control/while_let.md) - [Functions](fn.md) - [Methods](fn/methods.md) - [Closures](fn/closures.md) - [Capturing](fn/closures/capture.md) - [As input parameters](fn/closures/input_parameters.md) - [Type anonymity](fn/closures/anonymity.md) - [Input functions](fn/closures/input_functions.md) - [As output parameters](fn/closures/output_parameters.md) - [Examples in `std`](fn/closures/closure_examples.md) - [Iterator::any](fn/closures/closure_examples/iter_any.md) - [Searching through iterators](fn/closures/closure_examples/iter_find.md) - [Higher Order Functions](fn/hof.md) - [Diverging functions](fn/diverging.md) - [Modules](mod.md) - [Visibility](mod/visibility.md) - [Struct visibility](mod/struct_visibility.md) - [The `use` declaration](mod/use.md) - [`super` and `self`](mod/super.md) - [File hierarchy](mod/split.md) - [Crates](crates.md) - [Creating a Library](crates/lib.md) - [Using a Library](crates/using_lib.md) - [Cargo](cargo.md) - [Dependencies](cargo/deps.md) - [Conventions](cargo/conventions.md) - [Tests](cargo/test.md) - [Build Scripts](cargo/build_scripts.md) - [Attributes](attribute.md) - [`dead_code`](attribute/unused.md) - [Crates](attribute/crate.md) - [`cfg`](attribute/cfg.md) - [Custom](attribute/cfg/custom.md) - [Generics](generics.md) - [Functions](generics/gen_fn.md) - [Implementation](generics/impl.md) - [Traits](generics/gen_trait.md) - [Bounds](generics/bounds.md) - [Testcase: empty bounds](generics/bounds/testcase_empty.md) - [Multiple bounds](generics/multi_bounds.md) - [Where clauses](generics/where.md) - [New Type Idiom](generics/new_types.md) - [Associated items](generics/assoc_items.md) - [The Problem](generics/assoc_items/the_problem.md) - [Associated types](generics/assoc_items/types.md) - [Phantom type parameters](generics/phantom.md) - [Testcase: unit clarification](generics/phantom/testcase_units.md) - [Scoping rules](scope.md) - [RAII](scope/raii.md) - [Ownership and moves](scope/move.md) - [Mutability](scope/move/mut.md) - [Partial moves](scope/move/partial_move.md) - [Borrowing](scope/borrow.md) - [Mutability](scope/borrow/mut.md) - [Aliasing](scope/borrow/alias.md) - [The ref pattern](scope/borrow/ref.md) - [Lifetimes](scope/lifetime.md) - [Explicit annotation](scope/lifetime/explicit.md) - [Functions](scope/lifetime/fn.md) - [Methods](scope/lifetime/methods.md) - [Structs](scope/lifetime/struct.md) - [Traits](scope/lifetime/trait.md) - [Bounds](scope/lifetime/lifetime_bounds.md) - [Coercion](scope/lifetime/lifetime_coercion.md) - [Static](scope/lifetime/static_lifetime.md) - [Elision](scope/lifetime/elision.md) - [Traits](trait.md) - [Derive](trait/derive.md) - [Returning Traits with `dyn`](trait/dyn.md) - [Operator Overloading](trait/ops.md) - [Drop](trait/drop.md) - [Iterators](trait/iter.md) - [`impl Trait`](trait/impl_trait.md) - [Clone](trait/clone.md) - [Supertraits](trait/supertraits.md) - [Disambiguating overlapping traits](trait/disambiguating.md) - [macro_rules!](macros.md) - [Syntax](macros/syntax.md) - [Designators](macros/designators.md) - [Overload](macros/overload.md) - [Repeat](macros/repeat.md) - [DRY (Don't Repeat Yourself)](macros/dry.md) - [DSL (Domain Specific Languages)](macros/dsl.md) - [Variadics](macros/variadics.md) - [Error handling](error.md) - [`panic`](error/panic.md) - [`abort` & `unwind`](error/abort_unwind.md) - [`Option` & `unwrap`](error/option_unwrap.md) - [Unpacking options with `?`](error/option_unwrap/question_mark.md) - [Combinators: `map`](error/option_unwrap/map.md) - [Combinators: `and_then`](error/option_unwrap/and_then.md) - [Defaults: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`](error/option_unwrap/defaults.md) - [`Result`](error/result.md) - [`map` for `Result`](error/result/result_map.md) - [aliases for `Result`](error/result/result_alias.md) - [Early returns](error/result/early_returns.md) - [Introducing `?`](error/result/enter_question_mark.md) - [Multiple error types](error/multiple_error_types.md) - [Pulling `Result`s out of `Option`s](error/multiple_error_types/option_result.md) - [Defining an error type](error/multiple_error_types/define_error_type.md) - [`Box`ing errors](error/multiple_error_types/boxing_errors.md) - [Other uses of `?`](error/multiple_error_types/reenter_question_mark.md) - [Wrapping errors](error/multiple_error_types/wrap_error.md) - [Iterating over `Result`s](error/iter_result.md) - [Std library types](std.md) - [Box, stack and heap](std/box.md) - [Vectors](std/vec.md) - [Strings](std/str.md) - [`Option`](std/option.md) - [`Result`](std/result.md) - [`?`](std/result/question_mark.md) - [`panic!`](std/panic.md) - [HashMap](std/hash.md) - [Alternate/custom key types](std/hash/alt_key_types.md) - [HashSet](std/hash/hashset.md) - [`Rc`](std/rc.md) - [`Arc`](std/arc.md) - [Std misc](std_misc.md) - [Threads](std_misc/threads.md) - [Testcase: map-reduce](std_misc/threads/testcase_mapreduce.md) - [Channels](std_misc/channels.md) - [Path](std_misc/path.md) - [File I/O](std_misc/file.md) - [`open`](std_misc/file/open.md) - [`create`](std_misc/file/create.md) - [`read_lines`](std_misc/file/read_lines.md) - [Child processes](std_misc/process.md) - [Pipes](std_misc/process/pipe.md) - [Wait](std_misc/process/wait.md) - [Filesystem Operations](std_misc/fs.md) - [Program arguments](std_misc/arg.md) - [Argument parsing](std_misc/arg/matching.md) - [Foreign Function Interface](std_misc/ffi.md) - [Testing](testing.md) - [Unit testing](testing/unit_testing.md) - [Documentation testing](testing/doc_testing.md) - [Integration testing](testing/integration_testing.md) - [Dev-dependencies](testing/dev_dependencies.md) - [Unsafe Operations](unsafe.md) - [Inline assembly](unsafe/asm.md) - [Compatibility](compatibility.md) - [Raw identifiers](compatibility/raw_identifiers.md) - [Meta](meta.md) - [Documentation](meta/doc.md) - [Playground](meta/playground.md) ================================================ FILE: src/attribute/cfg/custom.md ================================================ # Custom Some conditionals like `target_os` are implicitly provided by `rustc`, but custom conditionals must be passed to `rustc` using the `--cfg` flag. ```rust,editable,ignore,mdbook-runnable #[cfg(some_condition)] fn conditional_function() { println!("condition met!"); } fn main() { conditional_function(); } ``` Try to run this to see what happens without the custom `cfg` flag. With the custom `cfg` flag: ```shell $ rustc --cfg some_condition custom.rs && ./custom condition met! ``` ================================================ FILE: src/attribute/cfg.md ================================================ # `cfg` Configuration conditional checks are possible through two different operators: * the `cfg` attribute: `#[cfg(...)]` in attribute position * the `cfg!` macro: `cfg!(...)` in boolean expressions While the former enables conditional compilation, the latter conditionally evaluates to `true` or `false` literals allowing for checks at run-time. Both utilize identical argument syntax. `cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true or false. For example, all blocks in an if/else expression need to be valid when `cfg!` is used for the condition, regardless of what `cfg!` is evaluating. ```rust,editable // This function only gets compiled if the target OS is linux #[cfg(target_os = "linux")] fn are_you_on_linux() { println!("You are running linux!"); } // And this function only gets compiled if the target OS is *not* linux #[cfg(not(target_os = "linux"))] fn are_you_on_linux() { println!("You are *not* running linux!"); } fn main() { are_you_on_linux(); println!("Are you sure?"); if cfg!(target_os = "linux") { println!("Yes. It's definitely linux!"); } else { println!("Yes. It's definitely *not* linux!"); } } ``` ### See also: [the reference][ref], [`cfg!`][cfg], and [macros][macros]. [cfg]: https://doc.rust-lang.org/std/macro.cfg!.html [macros]: ../macros.md [ref]: https://doc.rust-lang.org/reference/attributes.html#conditional-compilation ================================================ FILE: src/attribute/crate.md ================================================ # Crates The `crate_type` attribute can be used to tell the compiler whether a crate is a binary or a library (and even which type of library), and the `crate_name` attribute can be used to set the name of the crate. However, it is important to note that both the `crate_type` and `crate_name` attributes have **no** effect whatsoever when using Cargo, the Rust package manager. Since Cargo is used for the majority of Rust projects, this means real-world uses of `crate_type` and `crate_name` are relatively limited. ```rust,editable // This crate is a library #![crate_type = "lib"] // The library is named "rary" #![crate_name = "rary"] pub fn public_function() { println!("called rary's `public_function()`"); } fn private_function() { println!("called rary's `private_function()`"); } pub fn indirect_access() { print!("called rary's `indirect_access()`, that\n> "); private_function(); } ``` When the `crate_type` attribute is used, we no longer need to pass the `--crate-type` flag to `rustc`. ```shell $ rustc lib.rs $ ls lib* library.rlib ``` ================================================ FILE: src/attribute/unused.md ================================================ # `dead_code` The compiler provides a `dead_code` [*lint*][lint] that will warn about unused functions. An *attribute* can be used to disable the lint. ```rust,editable fn used_function() {} // `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint #[allow(dead_code)] fn unused_function() {} fn noisy_unused_function() {} // FIXME ^ Add an attribute to suppress the warning fn main() { used_function(); } ``` Note that in real programs, you should eliminate dead code. In these examples we'll allow dead code in some places because of the interactive nature of the examples. [lint]: https://en.wikipedia.org/wiki/Lint_%28software%29 ================================================ FILE: src/attribute.md ================================================ # Attributes An attribute is metadata applied to some module, crate or item. This metadata can be used to/for: * [conditional compilation of code][cfg] * [set crate name, version and type (binary or library)][crate] * disable [lints][lint] (warnings) * enable compiler features (macros, glob imports, etc.) * link to a foreign library * mark functions as unit tests * mark functions that will be part of a benchmark * [attribute like macros][macros] Attributes look like `#[outer_attribute]` or `#![inner_attribute]`, with the difference between them being where they apply. * `#[outer_attribute]` applies to the [item][item] immediately following it. Some examples of items are: a function, a module declaration, a constant, a structure, an enum. Here is an example where attribute `#[derive(Debug)]` applies to the struct `Rectangle`: ```rust #[derive(Debug)] struct Rectangle { width: u32, height: u32, } ``` * `#![inner_attribute]` applies to the enclosing [item][item] (typically a module or a crate). In other words, this attribute is interpreted as applying to the entire scope in which it's placed. Here is an example where `#![allow(unused_variables)]` applies to the whole crate (if placed in `main.rs`): ```rust #![allow(unused_variables)] fn main() { let x = 3; // This would normally warn about an unused variable. } ``` Attributes can take arguments with different syntaxes: * `#[attribute = "value"]` * `#[attribute(key = "value")]` * `#[attribute(value)]` Attributes can have multiple values and can be separated over multiple lines, too: ```rust,ignore #[attribute(value, value2)] #[attribute(value, value2, value3, value4, value5)] ``` [cfg]: attribute/cfg.md [crate]: attribute/crate.md [item]: https://doc.rust-lang.org/stable/reference/items.html [lint]: https://en.wikipedia.org/wiki/Lint_%28software%29 [macros]: https://doc.rust-lang.org/book/ch19-06-macros.html#attribute-like-macros ================================================ FILE: src/cargo/build_scripts.md ================================================ # Build Scripts Sometimes a normal build from `cargo` is not enough. Perhaps your crate needs some pre-requisites before `cargo` will successfully compile, things like code generation, or some native code that needs to be compiled. To solve this problem we have build scripts that Cargo can run. To add a build script to your package it can either be specified in the `Cargo.toml` as follows: ```toml [package] ... build = "build.rs" ``` Otherwise Cargo will look for a `build.rs` file in the project directory by default. ## How to use a build script The build script is simply another Rust file that will be compiled and invoked prior to compiling anything else in the package. Hence it can be used to fulfill pre-requisites of your crate. Cargo provides the script with inputs via environment variables [specified here] that can be used. The script provides output via stdout. All lines printed are written to `target/debug/build//output`. Further, lines prefixed with `cargo:` will be interpreted by Cargo directly and hence can be used to define parameters for the package's compilation. For further specification and examples have a read of the [Cargo specification][cargo_specification]. [specified here]: https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-build-scripts [cargo_specification]: https://doc.rust-lang.org/cargo/reference/build-scripts.html ================================================ FILE: src/cargo/conventions.md ================================================ # Conventions In the previous chapter, we saw the following directory hierarchy: ```txt foo ├── Cargo.toml └── src └── main.rs ``` Suppose that we wanted to have two binaries in the same project, though. What then? It turns out that `cargo` supports this. The default binary name is `main`, as we saw before, but you can add additional binaries by placing them in a `bin/` directory: ```txt foo ├── Cargo.toml └── src ├── main.rs └── bin └── my_other_bin.rs ``` To tell `cargo` to only compile or run this binary, we just pass `cargo` the `--bin my_other_bin` flag, where `my_other_bin` is the name of the binary we want to work with. In addition to extra binaries, `cargo` supports [more features] such as benchmarks, tests, and examples. In the next chapter, we will look more closely at tests. [more features]: https://doc.rust-lang.org/cargo/guide/project-layout.html ================================================ FILE: src/cargo/deps.md ================================================ # Dependencies Most programs have dependencies on some libraries. If you have ever managed dependencies by hand, you know how much of a pain this can be. Luckily, the Rust ecosystem comes standard with `cargo`! `cargo` can manage dependencies for a project. To create a new Rust project, ```sh # A binary cargo new foo # A library cargo new --lib bar ``` For the rest of this chapter, let's assume we are making a binary, rather than a library, but all of the concepts are the same. After the above commands, you should see a file hierarchy like this: ```txt . ├── bar │ ├── Cargo.toml │ └── src │ └── lib.rs └── foo ├── Cargo.toml └── src └── main.rs ``` The `main.rs` is the root source file for your new `foo` project -- nothing new there. The `Cargo.toml` is the config file for `cargo` for this project. If you look inside it, you should see something like this: ```toml [package] name = "foo" version = "0.1.0" authors = ["mark"] [dependencies] ``` The `name` field under `[package]` determines the name of the project. This is used by `crates.io` if you publish the crate (more later). It is also the name of the output binary when you compile. The `version` field is a crate version number using [Semantic Versioning](http://semver.org/). The `authors` field is a list of authors used when publishing the crate. The `[dependencies]` section lets you add dependencies for your project. For example, suppose that we want our program to have a great CLI. You can find lots of great packages on [crates.io](https://crates.io) (the official Rust package registry). One popular choice is [clap](https://crates.io/crates/clap). As of this writing, the most recent published version of `clap` is `2.27.1`. To add a dependency to our program, we can simply add the following to our `Cargo.toml` under `[dependencies]`: `clap = "2.27.1"`. And that's it! You can start using `clap` in your program. `cargo` also supports [other types of dependencies][dependencies]. Here is just a small sampling: ```toml [package] name = "foo" version = "0.1.0" authors = ["mark"] [dependencies] clap = "2.27.1" # from crates.io rand = { git = "https://github.com/rust-lang-nursery/rand" } # from online repo bar = { path = "../bar" } # from a path in the local filesystem ``` `cargo` is more than a dependency manager. All of the available configuration options are listed in the [format specification][manifest] of `Cargo.toml`. To build our project we can execute `cargo build` anywhere in the project directory (including subdirectories!). We can also do `cargo run` to build and run. Notice that these commands will resolve all dependencies, download crates if needed, and build everything, including your crate. (Note that it only rebuilds what it has not already built, similar to `make`). Voila! That's all there is to it! [manifest]: https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html ================================================ FILE: src/cargo/test.md ================================================ # Testing As we know testing is integral to any piece of software! Rust has first-class support for unit and integration testing ([see this chapter](https://doc.rust-lang.org/book/ch11-00-testing.html) in TRPL). From the testing chapters linked above, we see how to write unit tests and integration tests. Organizationally, we can place unit tests in the modules they test and integration tests in their own `tests/` directory: ```txt foo ├── Cargo.toml ├── src │ └── main.rs │ └── lib.rs └── tests ├── my_test.rs └── my_other_test.rs ``` Each file in `tests` is a separate [integration test](https://doc.rust-lang.org/book/ch11-03-test-organization.html#integration-tests), i.e. a test that is meant to test your library as if it were being called from a dependent crate. The [Testing][testing] chapter elaborates on the three different testing styles: [Unit][unit_testing], [Doc][doc_testing], and [Integration][integration_testing]. `cargo` naturally provides an easy way to run all of your tests! ```shell $ cargo test ``` You should see output like this: ```shell $ cargo test Compiling blah v0.1.0 (file:///nobackup/blah) Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs Running target/debug/deps/blah-d3b32b97275ec472 running 4 tests test test_bar ... ok test test_baz ... ok test test_foo_bar ... ok test test_foo ... ok test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` You can also run tests whose name matches a pattern: ```shell $ cargo test test_foo ``` ```shell $ cargo test test_foo Compiling blah v0.1.0 (file:///nobackup/blah) Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs Running target/debug/deps/blah-d3b32b97275ec472 running 2 tests test test_foo ... ok test test_foo_bar ... ok test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out ``` One word of caution: Cargo may run multiple tests concurrently, so make sure that they don't race with each other. One example of this concurrency causing issues is if two tests output to a file, such as below: ```rust #[cfg(test)] mod tests { // Import the necessary modules use std::fs::OpenOptions; use std::io::Write; // This test writes to a file #[test] fn test_file() { // Opens the file ferris.txt or creates one if it doesn't exist. let mut file = OpenOptions::new() .append(true) .create(true) .open("ferris.txt") .expect("Failed to open ferris.txt"); // Print "Ferris" 5 times. for _ in 0..5 { file.write_all("Ferris\n".as_bytes()) .expect("Could not write to ferris.txt"); } } // This test tries to write to the same file #[test] fn test_file_also() { // Opens the file ferris.txt or creates one if it doesn't exist. let mut file = OpenOptions::new() .append(true) .create(true) .open("ferris.txt") .expect("Failed to open ferris.txt"); // Print "Corro" 5 times. for _ in 0..5 { file.write_all("Corro\n".as_bytes()) .expect("Could not write to ferris.txt"); } } } ``` Although the intent is to get the following: ```shell $ cat ferris.txt Ferris Ferris Ferris Ferris Ferris Corro Corro Corro Corro Corro ``` What actually gets put into `ferris.txt` is this: ```shell $ cargo test test_file && cat ferris.txt Corro Ferris Corro Ferris Corro Ferris Corro Ferris Corro Ferris ``` [testing]: ../testing.md [unit_testing]: ../testing/unit_testing.md [integration_testing]: ../testing/integration_testing.md [doc_testing]: ../testing/doc_testing.md ================================================ FILE: src/cargo.md ================================================ # Cargo `cargo` is the official Rust package management tool. It has lots of really useful features to improve code quality and developer velocity! These include - Dependency management and integration with [crates.io](https://crates.io) (the official Rust package registry) - Awareness of unit tests - Awareness of benchmarks This chapter will go through some quick basics, but you can find the comprehensive docs in [The Cargo Book](https://doc.rust-lang.org/cargo/). ================================================ FILE: src/compatibility/raw_identifiers.md ================================================ # Raw identifiers Rust, like many programming languages, has the concept of "keywords". These identifiers mean something to the language, and so you cannot use them in places like variable names, function names, and other places. Raw identifiers let you use keywords where they would not normally be allowed. This is particularly useful when Rust introduces new keywords, and a library using an older edition of Rust has a variable or function with the same name as a keyword introduced in a newer edition. For example, consider a crate `foo` compiled with the 2015 edition of Rust that exports a function named `try`. This keyword is reserved for a new feature in the 2018 edition, so without raw identifiers, we would have no way to name the function. ```rust,ignore extern crate foo; fn main() { foo::try(); } ``` You'll get this error: ```text error: expected identifier, found keyword `try` --> src/main.rs:4:4 | 4 | foo::try(); | ^^^ expected identifier, found keyword ``` You can write this with a raw identifier: ```rust,ignore extern crate foo; fn main() { foo::r#try(); } ``` ================================================ FILE: src/compatibility.md ================================================ # Compatibility The Rust language is evolving rapidly, and because of this certain compatibility issues can arise, despite efforts to ensure forwards-compatibility wherever possible. * [Raw identifiers](compatibility/raw_identifiers.md) ================================================ FILE: src/conversion/from_into.md ================================================ # `From` and `Into` The [`From`] and [`Into`] traits are inherently linked, and this is actually part of its implementation. If you are able to convert type A from type B, then it should be easy to believe that we should be able to convert type B to type A. ## `From` The [`From`] trait allows for a type to define how to create itself from another type, hence providing a very simple mechanism for converting between several types. There are numerous implementations of this trait within the standard library for conversion of primitive and common types. For example we can easily convert a `str` into a `String` ```rust let my_str = "hello"; let my_string = String::from(my_str); ``` We can do something similar for defining a conversion for our own type. ```rust,editable use std::convert::From; #[derive(Debug)] struct Number { value: i32, } impl From for Number { fn from(item: i32) -> Self { Number { value: item } } } fn main() { let num = Number::from(30); println!("My number is {:?}", num); } ``` ## `Into` The [`Into`] trait is simply the reciprocal of the `From` trait. It defines how to convert a type into another type. Calling `into()` typically requires us to specify the result type as the compiler is unable to determine this most of the time. ```rust,editable use std::convert::Into; #[derive(Debug)] struct Number { value: i32, } impl Into for i32 { fn into(self) -> Number { Number { value: self } } } fn main() { let int = 5; // Try removing the type annotation let num: Number = int.into(); println!("My number is {:?}", num); } ``` ## `From` and `Into` are interchangeable `From` and `Into` are designed to be complementary. We do not need to provide an implementation for both traits. If you have implemented the `From` trait for your type, `Into` will call it when necessary. Note, however, that the converse is not true: implementing `Into` for your type will not automatically provide it with an implementation of `From`. ```rust,editable use std::convert::From; #[derive(Debug)] struct Number { value: i32, } // Define `From` impl From for Number { fn from(item: i32) -> Self { Number { value: item } } } fn main() { let int = 5; // use `Into` let num: Number = int.into(); println!("My number is {:?}", num); } ``` [`From`]: https://doc.rust-lang.org/std/convert/trait.From.html [`Into`]: https://doc.rust-lang.org/std/convert/trait.Into.html ================================================ FILE: src/conversion/string.md ================================================ # To and from Strings ## Converting to String To convert any type to a `String` is as simple as implementing the [`ToString`] trait for the type. Rather than doing so directly, you should implement the [`fmt::Display`][Display] trait which automatically provides [`ToString`] and also allows printing the type as discussed in the section on [`print!`][print]. ```rust,editable use std::fmt; struct Circle { radius: i32 } impl fmt::Display for Circle { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Circle of radius {}", self.radius) } } fn main() { let circle = Circle { radius: 6 }; println!("{}", circle.to_string()); } ``` ## Parsing a String It's useful to convert strings into many types, but one of the more common string operations is to convert them from string to number. The idiomatic approach to this is to use the [`parse`] function and either to arrange for type inference or to specify the type to parse using the 'turbofish' syntax. Both alternatives are shown in the following example. This will convert the string into the type specified as long as the [`FromStr`] trait is implemented for that type. This is implemented for numerous types within the standard library. ```rust,editable fn main() { let parsed: i32 = "5".parse().unwrap(); let turbo_parsed = "10".parse::().unwrap(); let sum = parsed + turbo_parsed; println!("Sum: {:?}", sum); } ``` To obtain this functionality on a user defined type simply implement the [`FromStr`] trait for that type. ```rust,editable use std::num::ParseIntError; use std::str::FromStr; #[derive(Debug)] struct Circle { radius: i32, } impl FromStr for Circle { type Err = ParseIntError; fn from_str(s: &str) -> Result { match s.trim().parse() { Ok(num) => Ok(Circle{ radius: num }), Err(e) => Err(e), } } } fn main() { let radius = " 3 "; let circle: Circle = radius.parse().unwrap(); println!("{:?}", circle); } ``` [`ToString`]: https://doc.rust-lang.org/std/string/trait.ToString.html [Display]: https://doc.rust-lang.org/std/fmt/trait.Display.html [print]: ../hello/print.md [`parse`]: https://doc.rust-lang.org/std/primitive.str.html#method.parse [`FromStr`]: https://doc.rust-lang.org/std/str/trait.FromStr.html ================================================ FILE: src/conversion/try_from_try_into.md ================================================ # `TryFrom` and `TryInto` Similar to [`From` and `Into`][from-into], [`TryFrom`] and [`TryInto`] are generic traits for converting between types. Unlike `From`/`Into`, the `TryFrom`/`TryInto` traits are used for fallible conversions, and as such, return [`Result`]s. [from-into]: from_into.html [`TryFrom`]: https://doc.rust-lang.org/std/convert/trait.TryFrom.html [`TryInto`]: https://doc.rust-lang.org/std/convert/trait.TryInto.html [`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html ```rust,editable use std::convert::TryFrom; use std::convert::TryInto; #[derive(Debug, PartialEq)] struct EvenNumber(i32); impl TryFrom for EvenNumber { type Error = (); fn try_from(value: i32) -> Result { if value % 2 == 0 { Ok(EvenNumber(value)) } else { Err(()) } } } fn main() { // TryFrom assert_eq!(EvenNumber::try_from(8), Ok(EvenNumber(8))); assert_eq!(EvenNumber::try_from(5), Err(())); // TryInto let result: Result = 8i32.try_into(); assert_eq!(result, Ok(EvenNumber(8))); let result: Result = 5i32.try_into(); assert_eq!(result, Err(())); } ``` ================================================ FILE: src/conversion.md ================================================ # Conversion Primitive types can be converted to each other through [casting]. Rust addresses conversion between custom types (i.e., `struct` and `enum`) by the use of [traits]. The generic conversions will use the [`From`] and [`Into`] traits. However there are more specific ones for the more common cases, in particular when converting to and from `String`s. [casting]: types/cast.md [traits]: trait.md [`From`]: https://doc.rust-lang.org/std/convert/trait.From.html [`Into`]: https://doc.rust-lang.org/std/convert/trait.Into.html ================================================ FILE: src/crates/lib.md ================================================ # Creating a Library Let's create a library, and then see how to link it to another crate. In `rary.rs`: ```rust,ignore pub fn public_function() { println!("called rary's `public_function()`"); } fn private_function() { println!("called rary's `private_function()`"); } pub fn indirect_access() { print!("called rary's `indirect_access()`, that\n> "); private_function(); } ``` ```shell $ rustc --crate-type=lib rary.rs $ ls lib* library.rlib ``` Libraries get prefixed with "lib", and by default they get named after their crate file, but this default name can be overridden by passing the `--crate-name` option to `rustc` or by using the [`crate_name` attribute][crate-name]. [crate-name]: ../attribute/crate.md ================================================ FILE: src/crates/using_lib.md ================================================ # Using a Library To link a crate to this new library you may use `rustc`'s `--extern` flag. All of its items will then be imported under a module named the same as the library. This module generally behaves the same way as any other module. ```rust,ignore // extern crate rary; // May be required for Rust 2015 edition or earlier fn main() { rary::public_function(); // Error! `private_function` is private //rary::private_function(); rary::indirect_access(); } ``` ```txt # Where library.rlib is the path to the compiled library, assumed that it's # in the same directory here: $ rustc executable.rs --extern rary=library.rlib && ./executable called rary's `public_function()` called rary's `indirect_access()`, that > called rary's `private_function()` ``` ================================================ FILE: src/crates.md ================================================ # Crates A crate is a compilation unit in Rust. Whenever `rustc some_file.rs` is called, `some_file.rs` is treated as the *crate file*. If `some_file.rs` has `mod` declarations in it, then the contents of the module files would be inserted in places where `mod` declarations in the crate file are found, *before* running the compiler over it. In other words, modules do *not* get compiled individually, only crates get compiled. A crate can be compiled into a binary or into a library. By default, `rustc` will produce a binary from a crate. This behavior can be overridden by passing the `--crate-type` flag to `lib`. ================================================ FILE: src/custom_types/constants.md ================================================ # constants Rust has two different types of constants which can be declared in any scope including global. Both require explicit type annotation: * `const`: An unchangeable value (the common case). * `static`: A possibly mutable variable with [`'static`][static] lifetime. The static lifetime is inferred and does not have to be specified. Accessing or modifying a mutable static variable is [`unsafe`][unsafe]. ```rust,editable,ignore,mdbook-runnable // Globals are declared outside all other scopes. static LANGUAGE: &str = "Rust"; const THRESHOLD: i32 = 10; fn is_big(n: i32) -> bool { // Access constant in some function n > THRESHOLD } fn main() { let n = 16; // Access constant in the main thread println!("This is {}", LANGUAGE); println!("The threshold is {}", THRESHOLD); println!("{} is {}", n, if is_big(n) { "big" } else { "small" }); // Error! Cannot modify a `const`. THRESHOLD = 5; // FIXME ^ Comment out this line } ``` ### See also: [The `const`/`static` RFC]( https://github.com/rust-lang/rfcs/blob/master/text/0246-const-vs-static.md), [`'static` lifetime][static] [static]: ../scope/lifetime/static_lifetime.md [unsafe]: ../unsafe.md ================================================ FILE: src/custom_types/enum/c_like.md ================================================ # C-like `enum` can also be used as C-like enums. ```rust,editable // An attribute to hide warnings for unused code. #![allow(dead_code)] // enum with implicit discriminator (starts at 0) enum Number { Zero, One, Two, } // enum with explicit discriminator enum Color { Red = 0xff0000, Green = 0x00ff00, Blue = 0x0000ff, } fn main() { // `enums` can be cast as integers. println!("zero is {}", Number::Zero as i32); println!("one is {}", Number::One as i32); println!("roses are #{:06x}", Color::Red as u32); println!("violets are #{:06x}", Color::Blue as u32); } ``` ### See also: [casting][cast] [cast]: ../../types/cast.md ================================================ FILE: src/custom_types/enum/enum_use.md ================================================ # use The `use` declaration can be used to avoid typing the full module path to access a name: ```rust,editable // An attribute to hide warnings for unused code. #![allow(dead_code)] enum Stage { Beginner, Advanced, } enum Role { Student, Teacher, } fn main() { // Explicitly `use` each name so they are available without // manual scoping. use Stage::{Beginner, Advanced}; // Automatically `use` each name inside `Role`. use Role::*; // Equivalent to `Stage::Beginner`. let stage = Beginner; // Equivalent to `Role::Student`. let role = Student; match stage { // Note the lack of scoping because of the explicit `use` above. Beginner => println!("Beginners are starting their learning journey!"), Advanced => println!("Advanced learners are mastering their subjects..."), } match role { // Note again the lack of scoping. Student => println!("Students are acquiring knowledge!"), Teacher => println!("Teachers are spreading knowledge!"), } } ``` ### See also: [`match`][match] and [`use`][use] [use]: ../../mod/use.md [match]: ../../flow_control/match.md ================================================ FILE: src/custom_types/enum/testcase_linked_list.md ================================================ # Testcase: linked-list A common way to implement a linked-list is via `enums`: ```rust,editable use crate::List::*; enum List { // Cons: Tuple struct that wraps an element and a pointer to the next node Cons(u32, Box), // Nil: A node that signifies the end of the linked list Nil, } // Methods can be attached to an enum impl List { // Create an empty list fn new() -> List { // `Nil` has type `List` Nil } // Consume a list, and return the same list with a new element at its front fn prepend(self, elem: u32) -> List { // `Cons` also has type List Cons(elem, Box::new(self)) } // Return the length of the list fn len(&self) -> u32 { // `self` has to be matched, because the behavior of this method // depends on the variant of `self` // `self` has type `&List`, and `*self` has type `List`, matching on a // concrete type `T` is preferred over a match on a reference `&T` // after Rust 2018 you can use self here and tail (with no ref) below as well, // rust will infer &s and ref tail. // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/default-match-bindings.html match *self { // Can't take ownership of the tail, because `self` is borrowed; // instead take a reference to the tail // And it's a non-tail recursive call which may cause stack overflow for long lists. Cons(_, ref tail) => 1 + tail.len(), // Base Case: An empty list has zero length Nil => 0 } } // Return representation of the list as a (heap allocated) string fn stringify(&self) -> String { match *self { Cons(head, ref tail) => { // `format!` is similar to `print!`, but returns a heap // allocated string instead of printing to the console format!("{}, {}", head, tail.stringify()) }, Nil => { format!("Nil") }, } } } fn main() { // Create an empty linked list let mut list = List::new(); // Prepend some elements list = list.prepend(1); list = list.prepend(2); list = list.prepend(3); // Show the final state of the list println!("linked list has length: {}", list.len()); println!("{}", list.stringify()); } ``` ### See also: [`Box`][box] and [methods][methods] [box]: ../../std/box.md [methods]: ../../fn/methods.md ================================================ FILE: src/custom_types/enum.md ================================================ # Enums The `enum` keyword allows the creation of a type which may be one of a few different variants. Any variant which is valid as a `struct` is also valid in an `enum`. ```rust,editable // Create an `enum` to classify a web event. Note how both // names and type information together specify the variant: // `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`. // Each is different and independent. enum WebEvent { // An `enum` variant may either be `unit-like`, PageLoad, PageUnload, // like tuple structs, KeyPress(char), Paste(String), // or c-like structures. Click { x: i64, y: i64 }, } // A function which takes a `WebEvent` enum as an argument and // returns nothing. fn inspect(event: WebEvent) { match event { WebEvent::PageLoad => println!("page loaded"), WebEvent::PageUnload => println!("page unloaded"), // Destructure `c` from inside the `enum` variant. WebEvent::KeyPress(c) => println!("pressed '{}'.", c), WebEvent::Paste(s) => println!("pasted \"{}\".", s), // Destructure `Click` into `x` and `y`. WebEvent::Click { x, y } => { println!("clicked at x={}, y={}.", x, y); }, } } fn main() { let pressed = WebEvent::KeyPress('x'); // `to_owned()` creates an owned `String` from a string slice. let pasted = WebEvent::Paste("my text".to_owned()); let click = WebEvent::Click { x: 20, y: 80 }; let load = WebEvent::PageLoad; let unload = WebEvent::PageUnload; inspect(pressed); inspect(pasted); inspect(click); inspect(load); inspect(unload); } ``` ## Type aliases If you use a type alias, you can refer to each enum variant via its alias. This might be useful if the enum's name is too long or too generic, and you want to rename it. ```rust,editable enum VeryVerboseEnumOfThingsToDoWithNumbers { Add, Subtract, } // Creates a type alias type Operations = VeryVerboseEnumOfThingsToDoWithNumbers; fn main() { // We can refer to each variant via its alias, not its long and inconvenient // name. let x = Operations::Add; } ``` The most common place you'll see this is in `impl` blocks using the `Self` alias. ```rust,editable enum VeryVerboseEnumOfThingsToDoWithNumbers { Add, Subtract, } impl VeryVerboseEnumOfThingsToDoWithNumbers { fn run(&self, x: i32, y: i32) -> i32 { match self { Self::Add => x + y, Self::Subtract => x - y, } } } ``` To learn more about enums and type aliases, you can read the [stabilization report][aliasreport] from when this feature was stabilized into Rust. ### See also: [`match`][match], [`fn`][fn], and [`String`][str], ["Type alias enum variants" RFC][type_alias_rfc] [c_struct]: https://en.wikipedia.org/wiki/Struct_(C_programming_language) [match]: ../flow_control/match.md [fn]: ../fn.md [str]: ../std/str.md [aliasreport]: https://github.com/rust-lang/rust/pull/61682/#issuecomment-502472847 [type_alias_rfc]: https://rust-lang.github.io/rfcs/2338-type-alias-enum-variants.html ================================================ FILE: src/custom_types/structs.md ================================================ # Structures There are three types of structures ("structs") that can be created using the `struct` keyword: * Tuple structs, which are, basically, named tuples. * The classic [C structs][c_struct] * Unit structs, which are field-less, are useful for generics. ```rust,editable // An attribute to hide warnings for unused code. #![allow(dead_code)] #[derive(Debug)] struct Person { name: String, age: u8, } // A unit struct struct Unit; // A tuple struct struct Pair(i32, f32); // A struct with two fields struct Point { x: f32, y: f32, } // Structs can be reused as fields of another struct struct Rectangle { // A rectangle can be specified by where the top left and bottom right // corners are in space. top_left: Point, bottom_right: Point, } fn main() { // Create struct with field init shorthand let name = String::from("Peter"); let age = 27; let peter = Person { name, age }; // Print debug struct println!("{:?}", peter); // Instantiate a `Point` let point: Point = Point { x: 5.2, y: 0.4 }; let another_point: Point = Point { x: 10.3, y: 0.2 }; // Access the fields of the point println!("point coordinates: ({}, {})", point.x, point.y); // Make a new point by using struct update syntax to use the fields of our // other one let bottom_right = Point { x: 10.3, ..another_point }; // `bottom_right.y` will be the same as `another_point.y` because we used that field // from `another_point` println!("second point: ({}, {})", bottom_right.x, bottom_right.y); // Destructure the point using a `let` binding let Point { x: left_edge, y: top_edge } = point; let _rectangle = Rectangle { // struct instantiation is an expression too top_left: Point { x: left_edge, y: top_edge }, bottom_right: bottom_right, }; // Instantiate a unit struct let _unit = Unit; // Instantiate a tuple struct let pair = Pair(1, 0.1); // Access the fields of a tuple struct println!("pair contains {:?} and {:?}", pair.0, pair.1); // Destructure a tuple struct let Pair(integer, decimal) = pair; println!("pair contains {:?} and {:?}", integer, decimal); } ``` ### Activity 1. Add a function `rect_area` which calculates the area of a `Rectangle` (try using nested destructuring). 2. Add a function `square` which takes a `Point` and a `f32` as arguments, and returns a `Rectangle` with its top left corner on the point, and a width and height corresponding to the `f32`. ### See also [`attributes`][attributes], [raw identifiers][raw_identifiers] and [destructuring][destructuring] [attributes]: ../attribute.md [c_struct]: https://en.wikipedia.org/wiki/Struct_(C_programming_language) [destructuring]: ../flow_control/match/destructuring.md [raw_identifiers]: ../compatibility/raw_identifiers.md ================================================ FILE: src/custom_types.md ================================================ # Custom Types Rust custom data types are formed mainly through the two keywords: * `struct`: define a structure * `enum`: define an enumeration Constants can also be created via the `const` and `static` keywords. ================================================ FILE: src/error/abort_unwind.md ================================================ # `abort` and `unwind` The previous section illustrates the error handling mechanism `panic`. Different code paths can be conditionally compiled based on the panic setting. The current values available are `unwind` and `abort`. Building on the prior lemonade example, we explicitly use the panic strategy to exercise different lines of code. ```rust,editable,mdbook-runnable fn drink(beverage: &str) { // You shouldn't drink too much sugary beverages. if beverage == "lemonade" { if cfg!(panic = "abort") { println!("This is not your party. Run!!!!"); } else { println!("Spit it out!!!!"); } } else { println!("Some refreshing {} is all I need.", beverage); } } fn main() { drink("water"); drink("lemonade"); } ``` Here is another example focusing on rewriting `drink()` and explicitly use the `unwind` keyword. ```rust,editable #[cfg(panic = "unwind")] fn ah() { println!("Spit it out!!!!"); } #[cfg(not(panic = "unwind"))] fn ah() { println!("This is not your party. Run!!!!"); } fn drink(beverage: &str) { if beverage == "lemonade" { ah(); } else { println!("Some refreshing {} is all I need.", beverage); } } fn main() { drink("water"); drink("lemonade"); } ``` The panic strategy can be set from the command line by using `abort` or `unwind`. ```console rustc lemonade.rs -C panic=abort ``` ================================================ FILE: src/error/iter_result.md ================================================ # Iterating over `Result`s An `Iter::map` operation might fail, for example: ```rust,editable fn main() { let strings = vec!["tofu", "93", "18"]; let numbers: Vec<_> = strings .into_iter() .map(|s| s.parse::()) .collect(); println!("Results: {:?}", numbers); } ``` Let's step through strategies for handling this. ## Ignore the failed items with `filter_map()` `filter_map` calls a function and filters out the results that are `None`. ```rust,editable fn main() { let strings = vec!["tofu", "93", "18"]; let numbers: Vec<_> = strings .into_iter() .filter_map(|s| s.parse::().ok()) .collect(); println!("Results: {:?}", numbers); } ``` ## Collect the failed items with `map_err()` and `filter_map()` `map_err` calls a function with the error, so by adding that to the previous `filter_map` solution we can save them off to the side while iterating. ```rust,editable fn main() { let strings = vec!["42", "tofu", "93", "999", "18"]; let mut errors = vec![]; let numbers: Vec<_> = strings .into_iter() .map(|s| s.parse::()) .filter_map(|r| r.map_err(|e| errors.push(e)).ok()) .collect(); println!("Numbers: {:?}", numbers); println!("Errors: {:?}", errors); } ``` ## Fail the entire operation with `collect()` `Result` implements `FromIterator` so that a vector of results (`Vec>`) can be turned into a result with a vector (`Result, E>`). Once an `Result::Err` is found, the iteration will terminate. ```rust,editable fn main() { let strings = vec!["tofu", "93", "18"]; let numbers: Result, _> = strings .into_iter() .map(|s| s.parse::()) .collect(); println!("Results: {:?}", numbers); } ``` This same technique can be used with `Option`. ## Collect all valid values and failures with `partition()` ```rust,editable fn main() { let strings = vec!["tofu", "93", "18"]; let (numbers, errors): (Vec<_>, Vec<_>) = strings .into_iter() .map(|s| s.parse::()) .partition(Result::is_ok); println!("Numbers: {:?}", numbers); println!("Errors: {:?}", errors); } ``` When you look at the results, you'll note that everything is still wrapped in `Result`. A little more boilerplate is needed for this. ```rust,editable fn main() { let strings = vec!["tofu", "93", "18"]; let (numbers, errors): (Vec<_>, Vec<_>) = strings .into_iter() .map(|s| s.parse::()) .partition(Result::is_ok); let numbers: Vec<_> = numbers.into_iter().map(Result::unwrap).collect(); let errors: Vec<_> = errors.into_iter().map(Result::unwrap_err).collect(); println!("Numbers: {:?}", numbers); println!("Errors: {:?}", errors); } ``` ================================================ FILE: src/error/multiple_error_types/boxing_errors.md ================================================ # `Box`ing errors A way to write simple code while preserving the original errors is to [`Box`][box] them. The drawback is that the underlying error type is only known at runtime and not [statically determined][dynamic_dispatch]. The stdlib helps in boxing our errors by having `Box` implement conversion from any type that implements the `Error` trait into the trait object `Box`, via [`From`][from]. ```rust,editable use std::error; use std::fmt; // Change the alias to use `Box`. type Result = std::result::Result>; #[derive(Debug, Clone)] struct EmptyVec; impl fmt::Display for EmptyVec { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "invalid first item to double") } } impl error::Error for EmptyVec {} fn double_first(vec: Vec<&str>) -> Result { vec.first() .ok_or_else(|| EmptyVec.into()) // Converts to Box using Into trait. .and_then(|s| { s.parse::() .map_err(From::from) // Converts to Box using From::from fn pointer. .map(|i| 2 * i) }) } fn print(result: Result) { match result { Ok(n) => println!("The first doubled is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; print(double_first(numbers)); print(double_first(empty)); print(double_first(strings)); } ``` ### See also: [Dynamic dispatch][dynamic_dispatch] and [`Error` trait][error] [box]: https://doc.rust-lang.org/std/boxed/struct.Box.html [dynamic_dispatch]: https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-objects-perform-dynamic-dispatch [error]: https://doc.rust-lang.org/std/error/trait.Error.html [from]: https://doc.rust-lang.org/std/convert/trait.From.html ================================================ FILE: src/error/multiple_error_types/define_error_type.md ================================================ # Defining an error type Sometimes it simplifies the code to mask all of the different errors with a single type of error. We'll show this with a custom error. Rust allows us to define our own error types. In general, a "good" error type: * Represents different errors with the same type * Presents nice error messages to the user * Is easy to compare with other types * Good: `Err(EmptyVec)` * Bad: `Err("Please use a vector with at least one element".to_owned())` * Can hold information about the error * Good: `Err(BadChar(c, position))` * Bad: `Err("+ cannot be used here".to_owned())` * Composes well with other errors ```rust,editable use std::fmt; type Result = std::result::Result; // Define our error types. These may be customized for our error handling cases. // Now we will be able to write our own errors, defer to an underlying error // implementation, or do something in between. #[derive(Debug, Clone)] struct DoubleError; // Generation of an error is completely separate from how it is displayed. // There's no need to be concerned about cluttering complex logic with the display style. // // Note that we don't store any extra info about the errors. This means we can't state // which string failed to parse without modifying our types to carry that information. impl fmt::Display for DoubleError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "invalid first item to double") } } fn double_first(vec: Vec<&str>) -> Result { vec.first() // Change the error to our new type. .ok_or(DoubleError) .and_then(|s| { s.parse::() // Update to the new error type here also. .map_err(|_| DoubleError) .map(|i| 2 * i) }) } fn print(result: Result) { match result { Ok(n) => println!("The first doubled is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; print(double_first(numbers)); print(double_first(empty)); print(double_first(strings)); } ``` ================================================ FILE: src/error/multiple_error_types/option_result.md ================================================ # Pulling `Result`s out of `Option`s The most basic way of handling mixed error types is to just embed them in each other. ```rust,editable use std::num::ParseIntError; fn double_first(vec: Vec<&str>) -> Option> { vec.first().map(|first| { first.parse::().map(|n| 2 * n) }) } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; println!("The first doubled is {:?}", double_first(numbers)); println!("The first doubled is {:?}", double_first(empty)); // Error 1: the input vector is empty println!("The first doubled is {:?}", double_first(strings)); // Error 2: the element doesn't parse to a number } ``` There are times when we'll want to stop processing on errors (like with [`?`][enter_question_mark]) but keep going when the `Option` is `None`. The `transpose` function comes in handy to swap the `Result` and `Option`. ```rust,editable use std::num::ParseIntError; fn double_first(vec: Vec<&str>) -> Result, ParseIntError> { let opt = vec.first().map(|first| { first.parse::().map(|n| 2 * n) }); opt.transpose() } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; println!("The first doubled is {:?}", double_first(numbers)); println!("The first doubled is {:?}", double_first(empty)); println!("The first doubled is {:?}", double_first(strings)); } ``` [enter_question_mark]: ../result/enter_question_mark.md ================================================ FILE: src/error/multiple_error_types/reenter_question_mark.md ================================================ # Other uses of `?` Notice in the previous example that our immediate reaction to calling `parse` is to `map` the error from a library error into a boxed error: ```rust,ignore .and_then(|s| s.parse::()) .map_err(|e| e.into()) ``` Since this is a simple and common operation, it would be convenient if it could be elided. Alas, because `and_then` is not sufficiently flexible, it cannot. However, we can instead use `?`. `?` was previously explained as either `unwrap` or `return Err(err)`. This is only mostly true. It actually means `unwrap` or `return Err(From::from(err))`. Since `From::from` is a conversion utility between different types, this means that if you `?` where the error is convertible to the return type, it will convert automatically. Here, we rewrite the previous example using `?`. As a result, the `map_err` will go away when `From::from` is implemented for our error type: ```rust,editable use std::error; use std::fmt; // Change the alias to use `Box`. type Result = std::result::Result>; #[derive(Debug)] struct EmptyVec; impl fmt::Display for EmptyVec { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "invalid first item to double") } } impl error::Error for EmptyVec {} // The same structure as before but rather than chain all `Results` // and `Options` along, we `?` to get the inner value out immediately. fn double_first(vec: Vec<&str>) -> Result { let first = vec.first().ok_or(EmptyVec)?; let parsed = first.parse::()?; Ok(2 * parsed) } fn print(result: Result) { match result { Ok(n) => println!("The first doubled is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; print(double_first(numbers)); print(double_first(empty)); print(double_first(strings)); } ``` This is actually fairly clean now. Compared with the original `panic`, it is very similar to replacing the `unwrap` calls with `?` except that the return types are `Result`. As a result, they must be destructured at the top level. ### See also: [`From::from`][from] and [`?`][q_mark] [from]: https://doc.rust-lang.org/std/convert/trait.From.html [q_mark]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator ================================================ FILE: src/error/multiple_error_types/wrap_error.md ================================================ # Wrapping errors An alternative to boxing errors is to wrap them in your own error type. ```rust,editable use std::error; use std::error::Error; use std::num::ParseIntError; use std::fmt; type Result = std::result::Result; #[derive(Debug)] enum DoubleError { EmptyVec, // We will defer to the parse error implementation for their error. // Supplying extra info requires adding more data to the type. Parse(ParseIntError), } impl fmt::Display for DoubleError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { DoubleError::EmptyVec => write!(f, "please use a vector with at least one element"), // The wrapped error contains additional information and is available // via the source() method. DoubleError::Parse(..) => write!(f, "the provided string could not be parsed as int"), } } } impl error::Error for DoubleError { fn source(&self) -> Option<&(dyn error::Error + 'static)> { match *self { DoubleError::EmptyVec => None, // The cause is the underlying implementation error type. Is implicitly // cast to the trait object `&error::Error`. This works because the // underlying type already implements the `Error` trait. DoubleError::Parse(ref e) => Some(e), } } } // Implement the conversion from `ParseIntError` to `DoubleError`. // This will be automatically called by `?` if a `ParseIntError` // needs to be converted into a `DoubleError`. impl From for DoubleError { fn from(err: ParseIntError) -> DoubleError { DoubleError::Parse(err) } } fn double_first(vec: Vec<&str>) -> Result { let first = vec.first().ok_or(DoubleError::EmptyVec)?; // Here we implicitly use the `ParseIntError` implementation of `From` (which // we defined above) in order to create a `DoubleError`. let parsed = first.parse::()?; Ok(2 * parsed) } fn print(result: Result) { match result { Ok(n) => println!("The first doubled is {}", n), Err(e) => { println!("Error: {}", e); if let Some(source) = e.source() { println!(" Caused by: {}", source); } }, } } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; print(double_first(numbers)); print(double_first(empty)); print(double_first(strings)); } ``` This adds a bit more boilerplate for handling errors and might not be needed in all applications. There are some libraries that can take care of the boilerplate for you. ### See also: [`From::from`][from] and [`Enums`][enums] [`Crates for handling errors`][crates-errors] [from]: https://doc.rust-lang.org/std/convert/trait.From.html [enums]: ../../custom_types/enum.md [crates-errors]: https://crates.io/keywords/error-handling ================================================ FILE: src/error/multiple_error_types.md ================================================ # Multiple error types The previous examples have always been very convenient; `Result`s interact with other `Result`s and `Option`s interact with other `Option`s. Sometimes an `Option` needs to interact with a `Result`, or a `Result` needs to interact with a `Result`. In those cases, we want to manage our different error types in a way that makes them composable and easy to interact with. In the following code, two instances of `unwrap` generate different error types. `Vec::first` returns an `Option`, while `parse::` returns a `Result`: ```rust,editable,ignore,mdbook-runnable fn double_first(vec: Vec<&str>) -> i32 { let first = vec.first().unwrap(); // Generate error 1 2 * first.parse::().unwrap() // Generate error 2 } fn main() { let numbers = vec!["42", "93", "18"]; let empty = vec![]; let strings = vec!["tofu", "93", "18"]; println!("The first doubled is {}", double_first(numbers)); println!("The first doubled is {}", double_first(empty)); // Error 1: the input vector is empty println!("The first doubled is {}", double_first(strings)); // Error 2: the element doesn't parse to a number } ``` Over the next sections, we'll see several strategies for handling these kind of problems. ================================================ FILE: src/error/option_unwrap/and_then.md ================================================ # Combinators: `and_then` `map()` was described as a chainable way to simplify `match` statements. However, using `map()` on a function that returns an `Option` results in the nested `Option>`. Chaining multiple calls together can then become confusing. That's where another combinator called `and_then()`, known in some languages as flatmap, comes in. `and_then()` calls its function input with the wrapped value and returns the result. If the `Option` is `None`, then it returns `None` instead. In the following example, `cookable_v3()` results in an `Option`. Using `map()` instead of `and_then()` would have given an `Option>`, which is an invalid type for `eat()`. ```rust,editable #![allow(dead_code)] #[derive(Debug)] enum Food { CordonBleu, Steak, Sushi } #[derive(Debug)] enum Day { Monday, Tuesday, Wednesday } // We don't have the ingredients to make Sushi. fn have_ingredients(food: Food) -> Option { match food { Food::Sushi => None, _ => Some(food), } } // We have the recipe for everything except Cordon Bleu. fn have_recipe(food: Food) -> Option { match food { Food::CordonBleu => None, _ => Some(food), } } // To make a dish, we need both the recipe and the ingredients. // We can represent the logic with a chain of `match`es: fn cookable_v1(food: Food) -> Option { match have_recipe(food) { None => None, Some(food) => have_ingredients(food), } } // This can conveniently be rewritten more compactly with `and_then()`: fn cookable_v3(food: Food) -> Option { have_recipe(food).and_then(have_ingredients) } // Otherwise we'd need to `flatten()` an `Option>` // to get an `Option`: fn cookable_v2(food: Food) -> Option { have_recipe(food).map(have_ingredients).flatten() } fn eat(food: Food, day: Day) { match cookable_v3(food) { Some(food) => println!("Yay! On {:?} we get to eat {:?}.", day, food), None => println!("Oh no. We don't get to eat on {:?}?", day), } } fn main() { let (cordon_bleu, steak, sushi) = (Food::CordonBleu, Food::Steak, Food::Sushi); eat(cordon_bleu, Day::Monday); eat(steak, Day::Tuesday); eat(sushi, Day::Wednesday); } ``` ### See also: [closures][closures], [`Option`][option], [`Option::and_then()`][and_then], and [`Option::flatten()`][flatten] [closures]: ../../fn/closures.md [option]: https://doc.rust-lang.org/std/option/enum.Option.html [and_then]: https://doc.rust-lang.org/std/option/enum.Option.html#method.and_then [flatten]: https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten ================================================ FILE: src/error/option_unwrap/defaults.md ================================================ # Unpacking options and defaults There is more than one way to unpack an `Option` and fall back on a default if it is `None`. To choose the one that meets our needs, we need to consider the following: * do we need eager or lazy evaluation? * do we need to keep the original empty value intact, or modify it in place? ## `or()` is chainable, evaluates eagerly, keeps empty value intact `or()`is chainable and eagerly evaluates its argument, as is shown in the following example. Note that because `or`'s arguments are evaluated eagerly, the variable passed to `or` is moved. ```rust,editable #[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let apple = Some(Fruit::Apple); let orange = Some(Fruit::Orange); let no_fruit: Option = None; let first_available_fruit = no_fruit.or(orange).or(apple); println!("first_available_fruit: {:?}", first_available_fruit); // first_available_fruit: Some(Orange) // `or` moves its argument. // In the example above, `or(orange)` returned a `Some`, so `or(apple)` was not invoked. // But the variable named `apple` has been moved regardless, and cannot be used anymore. // println!("Variable apple was moved, so this line won't compile: {:?}", apple); // TODO: uncomment the line above to see the compiler error } ``` ## `or_else()` is chainable, evaluates lazily, keeps empty value intact Another alternative is to use `or_else`, which is also chainable, and evaluates lazily, as is shown in the following example: ```rust,editable #[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let no_fruit: Option = None; let get_kiwi_as_fallback = || { println!("Providing kiwi as fallback"); Some(Fruit::Kiwi) }; let get_lemon_as_fallback = || { println!("Providing lemon as fallback"); Some(Fruit::Lemon) }; let first_available_fruit = no_fruit .or_else(get_kiwi_as_fallback) .or_else(get_lemon_as_fallback); println!("first_available_fruit: {:?}", first_available_fruit); // Providing kiwi as fallback // first_available_fruit: Some(Kiwi) } ``` ## `get_or_insert()` evaluates eagerly, modifies empty value in place To make sure that an `Option` contains a value, we can use `get_or_insert` to modify it in place with a fallback value, as is shown in the following example. Note that `get_or_insert` eagerly evaluates its parameter, so variable `apple` is moved: ```rust,editable #[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let mut my_fruit: Option = None; let apple = Fruit::Apple; let first_available_fruit = my_fruit.get_or_insert(apple); println!("first_available_fruit is: {:?}", first_available_fruit); println!("my_fruit is: {:?}", my_fruit); // first_available_fruit is: Apple // my_fruit is: Some(Apple) //println!("Variable named `apple` is moved: {:?}", apple); // TODO: uncomment the line above to see the compiler error } ``` ## `get_or_insert_with()` evaluates lazily, modifies empty value in place Instead of explicitly providing a value to fall back on, we can pass a closure to `get_or_insert_with`, as follows: ```rust,editable #[derive(Debug)] enum Fruit { Apple, Orange, Banana, Kiwi, Lemon } fn main() { let mut my_fruit: Option = None; let get_lemon_as_fallback = || { println!("Providing lemon as fallback"); Fruit::Lemon }; let first_available_fruit = my_fruit .get_or_insert_with(get_lemon_as_fallback); println!("first_available_fruit is: {:?}", first_available_fruit); println!("my_fruit is: {:?}", my_fruit); // Providing lemon as fallback // first_available_fruit is: Lemon // my_fruit is: Some(Lemon) // If the Option has a value, it is left unchanged, and the closure is not invoked let mut my_apple = Some(Fruit::Apple); let should_be_apple = my_apple.get_or_insert_with(get_lemon_as_fallback); println!("should_be_apple is: {:?}", should_be_apple); println!("my_apple is unchanged: {:?}", my_apple); // The output is a follows. Note that the closure `get_lemon_as_fallback` is not invoked // should_be_apple is: Apple // my_apple is unchanged: Some(Apple) } ``` ### See also: [`closures`][closures], [`get_or_insert`][get_or_insert], [`get_or_insert_with`][get_or_insert_with], [`moved variables`][moved], [`or`][or], [`or_else`][or_else] [closures]: https://doc.rust-lang.org/book/ch13-01-closures.html [get_or_insert]: https://doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert [get_or_insert_with]: https://doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with [moved]: https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html [or]: https://doc.rust-lang.org/core/option/enum.Option.html#method.or [or_else]: https://doc.rust-lang.org/core/option/enum.Option.html#method.or_else ================================================ FILE: src/error/option_unwrap/map.md ================================================ # Combinators: `map` `match` is a valid method for handling `Option`s. However, you may eventually find heavy usage tedious, especially with operations only valid with an input. In these cases, [combinators][combinators] can be used to manage control flow in a modular fashion. `Option` has a built in method called `map()`, a combinator for the simple mapping of `Some -> Some` and `None -> None`. Multiple `map()` calls can be chained together for even more flexibility. In the following example, `process()` replaces all functions previous to it while staying compact. ```rust,editable #![allow(dead_code)] #[derive(Debug)] enum Food { Apple, Carrot, Potato } #[derive(Debug)] struct Peeled(Food); #[derive(Debug)] struct Chopped(Food); #[derive(Debug)] struct Cooked(Food); // Peeling food. If there isn't any, then return `None`. // Otherwise, return the peeled food. fn peel(food: Option) -> Option { match food { Some(food) => Some(Peeled(food)), None => None, } } // Chopping food. If there isn't any, then return `None`. // Otherwise, return the chopped food. fn chop(peeled: Option) -> Option { match peeled { Some(Peeled(food)) => Some(Chopped(food)), None => None, } } // Cooking food. Here, we showcase `map()` instead of `match` for case handling. fn cook(chopped: Option) -> Option { chopped.map(|Chopped(food)| Cooked(food)) } // A function to peel, chop, and cook food all in sequence. // We chain multiple uses of `map()` to simplify the code. fn process(food: Option) -> Option { food.map(|f| Peeled(f)) .map(|Peeled(f)| Chopped(f)) .map(|Chopped(f)| Cooked(f)) } // Check whether there's food or not before trying to eat it! fn eat(food: Option) { match food { Some(food) => println!("Mmm. I love {:?}", food), None => println!("Oh no! It wasn't edible."), } } fn main() { let apple = Some(Food::Apple); let carrot = Some(Food::Carrot); let potato = None; let cooked_apple = cook(chop(peel(apple))); let cooked_carrot = cook(chop(peel(carrot))); // Let's try the simpler looking `process()` now. let cooked_potato = process(potato); eat(cooked_apple); eat(cooked_carrot); eat(cooked_potato); } ``` ### See also: [closures][closures], [`Option`][option], [`Option::map()`][map] [combinators]: https://doc.rust-lang.org/reference/glossary.html#combinator [closures]: ../../fn/closures.md [option]: https://doc.rust-lang.org/std/option/enum.Option.html [map]: https://doc.rust-lang.org/std/option/enum.Option.html#method.map ================================================ FILE: src/error/option_unwrap/question_mark.md ================================================ # Unpacking options with `?` You can unpack `Option`s by using `match` statements, but it's often easier to use the `?` operator. If `x` is an `Option`, then evaluating `x?` will return the underlying value if `x` is `Some`, otherwise it will terminate whatever function is being executed and return `None`. ```rust,ignore fn next_birthday(current_age: Option) -> Option { // If `current_age` is `None`, this returns `None`. // If `current_age` is `Some`, the inner `u8` value + 1 // gets assigned to `next_age` let next_age: u8 = current_age? + 1; Some(format!("Next year I will be {}", next_age)) } ``` You can chain many `?`s together to make your code much more readable. ```rust,editable struct Person { job: Option, } #[derive(Clone, Copy)] struct Job { phone_number: Option, } #[derive(Clone, Copy)] #[allow(dead_code)] struct PhoneNumber { area_code: Option, number: u32, } impl Person { // Gets the area code of the phone number of the person's job, if it exists. fn work_phone_area_code(&self) -> Option { // This would need many nested `match` statements without the `?` operator. // It would take a lot more code - try writing it yourself and see which // is easier. self.job?.phone_number?.area_code } } fn main() { let p = Person { job: Some(Job { phone_number: Some(PhoneNumber { area_code: Some(61), number: 439222222, }), }), }; assert_eq!(p.work_phone_area_code(), Some(61)); } ``` ================================================ FILE: src/error/option_unwrap.md ================================================ # `Option` & `unwrap` In the last example, we showed that we can induce program failure at will. We told our program to `panic` if we drink a sugary lemonade. But what if we expect _some_ drink but don't receive one? That case would be just as bad, so it needs to be handled! We _could_ test this against the null string (`""`) as we do with a lemonade. Since we're using Rust, let's instead have the compiler point out cases where there's no drink. An `enum` called `Option` in the `std` library is used when absence is a possibility. It manifests itself as one of two "options": * `Some(T)`: An element of type `T` was found * `None`: No element was found These cases can either be explicitly handled via `match` or implicitly with `unwrap`. Implicit handling will either return the inner element or `panic`. Note that it's possible to manually customize `panic` with [expect][expect], but `unwrap` otherwise leaves us with a less meaningful output than explicit handling. In the following example, explicit handling yields a more controlled result while retaining the option to `panic` if desired. ```rust,editable,ignore,mdbook-runnable // The adult has seen it all, and can handle any drink well. // All drinks are handled explicitly using `match`. fn give_adult(drink: Option<&str>) { // Specify a course of action for each case. match drink { Some("lemonade") => println!("Yuck! Too sugary."), Some(inner) => println!("{}? How nice.", inner), None => println!("No drink? Oh well."), } } // Others will `panic` before drinking sugary drinks. // All drinks are handled implicitly using `unwrap`. fn drink(drink: Option<&str>) { // `unwrap` returns a `panic` when it receives a `None`. let inside = drink.unwrap(); if inside == "lemonade" { panic!("AAAaaaaa!!!!"); } println!("I love {}s!!!!!", inside); } fn main() { let water = Some("water"); let lemonade = Some("lemonade"); let void = None; give_adult(water); give_adult(lemonade); give_adult(void); let coffee = Some("coffee"); let nothing = None; drink(coffee); drink(nothing); } ``` [expect]: https://doc.rust-lang.org/std/option/enum.Option.html#method.expect ================================================ FILE: src/error/panic.md ================================================ # `panic` The simplest error handling mechanism we will see is `panic`. It prints an error message, starts unwinding the stack, and usually exits the program. Here, we explicitly call `panic` on our error condition: ```rust,editable,ignore,mdbook-runnable fn drink(beverage: &str) { // You shouldn't drink too many sugary beverages. if beverage == "lemonade" { panic!("AAAaaaaa!!!!"); } println!("Some refreshing {} is all I need.", beverage); } fn main() { drink("water"); drink("lemonade"); drink("still water"); } ``` The first call to `drink` works. The second panics and thus the third is never called. ================================================ FILE: src/error/result/early_returns.md ================================================ # Early returns In the previous example, we explicitly handled the errors using combinators. Another way to deal with this case analysis is to use a combination of `match` statements and *early returns*. That is, we can simply stop executing the function and return the error if one occurs. For some, this form of code can be easier to both read and write. Consider this version of the previous example, rewritten using early returns: ```rust,editable use std::num::ParseIntError; fn multiply(first_number_str: &str, second_number_str: &str) -> Result { let first_number = match first_number_str.parse::() { Ok(first_number) => first_number, Err(e) => return Err(e), }; let second_number = match second_number_str.parse::() { Ok(second_number) => second_number, Err(e) => return Err(e), }; Ok(first_number * second_number) } fn print(result: Result) { match result { Ok(n) => println!("n is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { print(multiply("10", "2")); print(multiply("t", "2")); } ``` At this point, we've learned to explicitly handle errors using combinators and early returns. While we generally want to avoid panicking, explicitly handling all of our errors is cumbersome. In the next section, we'll introduce `?` for the cases where we simply need to `unwrap` without possibly inducing `panic`. ================================================ FILE: src/error/result/enter_question_mark.md ================================================ # Introducing `?` Sometimes we just want the simplicity of `unwrap` without the possibility of a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when what we really wanted was to get the variable *out*. This is exactly the purpose of `?`. Upon finding an `Err`, there are two valid actions to take: 1. `panic!` which we already decided to try to avoid if possible 2. `return` because an `Err` means it cannot be handled `?` is *almost*[^†] exactly equivalent to an `unwrap` which `return`s instead of `panic`king on `Err`s. Let's see how we can simplify the earlier example that used combinators: ```rust,editable use std::num::ParseIntError; fn multiply(first_number_str: &str, second_number_str: &str) -> Result { let first_number = first_number_str.parse::()?; let second_number = second_number_str.parse::()?; Ok(first_number * second_number) } fn print(result: Result) { match result { Ok(n) => println!("n is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { print(multiply("10", "2")); print(multiply("t", "2")); } ``` ## The `try!` macro Before there was `?`, the same functionality was achieved with the `try!` macro. The `?` operator is now recommended, but you may still find `try!` when looking at older code. The same `multiply` function from the previous example would look like this using `try!`: ```rust,editable,edition2015 // To compile and run this example without errors, while using Cargo, change the value // of the `edition` field, in the `[package]` section of the `Cargo.toml` file, to "2015". use std::num::ParseIntError; fn multiply(first_number_str: &str, second_number_str: &str) -> Result { let first_number = try!(first_number_str.parse::()); let second_number = try!(second_number_str.parse::()); Ok(first_number * second_number) } fn print(result: Result) { match result { Ok(n) => println!("n is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { print(multiply("10", "2")); print(multiply("t", "2")); } ``` [^†]: See [re-enter ?][re_enter_?] for more details. [re_enter_?]: ../multiple_error_types/reenter_question_mark.md ================================================ FILE: src/error/result/result_alias.md ================================================ # aliases for `Result` How about when we want to reuse a specific `Result` type many times? Recall that Rust allows us to create [aliases][typealias]. Conveniently, we can define one for the specific `Result` in question. At a module level, creating aliases can be particularly helpful. Errors found in a specific module often have the same `Err` type, so a single alias can succinctly define *all* associated `Results`. This is so useful that the `std` library even supplies one: [`io::Result`][io_result]! Here's a quick example to show off the syntax: ```rust,editable use std::num::ParseIntError; // Define a generic alias for a `Result` with the error type `ParseIntError`. type AliasedResult = Result; // Use the above alias to refer to our specific `Result` type. fn multiply(first_number_str: &str, second_number_str: &str) -> AliasedResult { first_number_str.parse::().and_then(|first_number| { second_number_str.parse::().map(|second_number| first_number * second_number) }) } // Here, the alias again allows us to save some space. fn print(result: AliasedResult) { match result { Ok(n) => println!("n is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { print(multiply("10", "2")); print(multiply("t", "2")); } ``` ### See also: [`io::Result`][io_result] [typealias]: ../../types/alias.md [io_result]: https://doc.rust-lang.org/std/io/type.Result.html ================================================ FILE: src/error/result/result_map.md ================================================ # `map` for `Result` Panicking in the previous example's `multiply` does not make for robust code. Generally, we want to return the error to the caller so it can decide what is the right way to respond to errors. We first need to know what kind of error type we are dealing with. To determine the `Err` type, we look to [`parse()`][parse], which is implemented with the [`FromStr`][from_str] trait for [`i32`][i32]. As a result, the `Err` type is specified as [`ParseIntError`][parse_int_error]. In the example below, the straightforward `match` statement leads to code that is overall more cumbersome. ```rust,editable use std::num::ParseIntError; // With the return type rewritten, we use pattern matching without `unwrap()`. fn multiply(first_number_str: &str, second_number_str: &str) -> Result { match first_number_str.parse::() { Ok(first_number) => { match second_number_str.parse::() { Ok(second_number) => { Ok(first_number * second_number) }, Err(e) => Err(e), } }, Err(e) => Err(e), } } fn print(result: Result) { match result { Ok(n) => println!("n is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { // This still presents a reasonable answer. let twenty = multiply("10", "2"); print(twenty); // The following now provides a much more helpful error message. let tt = multiply("t", "2"); print(tt); } ``` Luckily, `Option`'s `map`, `and_then`, and many other combinators are also implemented for `Result`. [`Result`][result] contains a complete listing. ```rust,editable use std::num::ParseIntError; // As with `Option`, we can use combinators such as `map()`. // This function is otherwise identical to the one above and reads: // Multiply if both values can be parsed from str, otherwise pass on the error. fn multiply(first_number_str: &str, second_number_str: &str) -> Result { first_number_str.parse::().and_then(|first_number| { second_number_str.parse::().map(|second_number| first_number * second_number) }) } fn print(result: Result) { match result { Ok(n) => println!("n is {}", n), Err(e) => println!("Error: {}", e), } } fn main() { // This still presents a reasonable answer. let twenty = multiply("10", "2"); print(twenty); // The following now provides a much more helpful error message. let tt = multiply("t", "2"); print(tt); } ``` [parse]: https://doc.rust-lang.org/std/primitive.str.html#method.parse [from_str]: https://doc.rust-lang.org/std/str/trait.FromStr.html [i32]: https://doc.rust-lang.org/std/primitive.i32.html [parse_int_error]: https://doc.rust-lang.org/std/num/struct.ParseIntError.html [result]: https://doc.rust-lang.org/std/result/enum.Result.html ================================================ FILE: src/error/result.md ================================================ # `Result` [`Result`][result] is a richer version of the [`Option`][option] type that describes possible *error* instead of possible *absence*. That is, `Result` could have one of two outcomes: * `Ok(T)`: An element `T` was found * `Err(E)`: An error was found with element `E` By convention, the expected outcome is `Ok` while the unexpected outcome is `Err`. Like `Option`, `Result` has many methods associated with it. `unwrap()`, for example, either yields the element `T` or `panic`s. For case handling, there are many combinators between `Result` and `Option` that overlap. In working with Rust, you will likely encounter methods that return the `Result` type, such as the [`parse()`][parse] method. It might not always be possible to parse a string into the other type, so `parse()` returns a `Result` indicating possible failure. Let's see what happens when we successfully and unsuccessfully `parse()` a string: ```rust,editable,ignore,mdbook-runnable fn multiply(first_number_str: &str, second_number_str: &str) -> i32 { // Let's try using `unwrap()` to get the number out. Will it bite us? let first_number = first_number_str.parse::().unwrap(); let second_number = second_number_str.parse::().unwrap(); first_number * second_number } fn main() { let twenty = multiply("10", "2"); println!("double is {}", twenty); let tt = multiply("t", "2"); println!("double is {}", tt); } ``` In the unsuccessful case, `parse()` leaves us with an error for `unwrap()` to `panic` on. Additionally, the `panic` exits our program and provides an unpleasant error message. To improve the quality of our error message, we should be more specific about the return type and consider explicitly handling the error. ## Using `Result` in `main` The `Result` type can also be the return type of the `main` function if specified explicitly. Typically the `main` function will be of the form: ```rust fn main() { println!("Hello World!"); } ``` However `main` is also able to have a return type of `Result`. If an error occurs within the `main` function it will return an error code and print a debug representation of the error (using the [`Debug`] trait). The following example shows such a scenario and touches on aspects covered in [the following section]. ```rust,editable use std::num::ParseIntError; fn main() -> Result<(), ParseIntError> { let number_str = "10"; let number = match number_str.parse::() { Ok(number) => number, Err(e) => return Err(e), }; println!("{}", number); Ok(()) } ``` [option]: https://doc.rust-lang.org/std/option/enum.Option.html [result]: https://doc.rust-lang.org/std/result/enum.Result.html [parse]: https://doc.rust-lang.org/std/primitive.str.html#method.parse [`Debug`]: https://doc.rust-lang.org/std/fmt/trait.Debug.html [the following section]: result/early_returns.md ================================================ FILE: src/error.md ================================================ # Error handling Error handling is the process of handling the possibility of failure. For example, failing to read a file and then continuing to use that *bad* input would clearly be problematic. Noticing and explicitly managing those errors saves the rest of the program from various pitfalls. There are various ways to deal with errors in Rust, which are described in the following subchapters. They all have more or less subtle differences and different use cases. As a rule of thumb: An explicit `panic` is mainly useful for tests and dealing with unrecoverable errors. For prototyping it can be useful, for example when dealing with functions that haven't been implemented yet, but in those cases the more descriptive `unimplemented` is better. In tests `panic` is a reasonable way to explicitly fail. The `Option` type is for when a value is optional or when the lack of a value is not an error condition. For example the parent of a directory - `/` and `C:` don't have one. When dealing with `Option`s, `unwrap` is fine for prototyping and cases where it's absolutely certain that there is guaranteed to be a value. However `expect` is more useful since it lets you specify an error message in case something goes wrong anyway. When there is a chance that things do go wrong and the caller has to deal with the problem, use `Result`. You can `unwrap` and `expect` them as well (please don't do that unless it's a test or quick prototype). For a more rigorous discussion of error handling, refer to the error handling section in the [official book][book]. [book]: https://doc.rust-lang.org/book/ch09-00-error-handling.html ================================================ FILE: src/expression.md ================================================ # Expressions A Rust program is (mostly) made up of a series of statements: ```rust,editable fn main() { // statement // statement // statement } ``` There are a few kinds of statements in Rust. The most common two are declaring a variable binding, and using a `;` with an expression: ```rust,editable fn main() { // variable binding let x = 5; // expression; x; x + 1; 15; } ``` Blocks are expressions too, so they can be used as values in assignments. The last expression in the block will be assigned to the place expression such as a local variable. However, if the last expression of the block ends with a semicolon, the return value will be `()`. ```rust,editable fn main() { let x = 5u32; let y = { let x_squared = x * x; let x_cube = x_squared * x; // This expression will be assigned to `y` x_cube + x_squared + x }; let z = { // The semicolon suppresses this expression and `()` is assigned to `z` 2 * x; }; println!("x is {:?}", x); println!("y is {:?}", y); println!("z is {:?}", z); } ``` ================================================ FILE: src/flow_control/for.md ================================================ # for loops ## for and range The `for in` construct can be used to iterate through an `Iterator`. One of the easiest ways to create an iterator is to use the range notation `a..b`. This yields values from `a` (inclusive) to `b` (exclusive) in steps of one. Let's write FizzBuzz using `for` instead of `while`. ```rust,editable fn main() { // `n` will take the values: 1, 2, ..., 100 in each iteration for n in 1..101 { if n % 15 == 0 { println!("fizzbuzz"); } else if n % 3 == 0 { println!("fizz"); } else if n % 5 == 0 { println!("buzz"); } else { println!("{}", n); } } } ``` Alternatively, `a..=b` can be used for a range that is inclusive on both ends. The above can be written as: ```rust,editable fn main() { // `n` will take the values: 1, 2, ..., 100 in each iteration for n in 1..=100 { if n % 15 == 0 { println!("fizzbuzz"); } else if n % 3 == 0 { println!("fizz"); } else if n % 5 == 0 { println!("buzz"); } else { println!("{}", n); } } } ``` ## for and iterators The `for in` construct is able to interact with an `Iterator` in several ways. As discussed in the section on the [Iterator][iter] trait, by default the `for` loop will apply the `into_iter` function to the collection. However, this is not the only means of converting collections into iterators. `into_iter`, `iter` and `iter_mut` all handle the conversion of a collection into an iterator in different ways, by providing different views on the data within. * `iter` - This borrows each element of the collection through each iteration. Thus leaving the collection untouched and available for reuse after the loop. ```rust,editable fn main() { let names = vec!["Bob", "Frank", "Ferris"]; for name in names.iter() { match name { &"Ferris" => println!("There is a rustacean among us!"), // TODO ^ Try deleting the & and matching just "Ferris" _ => println!("Hello {}", name), } } println!("names: {:?}", names); } ``` * `into_iter` - This consumes the collection so that on each iteration the exact data is provided. Once the collection has been consumed it is no longer available for reuse as it has been 'moved' within the loop. ```rust,editable,ignore,mdbook-runnable fn main() { let names = vec!["Bob", "Frank", "Ferris"]; for name in names.into_iter() { match name { "Ferris" => println!("There is a rustacean among us!"), _ => println!("Hello {}", name), } } println!("names: {:?}", names); // FIXME ^ Comment out this line } ``` * `iter_mut` - This mutably borrows each element of the collection, allowing for the collection to be modified in place. ```rust,editable fn main() { let mut names = vec!["Bob", "Frank", "Ferris"]; for name in names.iter_mut() { *name = match name { &mut "Ferris" => "There is a rustacean among us!", _ => "Hello", } } println!("names: {:?}", names); } ``` In the above snippets note the type of `match` branch, that is the key difference in the types of iteration. The difference in type then of course implies differing actions that are able to be performed. ### See also: [Iterator][iter] [iter]: ../trait/iter.md ================================================ FILE: src/flow_control/if_else.md ================================================ # if/else Branching with `if`-`else` is similar to other languages. Unlike many of them, the boolean condition doesn't need to be surrounded by parentheses, and each condition is followed by a block. `if`-`else` conditionals are expressions, and, all branches must return the same type. ```rust,editable fn main() { let n = 5; if n < 0 { print!("{} is negative", n); } else if n > 0 { print!("{} is positive", n); } else { print!("{} is zero", n); } let big_n = if n < 10 && n > -10 { println!(", and is a small number, increase ten-fold"); // This expression returns an `i32`. 10 * n } else { println!(", and is a big number, halve the number"); // This expression must return an `i32` as well. n / 2 // TODO ^ Try suppressing this expression with a semicolon. }; // ^ Don't forget to put a semicolon here! All `let` bindings need it. println!("{} -> {}", n, big_n); } ``` ================================================ FILE: src/flow_control/if_let.md ================================================ # if let For some use cases, when matching enums, `match` is awkward. For example: ```rust // Make `optional` of type `Option` let optional = Some(7); match optional { Some(i) => println!("This is a really long string and `{:?}`", i), _ => {}, // ^ Required because `match` is exhaustive. Doesn't it seem // like wasted space? }; ``` `if let` is cleaner for this use case and in addition allows various failure options to be specified: ```rust,editable fn main() { // All have type `Option` let number = Some(7); let letter: Option = None; let emoticon: Option = None; // The `if let` construct reads: "if `let` destructures `number` into // `Some(i)`, evaluate the block (`{}`). if let Some(i) = number { println!("Matched {:?}!", i); } // If you need to specify a failure, use an else: if let Some(i) = letter { println!("Matched {:?}!", i); } else { // Destructure failed. Change to the failure case. println!("Didn't match a number. Let's go with a letter!"); } // Provide an altered failing condition. let i_like_letters = false; if let Some(i) = emoticon { println!("Matched {:?}!", i); // Destructure failed. Evaluate an `else if` condition to see if the // alternate failure branch should be taken: } else if i_like_letters { println!("Didn't match a number. Let's go with a letter!"); } else { // The condition evaluated false. This branch is the default: println!("I don't like letters. Let's go with an emoticon :)!"); } } ``` In the same way, `if let` can be used to match any enum value: ```rust,editable // Our example enum enum Foo { Bar, Baz, Qux(u32) } fn main() { // Create example variables let a = Foo::Bar; let b = Foo::Baz; let c = Foo::Qux(100); // Variable a matches Foo::Bar if let Foo::Bar = a { println!("a is foobar"); } // Variable b does not match Foo::Bar // So this will print nothing if let Foo::Bar = b { println!("b is foobar"); } // Variable c matches Foo::Qux which has a value // Similar to Some() in the previous example if let Foo::Qux(value) = c { println!("c is {}", value); } // Binding also works with `if let` if let Foo::Qux(value @ 100) = c { println!("c is one hundred"); } } ``` Another benefit is that `if let` allows us to match non-parameterized enum variants. This is true even in cases where the enum doesn't implement or derive `PartialEq`. In such cases `if Foo::Bar == a` would fail to compile, because instances of the enum cannot be equated, however `if let` will continue to work. Would you like a challenge? Fix the following example to use `if let`: ```rust,editable,ignore,mdbook-runnable // This enum purposely neither implements nor derives PartialEq. // That is why comparing Foo::Bar == a fails below. enum Foo {Bar} fn main() { let a = Foo::Bar; // Variable a matches Foo::Bar if Foo::Bar == a { // ^-- this causes a compile-time error. Use `if let` instead. println!("a is foobar"); } } ``` ### See also: [`enum`][enum], [`Option`][option], and the [RFC][if_let_rfc] [enum]: ../custom_types/enum.md [if_let_rfc]: https://github.com/rust-lang/rfcs/pull/160 [option]: ../std/option.md ================================================ FILE: src/flow_control/let_else.md ================================================ # let-else > 🛈 stable since: rust 1.65 > > 🛈 you can target specific edition by compiling like this > `rustc --edition=2021 main.rs` With `let`-`else`, a refutable pattern can match and bind variables in the surrounding scope like a normal `let`, or else diverge (e.g. `break`, `return`, `panic!`) when the pattern doesn't match. ```rust use std::str::FromStr; fn get_count_item(s: &str) -> (u64, &str) { let mut it = s.split(' '); let (Some(count_str), Some(item)) = (it.next(), it.next()) else { panic!("Can't segment count item pair: '{s}'"); }; let Ok(count) = u64::from_str(count_str) else { panic!("Can't parse integer: '{count_str}'"); }; (count, item) } fn main() { assert_eq!(get_count_item("3 chairs"), (3, "chairs")); } ``` The scope of name bindings is the main thing that makes this different from `match` or `if let`-`else` expressions. You could previously approximate these patterns with an unfortunate bit of repetition and an outer `let`: ```rust # use std::str::FromStr; # # fn get_count_item(s: &str) -> (u64, &str) { # let mut it = s.split(' '); let (count_str, item) = match (it.next(), it.next()) { (Some(count_str), Some(item)) => (count_str, item), _ => panic!("Can't segment count item pair: '{s}'"), }; let count = if let Ok(count) = u64::from_str(count_str) { count } else { panic!("Can't parse integer: '{count_str}'"); }; # (count, item) # } # # assert_eq!(get_count_item("3 chairs"), (3, "chairs")); ``` ### See also: [option][option], [match][match], [if let][if_let] and the [let-else RFC][let_else_rfc]. [match]: ./match.md [if_let]: ./if_let.md [let_else_rfc]: https://rust-lang.github.io/rfcs/3137-let-else.html [option]: ../std/option.md ================================================ FILE: src/flow_control/loop/nested.md ================================================ # Nesting and labels It's possible to `break` or `continue` outer loops when dealing with nested loops. In these cases, the loops must be annotated with some `'label`, and the label must be passed to the `break`/`continue` statement. ```rust,editable #![allow(unreachable_code, unused_labels)] fn main() { 'outer: loop { println!("Entered the outer loop"); 'inner: loop { println!("Entered the inner loop"); // This would break only the inner loop //break; // This breaks the outer loop break 'outer; } println!("This point will never be reached"); } println!("Exited the outer loop"); } ``` ================================================ FILE: src/flow_control/loop/return.md ================================================ # Returning from loops One of the uses of a `loop` is to retry an operation until it succeeds. If the operation returns a value though, you might need to pass it to the rest of the code: put it after the `break`, and it will be returned by the `loop` expression. ```rust,editable fn main() { let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } }; assert_eq!(result, 20); } ``` ================================================ FILE: src/flow_control/loop.md ================================================ # loop Rust provides a `loop` keyword to indicate an infinite loop. The `break` statement can be used to exit a loop at anytime, whereas the `continue` statement can be used to skip the rest of the iteration and start a new one. ```rust,editable fn main() { let mut count = 0u32; println!("Let's count until infinity!"); // Infinite loop loop { count += 1; if count == 3 { println!("three"); // Skip the rest of this iteration continue; } println!("{}", count); if count == 5 { println!("OK, that's enough"); // Exit this loop break; } } } ``` ================================================ FILE: src/flow_control/match/binding.md ================================================ # Binding Indirectly accessing a variable makes it impossible to branch and use that variable without re-binding. `match` provides the `@` sigil for binding values to names: ```rust,editable // A function `age` which returns a `u32`. fn age() -> u32 { 15 } fn main() { println!("Tell me what type of person you are"); match age() { 0 => println!("I haven't celebrated my first birthday yet"), // Could `match` 1 ..= 12 directly but then what age // would the child be? // Could `match` n and use an `if` guard, but would // not contribute to exhaustiveness checks. // (Although in this case that would not matter since // a "catch-all" pattern is present at the bottom) // Instead, bind to `n` for the sequence of 1 ..= 12. // Now the age can be reported. n @ 1 ..= 12 => println!("I'm a child of age {:?}", n), n @ 13 ..= 19 => println!("I'm a teen of age {:?}", n), // A similar binding can be done when matching several values. n @ (1 | 7 | 15 | 13) => println!("I'm a teen of age {:?}", n), // Nothing bound. Return the result. n => println!("I'm an old person of age {:?}", n), } } ``` You can also use binding to "destructure" `enum` variants, such as `Option`: ```rust,editable fn some_number() -> Option { Some(42) } fn main() { match some_number() { // Got `Some` variant, match if its value, bound to `n`, // is equal to 42. // Could also use `Some(42)` and print `"The Answer: 42!"` // but that would require changing `42` in 2 spots should // you ever wish to change it. // Could also use `Some(n) if n == 42` and print `"The Answer: {n}!"` // but that would not contribute to exhaustiveness checks. // (Although in this case that would not matter since // the next arm is a "catch-all" pattern) Some(n @ 42) => println!("The Answer: {}!", n), // Match any other number. Some(n) => println!("Not interesting... {}", n), // Match anything else (`None` variant). _ => (), } } ``` ### See also: [`functions`][functions], [`enums`][enums] and [`Option`][option] [functions]: ../../fn.md [enums]: ../../custom_types/enum.md [option]: ../../std/option.md ================================================ FILE: src/flow_control/match/destructuring/destructure_enum.md ================================================ # enums An `enum` is destructured similarly: ```rust,editable // `allow` required to silence warnings because only // one variant is used. #[allow(dead_code)] enum Color { // These 3 are specified solely by their name. Red, Blue, Green, // These likewise tie `u32` tuples to different names: color models. RGB(u32, u32, u32), HSV(u32, u32, u32), HSL(u32, u32, u32), CMY(u32, u32, u32), CMYK(u32, u32, u32, u32), } fn main() { let color = Color::RGB(122, 17, 40); // TODO ^ Try different variants for `color` println!("What color is it?"); // An `enum` can be destructured using a `match`. match color { Color::Red => println!("The color is Red!"), Color::Blue => println!("The color is Blue!"), Color::Green => println!("The color is Green!"), Color::RGB(r, g, b) => println!("Red: {}, green: {}, and blue: {}!", r, g, b), Color::HSV(h, s, v) => println!("Hue: {}, saturation: {}, value: {}!", h, s, v), Color::HSL(h, s, l) => println!("Hue: {}, saturation: {}, lightness: {}!", h, s, l), Color::CMY(c, m, y) => println!("Cyan: {}, magenta: {}, yellow: {}!", c, m, y), Color::CMYK(c, m, y, k) => println!("Cyan: {}, magenta: {}, yellow: {}, key (black): {}!", c, m, y, k), // Don't need another arm because all variants have been examined } } ``` ### See also: [`#[allow(...)]`][allow], [color models][color_models] and [`enum`][enum] [allow]: ../../../attribute/unused.md [color_models]: https://en.wikipedia.org/wiki/Color_model [enum]: ../../../custom_types/enum.md ================================================ FILE: src/flow_control/match/destructuring/destructure_pointers.md ================================================ # pointers/ref For pointers, a distinction needs to be made between destructuring and dereferencing as they are different concepts which are used differently from languages like C/C++. * Dereferencing uses `*` * Destructuring uses `&`, `ref`, and `ref mut` ```rust,editable fn main() { // Assign a reference of type `i32`. The `&` signifies there // is a reference being assigned. let reference = &4; match reference { // If `reference` is pattern matched against `&val`, it results // in a comparison like: // `&i32` // `&val` // ^ We see that if the matching `&`s are dropped, then the `i32` // should be assigned to `val`. &val => println!("Got a value via destructuring: {:?}", val), } // To avoid the `&`, you dereference before matching. match *reference { val => println!("Got a value via dereferencing: {:?}", val), } // What if you don't start with a reference? `reference` was a `&` // because the right side was already a reference. This is not // a reference because the right side is not one. let _not_a_reference = 3; // Rust provides `ref` for exactly this purpose. It modifies the // assignment so that a reference is created for the element; this // reference is assigned. let ref _is_a_reference = 3; // Accordingly, by defining 2 values without references, references // can be retrieved via `ref` and `ref mut`. let value = 5; let mut mut_value = 6; // Use `ref` keyword to create a reference. match value { ref r => println!("Got a reference to a value: {:?}", r), } // Use `ref mut` similarly. match mut_value { ref mut m => { // Got a reference. Gotta dereference it before we can // add anything to it. *m += 10; println!("We added 10. `mut_value`: {:?}", m); }, } } ``` ### See also: [The ref pattern](../../../scope/borrow/ref.md) ================================================ FILE: src/flow_control/match/destructuring/destructure_slice.md ================================================ # arrays/slices Like tuples, arrays and slices can be destructured this way: ```rust,editable fn main() { // Try changing the values in the array, or make it a slice! let array = [1, -2, 6]; match array { // Binds the second and the third elements to the respective variables [0, second, third] => println!("array[0] = 0, array[1] = {}, array[2] = {}", second, third), // Single values can be ignored with _ [1, _, third] => println!( "array[0] = 1, array[2] = {} and array[1] was ignored", third ), // You can also bind some and ignore the rest [-1, second, ..] => println!( "array[0] = -1, array[1] = {} and all the other ones were ignored", second ), // The code below would not compile // [-1, second] => ... // Or store them in another array/slice (the type depends on // that of the value that is being matched against) [3, second, tail @ ..] => println!( "array[0] = 3, array[1] = {} and the other elements were {:?}", second, tail ), // Combining these patterns, we can, for example, bind the first and // last values, and store the rest of them in a single array [first, middle @ .., last] => println!( "array[0] = {}, middle = {:?}, array[2] = {}", first, middle, last ), } } ``` ### See also: [Arrays and Slices](../../../primitives/array.md) and [Binding](../binding.md) for `@` sigil ================================================ FILE: src/flow_control/match/destructuring/destructure_structures.md ================================================ # structs Similarly, a `struct` can be destructured as shown: ```rust,editable fn main() { struct Foo { x: (u32, u32), y: u32, } // Try changing the values in the struct to see what happens let foo = Foo { x: (1, 2), y: 3 }; match foo { Foo { x: (1, b), y } => println!("First of x is 1, b = {}, y = {} ", b, y), // you can destructure structs and rename the variables, // the order is not important Foo { y: 2, x: i } => println!("y is 2, i = {:?}", i), // and you can also ignore some variables: Foo { y, .. } => println!("y = {}, we don't care about x", y), // this will give an error: pattern does not mention field `x` //Foo { y } => println!("y = {}", y), } let faa = Foo { x: (1, 2), y: 3 }; // You do not need a match block to destructure structs: let Foo { x : x0, y: y0 } = faa; println!("Outside: x0 = {x0:?}, y0 = {y0}"); // Destructuring works with nested structs as well: struct Bar { foo: Foo, } let bar = Bar { foo: faa }; let Bar { foo: Foo { x: nested_x, y: nested_y } } = bar; println!("Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}"); } ``` ### See also: [Structs](../../../custom_types/structs.md) ================================================ FILE: src/flow_control/match/destructuring/destructure_tuple.md ================================================ # tuples Tuples can be destructured in a `match` as follows: ```rust,editable fn main() { let triple = (0, -2, 3); // TODO ^ Try different values for `triple` println!("Tell me about {:?}", triple); // Match can be used to destructure a tuple match triple { // Destructure the second and third elements (0, y, z) => println!("First is `0`, `y` is {:?}, and `z` is {:?}", y, z), (1, ..) => println!("First is `1` and the rest doesn't matter"), (.., 2) => println!("last is `2` and the rest doesn't matter"), (3, .., 4) => println!("First is `3`, last is `4`, and the rest doesn't matter"), // `..` can be used to ignore the rest of the tuple _ => println!("It doesn't matter what they are"), // `_` means don't bind the value to a variable } } ``` ### See also: [Tuples](../../../primitives/tuples.md) ================================================ FILE: src/flow_control/match/destructuring.md ================================================ # Destructuring A `match` block can destructure items in a variety of ways. * [Destructuring Tuples][tuple] * [Destructuring Arrays and Slices][slice] * [Destructuring Enums][enum] * [Destructuring Pointers][refs] * [Destructuring Structures][struct] [enum]: destructuring/destructure_enum.md [refs]: destructuring/destructure_pointers.md [struct]: destructuring/destructure_structures.md [tuple]: destructuring/destructure_tuple.md [slice]: destructuring/destructure_slice.md ### See also: [The Rust Reference for Destructuring](https://doc.rust-lang.org/reference/patterns.html#r-patterns.destructure) ================================================ FILE: src/flow_control/match/guard.md ================================================ # Guards A `match` *guard* can be added to filter the arm. ```rust,editable #[allow(dead_code)] enum Temperature { Celsius(i32), Fahrenheit(i32), } fn main() { let temperature = Temperature::Celsius(35); // ^ TODO try different values for `temperature` match temperature { Temperature::Celsius(t) if t > 30 => println!("{}C is above 30 Celsius", t), // The `if condition` part ^ is a guard Temperature::Celsius(t) => println!("{}C is equal to or below 30 Celsius", t), Temperature::Fahrenheit(t) if t > 86 => println!("{}F is above 86 Fahrenheit", t), Temperature::Fahrenheit(t) => println!("{}F is equal to or below 86 Fahrenheit", t), } } ``` Note that the compiler won't take guard conditions into account when checking if all patterns are covered by the match expression. ```rust,editable,ignore,mdbook-runnable fn main() { let number: u8 = 4; match number { i if i == 0 => println!("Zero"), i if i > 0 => println!("Greater than zero"), // _ => unreachable!("Should never happen."), // TODO ^ uncomment to fix compilation } } ``` ### See also: [Tuples](../../primitives/tuples.md) [Enums](../../custom_types/enum.md) ================================================ FILE: src/flow_control/match.md ================================================ # match Rust provides pattern matching via the `match` keyword, which can be used like a C `switch`. The first matching arm is evaluated and all possible values must be covered. ```rust,editable fn main() { let number = 13; // TODO ^ Try different values for `number` println!("Tell me about {}", number); match number { // Match a single value 1 => println!("One!"), // Match several values 2 | 3 | 5 | 7 | 11 => println!("This is a prime"), // TODO ^ Try adding 13 to the list of prime values // Match an inclusive range 13..=19 => println!("A teen"), // Handle the rest of cases _ => println!("Ain't special"), // TODO ^ Try commenting out this catch-all arm } let boolean = true; // Match is an expression too let binary = match boolean { // The arms of a match must cover all the possible values false => 0, true => 1, // TODO ^ Try commenting out one of these arms }; println!("{} -> {}", boolean, binary); } ``` ================================================ FILE: src/flow_control/while.md ================================================ # while The `while` keyword can be used to run a loop while a condition is true. Let's write the infamous [FizzBuzz][fizzbuzz] using a `while` loop. ```rust,editable fn main() { // A counter variable let mut n = 1; // Loop while `n` is less than 101 while n < 101 { if n % 15 == 0 { println!("fizzbuzz"); } else if n % 3 == 0 { println!("fizz"); } else if n % 5 == 0 { println!("buzz"); } else { println!("{}", n); } // Increment counter n += 1; } } ``` [fizzbuzz]: https://en.wikipedia.org/wiki/Fizz_buzz ================================================ FILE: src/flow_control/while_let.md ================================================ # while let Similar to `if let`, `while let` can make awkward `match` sequences more tolerable. Consider the following sequence that increments `i`: ```rust // Make `optional` of type `Option` let mut optional = Some(0); // Repeatedly try this test. loop { match optional { // If `optional` destructures, evaluate the block. Some(i) => { if i > 9 { println!("Greater than 9, quit!"); optional = None; } else { println!("`i` is `{:?}`. Try again.", i); optional = Some(i + 1); } // ^ Requires 3 indentations! }, // Quit the loop when the destructure fails: _ => { break; } // ^ Why should this be required? There must be a better way! } } ``` Using `while let` makes this sequence much nicer: ```rust,editable fn main() { // Make `optional` of type `Option` let mut optional = Some(0); // This reads: "while `let` destructures `optional` into // `Some(i)`, evaluate the block (`{}`). Else `break`. while let Some(i) = optional { if i > 9 { println!("Greater than 9, quit!"); optional = None; } else { println!("`i` is `{:?}`. Try again.", i); optional = Some(i + 1); } // ^ Less rightward drift and doesn't require // explicitly handling the failing case. } // ^ `if let` had additional optional `else`/`else if` // clauses. `while let` does not have these. } ``` ### See also: [`enum`][enum], [`Option`][option], and the [RFC][while_let_rfc] [enum]: ../custom_types/enum.md [option]: ../std/option.md [while_let_rfc]: https://github.com/rust-lang/rfcs/pull/214 ================================================ FILE: src/flow_control.md ================================================ # Flow of Control An integral part of any programming language are ways to modify control flow: `if`/`else`, `for`, and others. Let's talk about them in Rust. ================================================ FILE: src/fn/closures/anonymity.md ================================================ # Type anonymity Closures succinctly capture variables from enclosing scopes. Does this have any consequences? It surely does. Observe how using a closure as a function parameter requires [generics], which is necessary because of how they are defined: ```rust // `F` must be generic. fn apply(f: F) where F: FnOnce() { f(); } ``` When a closure is defined, the compiler implicitly creates a new anonymous structure to store the captured variables inside, meanwhile implementing the functionality via one of the `traits`: `Fn`, `FnMut`, or `FnOnce` for this unknown type. This type is assigned to the variable which is stored until calling. Since this new type is of unknown type, any usage in a function will require generics. However, an unbounded type parameter `` would still be ambiguous and not be allowed. Thus, bounding by one of the `traits`: `Fn`, `FnMut`, or `FnOnce` (which it implements) is sufficient to specify its type. ```rust,editable // `F` must implement `Fn` for a closure which takes no // inputs and returns nothing - exactly what is required // for `print`. fn apply(f: F) where F: Fn() { f(); } fn main() { let x = 7; // Capture `x` into an anonymous type and implement // `Fn` for it. Store it in `print`. let print = || println!("{}", x); apply(print); } ``` ### See also: [A thorough analysis][thorough_analysis], [`Fn`][fn], [`FnMut`][fn_mut], and [`FnOnce`][fn_once] [generics]: ../../generics.md [fn]: https://doc.rust-lang.org/std/ops/trait.Fn.html [fn_mut]: https://doc.rust-lang.org/std/ops/trait.FnMut.html [fn_once]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html [thorough_analysis]: https://huonw.github.io/blog/2015/05/finding-closure-in-rust/ ================================================ FILE: src/fn/closures/capture.md ================================================ # Capturing Closures are inherently flexible and will do what the functionality requires to make the closure work without annotation. This allows capturing to flexibly adapt to the use case, sometimes moving and sometimes borrowing. Closures can capture variables: * by reference: `&T` * by mutable reference: `&mut T` * by value: `T` They preferentially capture variables by reference and only go lower when required. ```rust,editable fn main() { use std::mem; let color = String::from("green"); // A closure to print `color` which immediately borrows (`&`) `color` and // stores the borrow and closure in the `print` variable. It will remain // borrowed until `print` is used the last time. // // `println!` only requires arguments by immutable reference so it doesn't // impose anything more restrictive. let print = || println!("`color`: {}", color); // Call the closure using the borrow. print(); // `color` can be borrowed immutably again, because the closure only holds // an immutable reference to `color`. let _reborrow = &color; print(); // A move or reborrow is allowed after the final use of `print` let _color_moved = color; let mut count = 0; // A closure to increment `count` could take either `&mut count` or `count` // but `&mut count` is less restrictive so it takes that. Immediately // borrows `count`. // // A `mut` is required on `inc` because a `&mut` is stored inside. Thus, // calling the closure mutates `count` which requires a `mut`. let mut inc = || { count += 1; println!("`count`: {}", count); }; // Call the closure using a mutable borrow. inc(); // The closure still mutably borrows `count` because it is called later. // An attempt to reborrow will lead to an error. // let _reborrow = &count; // ^ TODO: try uncommenting this line. inc(); // The closure no longer needs to borrow `&mut count`. Therefore, it is // possible to reborrow without an error let _count_reborrowed = &mut count; // A non-copy type. let movable = Box::new(3); // `mem::drop` requires `T` so this must take by value. A copy type // would copy into the closure leaving the original untouched. // A non-copy must move and so `movable` immediately moves into // the closure. let consume = || { println!("`movable`: {:?}", movable); mem::drop(movable); }; // `consume` consumes the variable so this can only be called once. consume(); // consume(); // ^ TODO: Try uncommenting this line. } ``` Using `move` before vertical pipes forces closure to take ownership of captured variables: ```rust,editable fn main() { // `Vec` has non-copy semantics. let haystack = vec![1, 2, 3]; let contains = move |needle| haystack.contains(needle); println!("{}", contains(&1)); println!("{}", contains(&4)); // println!("There're {} elements in vec", haystack.len()); // ^ Uncommenting above line will result in compile-time error // because borrow checker doesn't allow re-using variable after it // has been moved. // Removing `move` from closure's signature will cause closure // to borrow _haystack_ variable immutably, hence _haystack_ is still // available and uncommenting above line will not cause an error. } ``` ### See also: [`Box`][box] and [`std::mem::drop`][drop] [box]: ../../std/box.md [drop]: https://doc.rust-lang.org/std/mem/fn.drop.html ================================================ FILE: src/fn/closures/closure_examples/iter_any.md ================================================ # Iterator::any `Iterator::any` is a function which when passed an iterator, will return `true` if any element satisfies the predicate. Otherwise `false`. Its signature: ```rust,ignore pub trait Iterator { // The type being iterated over. type Item; // `any` takes `&mut self` meaning the caller may be borrowed // and modified, but not consumed. fn any(&mut self, f: F) -> bool where // `FnMut` meaning any captured variable may at most be // modified, not consumed. `Self::Item` is the closure parameter type, // which is determined by the iterator (e.g., `&T` for `.iter()`, // `T` for `.into_iter()`). F: FnMut(Self::Item) -> bool; } ``` ```rust,editable fn main() { let vec1 = vec![1, 2, 3]; let vec2 = vec![4, 5, 6]; // `iter()` for vecs yields `&i32`. Destructure to `i32`. println!("2 in vec1: {}", vec1.iter() .any(|&x| x == 2)); // `into_iter()` for vecs yields `i32`. No destructuring required. println!("2 in vec2: {}", vec2.into_iter().any(|x| x == 2)); // `iter()` only borrows `vec1` and its elements, so they can be used again println!("vec1 len: {}", vec1.len()); println!("First element of vec1 is: {}", vec1[0]); // `into_iter()` does move `vec2` and its elements, so they cannot be used again // println!("First element of vec2 is: {}", vec2[0]); // println!("vec2 len: {}", vec2.len()); // TODO: uncomment two lines above and see compiler errors. let array1 = [1, 2, 3]; let array2 = [4, 5, 6]; // `iter()` for arrays yields `&i32`. println!("2 in array1: {}", array1.iter() .any(|&x| x == 2)); // `into_iter()` for arrays yields `i32`. println!("2 in array2: {}", array2.into_iter().any(|x| x == 2)); } ``` ### See also: [`std::iter::Iterator::any`][any] [any]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.any ================================================ FILE: src/fn/closures/closure_examples/iter_find.md ================================================ # Searching through iterators `Iterator::find` is a function which iterates over an iterator and searches for the first value which satisfies some condition. If none of the values satisfy the condition, it returns `None`. Its signature: ```rust,ignore pub trait Iterator { // The type being iterated over. type Item; // `find` takes `&mut self` meaning the caller may be borrowed // and modified, but not consumed. fn find
' panicked at 'division by zero', panic.rs:5 ==4401== ==4401== HEAP SUMMARY: ==4401== in use at exit: 0 bytes in 0 blocks ==4401== total heap usage: 18 allocs, 18 frees, 1,648 bytes allocated ==4401== ==4401== All heap blocks were freed -- no leaks are possible ==4401== ==4401== For counts of detected and suppressed errors, rerun with: -v ==4401== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) ``` ================================================ FILE: src/std/rc.md ================================================ # `Rc` When multiple ownership is needed, `Rc`(Reference Counting) can be used. `Rc` keeps track of the number of the references which means the number of owners of the value wrapped inside an `Rc`. Reference count of an `Rc` increases by 1 whenever an `Rc` is cloned, and decreases by 1 whenever one cloned `Rc` is dropped out of the scope. When an `Rc`'s reference count becomes zero (which means there are no remaining owners), both the `Rc` and the value are all dropped. Cloning an `Rc` never performs a deep copy. Cloning creates just another pointer to the wrapped value, and increments the count. ```rust,editable use std::rc::Rc; fn main() { let rc_examples = "Rc examples".to_string(); { println!("--- rc_a is created ---"); let rc_a: Rc = Rc::new(rc_examples); println!("Reference Count of rc_a: {}", Rc::strong_count(&rc_a)); { println!("--- rc_a is cloned to rc_b ---"); let rc_b: Rc = Rc::clone(&rc_a); println!("Reference Count of rc_b: {}", Rc::strong_count(&rc_b)); println!("Reference Count of rc_a: {}", Rc::strong_count(&rc_a)); // Two `Rc`s are equal if their inner values are equal println!("rc_a and rc_b are equal: {}", rc_a.eq(&rc_b)); // We can use methods of a value directly println!("Length of the value inside rc_a: {}", rc_a.len()); println!("Value of rc_b: {}", rc_b); println!("--- rc_b is dropped out of scope ---"); } println!("Reference Count of rc_a: {}", Rc::strong_count(&rc_a)); println!("--- rc_a is dropped out of scope ---"); } // Error! `rc_examples` already moved into `rc_a` // And when `rc_a` is dropped, `rc_examples` is dropped together // println!("rc_examples: {}", rc_examples); // TODO ^ Try uncommenting this line } ``` ### See also: [std::rc][1] and [std::sync::arc][2]. [1]: https://doc.rust-lang.org/std/rc/index.html [2]: https://doc.rust-lang.org/std/sync/struct.Arc.html ================================================ FILE: src/std/result/question_mark.md ================================================ # `?` Chaining results using match can get pretty untidy; luckily, the `?` operator can be used to make things pretty again. `?` is used at the end of an expression returning a `Result`, and is equivalent to a match expression, where the `Err(err)` branch expands to an early `return Err(From::from(err))`, and the `Ok(ok)` branch expands to an `ok` expression. ```rust,editable,ignore,mdbook-runnable mod checked { #[derive(Debug)] enum MathError { DivisionByZero, NonPositiveLogarithm, NegativeSquareRoot, } type MathResult = Result; fn div(x: f64, y: f64) -> MathResult { if y == 0.0 { Err(MathError::DivisionByZero) } else { Ok(x / y) } } fn sqrt(x: f64) -> MathResult { if x < 0.0 { Err(MathError::NegativeSquareRoot) } else { Ok(x.sqrt()) } } fn ln(x: f64) -> MathResult { if x <= 0.0 { Err(MathError::NonPositiveLogarithm) } else { Ok(x.ln()) } } // Intermediate function fn op_(x: f64, y: f64) -> MathResult { // if `div` "fails", then `DivisionByZero` will be `return`ed let ratio = div(x, y)?; // if `ln` "fails", then `NonPositiveLogarithm` will be `return`ed let ln = ln(ratio)?; sqrt(ln) } pub fn op(x: f64, y: f64) { match op_(x, y) { Err(why) => panic!("{}", match why { MathError::NonPositiveLogarithm => "logarithm of non-positive number", MathError::DivisionByZero => "division by zero", MathError::NegativeSquareRoot => "square root of negative number", }), Ok(value) => println!("{}", value), } } } fn main() { checked::op(1.0, 10.0); } ``` Be sure to check the [documentation][docs], as there are many methods to map/compose `Result`. [docs]: https://doc.rust-lang.org/std/result/index.html ================================================ FILE: src/std/result.md ================================================ # `Result` We've seen that the `Option` enum can be used as a return value from functions that may fail, where `None` can be returned to indicate failure. However, sometimes it is important to express *why* an operation failed. To do this we have the `Result` enum. The `Result` enum has two variants: * `Ok(value)` which indicates that the operation succeeded, and wraps the `value` returned by the operation. (`value` has type `T`) * `Err(why)`, which indicates that the operation failed, and wraps `why`, which (hopefully) explains the cause of the failure. (`why` has type `E`) ```rust,editable,ignore,mdbook-runnable mod checked { // Mathematical "errors" we want to catch #[derive(Debug)] pub enum MathError { DivisionByZero, NonPositiveLogarithm, NegativeSquareRoot, } pub type MathResult = Result; pub fn div(x: f64, y: f64) -> MathResult { if y == 0.0 { // This operation would `fail`, instead let's return the reason of // the failure wrapped in `Err` Err(MathError::DivisionByZero) } else { // This operation is valid, return the result wrapped in `Ok` Ok(x / y) } } pub fn sqrt(x: f64) -> MathResult { if x < 0.0 { Err(MathError::NegativeSquareRoot) } else { Ok(x.sqrt()) } } pub fn ln(x: f64) -> MathResult { if x <= 0.0 { Err(MathError::NonPositiveLogarithm) } else { Ok(x.ln()) } } } // `op(x, y)` === `sqrt(ln(x / y))` fn op(x: f64, y: f64) -> f64 { // This is a three level match pyramid! match checked::div(x, y) { Err(why) => panic!("{:?}", why), Ok(ratio) => match checked::ln(ratio) { Err(why) => panic!("{:?}", why), Ok(ln) => match checked::sqrt(ln) { Err(why) => panic!("{:?}", why), Ok(sqrt) => sqrt, }, }, } } fn main() { // Will this fail? println!("{}", op(1.0, 10.0)); } ``` ================================================ FILE: src/std/str.md ================================================ # Strings The two most used string types in Rust are `String` and `&str`. A `String` is stored as a vector of bytes (`Vec`), but guaranteed to always be a valid UTF-8 sequence. `String` is heap allocated, growable and not null terminated. `&str` is a slice (`&[u8]`) that always points to a valid UTF-8 sequence, and can be used to view into a `String`, just like `&[T]` is a view into `Vec`. ```rust,editable fn main() { // (all the type annotations are superfluous) // A reference to a string allocated in read only memory let pangram: &'static str = "the quick brown fox jumps over the lazy dog"; println!("Pangram: {}", pangram); // Iterate over words in reverse, no new string is allocated println!("Words in reverse"); for word in pangram.split_whitespace().rev() { println!("> {}", word); } // Copy chars into a vector, sort and remove duplicates let mut chars: Vec = pangram.chars().collect(); chars.sort(); chars.dedup(); // Create an empty and growable `String` let mut string = String::new(); for c in chars { // Insert a char at the end of string string.push(c); // Insert a string at the end of string string.push_str(", "); } // The trimmed string is a slice to the original string, hence no new // allocation is performed let chars_to_trim: &[char] = &[' ', ',']; let trimmed_str: &str = string.trim_matches(chars_to_trim); println!("Used characters: {}", trimmed_str); // Heap allocate a string let alice = String::from("I like dogs"); // Allocate new memory and store the modified string there let bob: String = alice.replace("dog", "cat"); println!("Alice says: {}", alice); println!("Bob says: {}", bob); } ``` More `str`/`String` methods can be found under the [std::str][str] and [std::string][string] modules ## Literals and escapes There are multiple ways to write string literals with special characters in them. All result in a similar `&str` so it's best to use the form that is the most convenient to write. Similarly there are multiple ways to write byte string literals, which all result in `&[u8; N]`. Generally special characters are escaped with a backslash character: `\`. This way you can add any character to your string, even unprintable ones and ones that you don't know how to type. If you want a literal backslash, escape it with another one: `\\` String or character literal delimiters occurring within a literal must be escaped: `"\""`, `'\''`. ```rust,editable fn main() { // You can use escapes to write bytes by their hexadecimal values... let byte_escape = "I'm writing \x52\x75\x73\x74!"; println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape); // ...or Unicode code points. let unicode_codepoint = "\u{211D}"; let character_name = "\"DOUBLE-STRUCK CAPITAL R\""; println!("Unicode character {} (U+211D) is called {}", unicode_codepoint, character_name ); let long_string = "String literals can span multiple lines. The linebreak and indentation here ->\ <- can be escaped too!"; println!("{}", long_string); } ``` Sometimes there are just too many characters that need to be escaped or it's just much more convenient to write a string out as-is. This is where raw string literals come into play. ```rust, editable fn main() { let raw_str = r"Escapes don't work here: \x3F \u{211D}"; println!("{}", raw_str); // If you need quotes in a raw string, add a pair of #s let quotes = r#"And then I said: "There is no escape!""#; println!("{}", quotes); // If you need "# in your string, just use more #s in the delimiter. // You can use up to 255 #s. let longer_delimiter = r###"A string with "# in it. And even "##!"###; println!("{}", longer_delimiter); } ``` Want a string that's not UTF-8? (Remember, `str` and `String` must be valid UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings to the rescue! ```rust, editable use std::str; fn main() { // Note that this is not actually a `&str` let bytestring: &[u8; 21] = b"this is a byte string"; // Byte arrays don't have the `Display` trait, so printing them is a bit limited println!("A byte string: {:?}", bytestring); // Byte strings can have byte escapes... let escaped = b"\x52\x75\x73\x74 as bytes"; // ...but no unicode escapes // let escaped = b"\u{211D} is not allowed"; println!("Some escaped bytes: {:?}", escaped); // Raw byte strings work just like raw strings let raw_bytestring = br"\u{211D} is not escaped here"; println!("{:?}", raw_bytestring); // Converting a byte array to `str` can fail if let Ok(my_str) = str::from_utf8(raw_bytestring) { println!("And the same as text: '{}'", my_str); } let _quotes = br#"You can also use "fancier" formatting, \ like with normal raw strings"#; // Byte strings don't have to be UTF-8 let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82\xbb"; // "ようこそ" in SHIFT-JIS // But then they can't always be converted to `str` match str::from_utf8(shift_jis) { Ok(my_str) => println!("Conversion successful: '{}'", my_str), Err(e) => println!("Conversion failed: {:?}", e), }; } ``` For conversions between character encodings check out the [encoding][encoding-crate] crate. A more detailed listing of the ways to write string literals and escape characters is given in the ['Tokens' chapter][tokens] of the Rust Reference. [str]: https://doc.rust-lang.org/std/str/ [string]: https://doc.rust-lang.org/std/string/ [tokens]: https://doc.rust-lang.org/reference/tokens.html [encoding-crate]: https://crates.io/crates/encoding ================================================ FILE: src/std/vec.md ================================================ # Vectors Vectors are re-sizable arrays. Like slices, their size is not known at compile time, but they can grow or shrink at any time. A vector is represented using 3 parameters: - pointer to the data - length - capacity The capacity indicates how much memory is reserved for the vector. The vector can grow as long as the length is smaller than the capacity. When this threshold needs to be surpassed, the vector is reallocated with a larger capacity. ```rust,editable,ignore,mdbook-runnable fn main() { // Iterators can be collected into vectors let collected_iterator: Vec = (0..10).collect(); println!("Collected (0..10) into: {:?}", collected_iterator); // The `vec!` macro can be used to initialize a vector let mut xs = vec![1i32, 2, 3]; println!("Initial vector: {:?}", xs); // Insert new element at the end of the vector println!("Push 4 into the vector"); xs.push(4); println!("Vector: {:?}", xs); // Error! Immutable vectors can't grow collected_iterator.push(0); // FIXME ^ Comment out this line // The `len` method yields the number of elements currently stored in a vector println!("Vector length: {}", xs.len()); // Indexing is done using the square brackets (indexing starts at 0) println!("Second element: {}", xs[1]); // `pop` removes the last element from the vector and returns it println!("Pop last element: {:?}", xs.pop()); // Out of bounds indexing yields a panic println!("Fourth element: {}", xs[3]); // FIXME ^ Comment out this line // `Vector`s can be easily iterated over println!("Contents of xs:"); for x in xs.iter() { println!("> {}", x); } // A `Vector` can also be iterated over while the iteration // count is enumerated in a separate variable (`i`) for (i, x) in xs.iter().enumerate() { println!("In position {} we have value {}", i, x); } // Thanks to `iter_mut`, mutable `Vector`s can also be iterated // over in a way that allows modifying each value for x in xs.iter_mut() { *x *= 3; } println!("Updated vector: {:?}", xs); } ``` More `Vec` methods can be found under the [std::vec][vec] module [vec]: https://doc.rust-lang.org/std/vec/ ================================================ FILE: src/std.md ================================================ # Std library types The `std` library provides many custom types which expands drastically on the `primitives`. Some of these include: * growable `String`s like: `"hello world"` * growable vectors: `[1, 2, 3]` * optional types: `Option` * error handling types: `Result` * heap allocated pointers: `Box` ### See also: [primitives] and [the std library][std] [primitives]: primitives.md [std]: https://doc.rust-lang.org/std/ ================================================ FILE: src/std_misc/arg/matching.md ================================================ # Argument parsing Matching can be used to parse simple arguments: ```rust,ignore use std::env; fn increase(number: i32) { println!("{}", number + 1); } fn decrease(number: i32) { println!("{}", number - 1); } fn help() { println!("usage: match_args Check whether given string is the answer. match_args {{increase|decrease}} Increase or decrease given integer by one."); } fn main() { let args: Vec = env::args().collect(); match args.len() { // no arguments passed 1 => { println!("My name is 'match_args'. Try passing some arguments!"); }, // one argument passed 2 => { match args[1].parse() { Ok(42) => println!("This is the answer!"), _ => println!("This is not the answer."), } }, // one command and one argument passed 3 => { let cmd = &args[1]; let num = &args[2]; // parse the number let number: i32 = match num.parse() { Ok(n) => { n }, Err(_) => { eprintln!("error: second argument not an integer"); help(); return; }, }; // parse the command match &cmd[..] { "increase" => increase(number), "decrease" => decrease(number), _ => { eprintln!("error: invalid command"); help(); }, } }, // all the other cases _ => { // show a help message help(); } } } ``` If you named your program `match_args.rs` and compile it like this `rustc match_args.rs`, you can execute it as follows: ```shell $ ./match_args Rust This is not the answer. $ ./match_args 42 This is the answer! $ ./match_args do something error: second argument not an integer usage: match_args Check whether given string is the answer. match_args {increase|decrease} Increase or decrease given integer by one. $ ./match_args do 42 error: invalid command usage: match_args Check whether given string is the answer. match_args {increase|decrease} Increase or decrease given integer by one. $ ./match_args increase 42 43 ``` ================================================ FILE: src/std_misc/arg.md ================================================ # Program arguments ## Standard Library The command line arguments can be accessed using `std::env::args`, which returns an iterator that yields a `String` for each argument: ```rust,editable use std::env; fn main() { let args: Vec = env::args().collect(); // The first argument is the path that was used to call the program. println!("My path is {}.", args[0]); // The rest of the arguments are the passed command line parameters. // Call the program like this: // $ ./args arg1 arg2 println!("I got {:?} arguments: {:?}.", args.len() - 1, &args[1..]); } ``` ```shell $ ./args 1 2 3 My path is ./args. I got 3 arguments: ["1", "2", "3"]. ``` ## Crates Alternatively, there are numerous crates that can provide extra functionality when creating command-line applications. One of the more popular command line argument crates being [`clap`]. [`clap`]: https://rust-cli.github.io/book/tutorial/cli-args.html#parsing-cli-arguments-with-clap ================================================ FILE: src/std_misc/channels.md ================================================ # Channels Rust provides asynchronous `channels` for communication between threads. Channels allow a unidirectional flow of information between two end-points: the `Sender` and the `Receiver`. ```rust,editable use std::sync::mpsc::{Sender, Receiver}; use std::sync::mpsc; use std::thread; static NTHREADS: i32 = 3; fn main() { // Channels have two endpoints: the `Sender` and the `Receiver`, // where `T` is the type of the message to be transferred // (type annotation is superfluous) let (tx, rx): (Sender, Receiver) = mpsc::channel(); let mut children = Vec::new(); for id in 0..NTHREADS { // The sender endpoint can be copied let thread_tx = tx.clone(); // Each thread will send its id via the channel let child = thread::spawn(move || { // The thread takes ownership over `thread_tx` // Each thread queues a message in the channel thread_tx.send(id).unwrap(); // Sending is a non-blocking operation, the thread will continue // immediately after sending its message println!("thread {} finished", id); }); children.push(child); } // Here, all the messages are collected let mut ids = Vec::with_capacity(NTHREADS as usize); for _ in 0..NTHREADS { // The `recv` method picks a message from the channel // `recv` will block the current thread if there are no messages available ids.push(rx.recv()); } // Wait for the threads to complete any remaining work for child in children { child.join().expect("oops! the child thread panicked"); } // Show the order in which the messages were sent println!("{:?}", ids); } ``` ================================================ FILE: src/std_misc/ffi.md ================================================ # Foreign Function Interface Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign functions must be declared inside an `extern` block annotated with a `#[link]` attribute containing the name of the foreign library. ```rust,ignore use std::fmt; // this extern block links to the libm library #[cfg(target_family = "windows")] #[link(name = "msvcrt")] extern { // this is a foreign function // that computes the square root of a single precision complex number fn csqrtf(z: Complex) -> Complex; fn ccosf(z: Complex) -> Complex; } #[cfg(target_family = "unix")] #[link(name = "m")] extern { // this is a foreign function // that computes the square root of a single precision complex number fn csqrtf(z: Complex) -> Complex; fn ccosf(z: Complex) -> Complex; } // Since calling foreign functions is considered unsafe, // it's common to write safe wrappers around them. fn cos(z: Complex) -> Complex { unsafe { ccosf(z) } } fn main() { // z = -1 + 0i let z = Complex { re: -1., im: 0. }; // calling a foreign function is an unsafe operation let z_sqrt = unsafe { csqrtf(z) }; println!("the square root of {:?} is {:?}", z, z_sqrt); // calling safe API wrapped around unsafe operation println!("cos({:?}) = {:?}", z, cos(z)); } // Minimal implementation of single precision complex numbers #[repr(C)] #[derive(Clone, Copy)] struct Complex { re: f32, im: f32, } impl fmt::Debug for Complex { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.im < 0. { write!(f, "{}-{}i", self.re, -self.im) } else { write!(f, "{}+{}i", self.re, self.im) } } } ``` ================================================ FILE: src/std_misc/file/create.md ================================================ # `create` The `create` function opens a file in write-only mode. If the file already existed, the old content is destroyed. Otherwise, a new file is created. ```rust,ignore static LOREM_IPSUM: &str = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. "; use std::fs::File; use std::io::prelude::*; use std::path::Path; fn main() { let path = Path::new("lorem_ipsum.txt"); let display = path.display(); // Open a file in write-only mode, returns `io::Result` let mut file = match File::create(&path) { Err(why) => panic!("couldn't create {}: {}", display, why), Ok(file) => file, }; // Write the `LOREM_IPSUM` string to `file`, returns `io::Result<()>` match file.write_all(LOREM_IPSUM.as_bytes()) { Err(why) => panic!("couldn't write to {}: {}", display, why), Ok(_) => println!("successfully wrote to {}", display), } } ``` Here's the expected successful output: ```shell $ rustc create.rs && ./create successfully wrote to lorem_ipsum.txt $ cat lorem_ipsum.txt Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ``` (As in the previous example, you are encouraged to test this example under failure conditions.) The [`OpenOptions`] struct can be used to configure how a file is opened. [`OpenOptions`]: https://doc.rust-lang.org/std/fs/struct.OpenOptions.html ================================================ FILE: src/std_misc/file/open.md ================================================ # `open` The `open` function can be used to open a file in read-only mode. A `File` owns a resource, the file descriptor and takes care of closing the file when it is `drop`ed. ```rust,editable,ignore use std::fs::File; use std::io::prelude::*; use std::path::Path; fn main() { // Create a path to the desired file let path = Path::new("hello.txt"); let display = path.display(); // Open the path in read-only mode, returns `io::Result` let mut file = match File::open(&path) { Err(why) => panic!("couldn't open {}: {}", display, why), Ok(file) => file, }; // Read the file contents into a string, returns `io::Result` let mut s = String::new(); match file.read_to_string(&mut s) { Err(why) => panic!("couldn't read {}: {}", display, why), Ok(_) => print!("{} contains:\n{}", display, s), } // `file` goes out of scope, and the "hello.txt" file gets closed } ``` Here's the expected successful output: ```shell $ echo "Hello World!" > hello.txt $ rustc open.rs && ./open hello.txt contains: Hello World! ``` (You are encouraged to test the previous example under different failure conditions: `hello.txt` doesn't exist, or `hello.txt` is not readable, etc.) ================================================ FILE: src/std_misc/file/read_lines.md ================================================ # `read_lines` ## A naive approach This might be a reasonable first attempt for a beginner's first implementation for reading lines from a file. ```rust,no_run use std::fs::read_to_string; fn read_lines(filename: &str) -> Vec { let mut result = Vec::new(); for line in read_to_string(filename).unwrap().lines() { result.push(line.to_string()) } result } ``` Since the method `lines()` returns an iterator over the lines in the file, we can also perform a map inline and collect the results, yielding a more concise and fluent expression. ```rust,no_run use std::fs::read_to_string; fn read_lines(filename: &str) -> Vec { read_to_string(filename) .unwrap() // panic on possible file-reading errors .lines() // split the string into an iterator of string slices .map(String::from) // make each slice into a string .collect() // gather them together into a vector } ``` Note that in both examples above, we must convert the `&str` reference returned from `lines()` to the owned type `String`, using `.to_string()` and `String::from` respectively. ## A more efficient approach Here we pass ownership of the open `File` to a `BufReader` struct. `BufReader` uses an internal buffer to reduce intermediate allocations. We also update `read_lines` to return an iterator instead of allocating new `String` objects in memory for each line. ```rust,no_run use std::fs::File; use std::io::{self, BufRead}; use std::path::Path; fn main() { // File hosts.txt must exist in the current path if let Ok(lines) = read_lines("./hosts.txt") { // Consumes the iterator, returns an (Optional) String for line in lines.map_while(Result::ok) { println!("{}", line); } } } // The output is wrapped in a Result to allow matching on errors. // Returns an Iterator to the Reader of the lines of the file. fn read_lines

(filename: P) -> io::Result>> where P: AsRef, { let file = File::open(filename)?; Ok(io::BufReader::new(file).lines()) } ``` Running this program simply prints the lines individually. ```shell $ echo -e "127.0.0.1\n192.168.0.1\n" > hosts.txt $ rustc read_lines.rs && ./read_lines 127.0.0.1 192.168.0.1 ``` (Note that since `File::open` expects a generic `AsRef` as argument, we define our generic `read_lines()` method with the same generic constraint, using the `where` keyword.) This process is more efficient than creating a `String` in memory with all of the file's contents. This can especially cause performance issues when working with larger files. ================================================ FILE: src/std_misc/file.md ================================================ # File I/O The `File` struct represents a file that has been opened (it wraps a file descriptor), and gives read and/or write access to the underlying file. Since many things can go wrong when doing file I/O, all the `File` methods return the `io::Result` type, which is an alias for `Result`. This makes the failure of all I/O operations *explicit*. Thanks to this, the programmer can see all the failure paths, and is encouraged to handle them in a proactive manner. ================================================ FILE: src/std_misc/fs.md ================================================ # Filesystem Operations The `std::fs` module contains several functions that deal with the filesystem. ```rust,ignore use std::fs; use std::fs::{File, OpenOptions}; use std::io; use std::io::prelude::*; #[cfg(target_family = "unix")] use std::os::unix; #[cfg(target_family = "windows")] use std::os::windows; use std::path::Path; // A simple implementation of `% cat path` fn cat(path: &Path) -> io::Result { let mut f = File::open(path)?; let mut s = String::new(); match f.read_to_string(&mut s) { Ok(_) => Ok(s), Err(e) => Err(e), } } // A simple implementation of `% echo s > path` fn echo(s: &str, path: &Path) -> io::Result<()> { let mut f = File::create(path)?; f.write_all(s.as_bytes()) } // A simple implementation of `% touch path` (ignores existing files) fn touch(path: &Path) -> io::Result<()> { match OpenOptions::new().create(true).write(true).open(path) { Ok(_) => Ok(()), Err(e) => Err(e), } } fn main() { println!("`mkdir a`"); // Create a directory, returns `io::Result<()>` match fs::create_dir("a") { Err(why) => println!("! {:?}", why.kind()), Ok(_) => {}, } println!("`echo hello > a/b.txt`"); // The previous match can be simplified using the `unwrap_or_else` method echo("hello", &Path::new("a/b.txt")).unwrap_or_else(|why| { println!("! {:?}", why.kind()); }); println!("`mkdir -p a/c/d`"); // Recursively create a directory, returns `io::Result<()>` fs::create_dir_all("a/c/d").unwrap_or_else(|why| { println!("! {:?}", why.kind()); }); println!("`touch a/c/e.txt`"); touch(&Path::new("a/c/e.txt")).unwrap_or_else(|why| { println!("! {:?}", why.kind()); }); println!("`ln -s ../b.txt a/c/b.txt`"); // Create a symbolic link, returns `io::Result<()>` #[cfg(target_family = "unix")] { unix::fs::symlink("../b.txt", "a/c/b.txt").unwrap_or_else(|why| { println!("! {:?}", why.kind()); }); } #[cfg(target_family = "windows")] { windows::fs::symlink_file("../b.txt", "a/c/b.txt").unwrap_or_else(|why| { println!("! {:?}", why.to_string()); }); } println!("`cat a/c/b.txt`"); match cat(&Path::new("a/c/b.txt")) { Err(why) => println!("! {:?}", why.kind()), Ok(s) => println!("> {}", s), } println!("`ls a`"); // Read the contents of a directory, returns `io::Result>` match fs::read_dir("a") { Err(why) => println!("! {:?}", why.kind()), Ok(paths) => for path in paths { println!("> {:?}", path.unwrap().path()); }, } println!("`rm a/c/e.txt`"); // Remove a file, returns `io::Result<()>` fs::remove_file("a/c/e.txt").unwrap_or_else(|why| { println!("! {:?}", why.kind()); }); println!("`rmdir a/c/d`"); // Remove an empty directory, returns `io::Result<()>` fs::remove_dir("a/c/d").unwrap_or_else(|why| { println!("! {:?}", why.kind()); }); } ``` Here's the expected successful output: ```shell $ rustc fs.rs && ./fs `mkdir a` `echo hello > a/b.txt` `mkdir -p a/c/d` `touch a/c/e.txt` `ln -s ../b.txt a/c/b.txt` `cat a/c/b.txt` > hello `ls a` > "a/b.txt" > "a/c" `rm a/c/e.txt` `rmdir a/c/d` ``` And the final state of the `a` directory is: ```shell $ tree a a |-- b.txt `-- c `-- b.txt -> ../b.txt 1 directory, 2 files ``` An alternative way to define the function `cat` is with `?` notation: ```rust,ignore fn cat(path: &Path) -> io::Result { let mut f = File::open(path)?; let mut s = String::new(); f.read_to_string(&mut s)?; Ok(s) } ``` ### See also: [`cfg!`][cfg] [cfg]: ../attribute/cfg.md ================================================ FILE: src/std_misc/path.md ================================================ # Path The `Path` type represents file paths in the underlying filesystem. Across all platforms there is a single `std::path::Path` that abstracts over platform-specific path semantics and separators. Bring it into scope with `use std::path::Path;` when needed. A `Path` can be created from an `OsStr`, and provides several methods to get information from the file/directory the path points to. A `Path` is immutable. The owned version of `Path` is `PathBuf`. The relation between `Path` and `PathBuf` is similar to that of `str` and `String`: a `PathBuf` can be mutated in-place, and can be dereferenced to a `Path`. Note that a `Path` is *not* internally represented as an UTF-8 string, but instead is stored as an `OsString`. Therefore, converting a `Path` to a `&str` is *not* free and may fail (an `Option` is returned). However, a `Path` can be freely converted to an `OsString` or `&OsStr` using `into_os_string` and `as_os_str`, respectively. ```rust,editable use std::path::Path; fn main() { // Create a `Path` from an `&'static str` let path = Path::new("."); // The `display` method returns a `Display`able structure let _display = path.display(); // `join` merges a path with a byte container using the OS specific // separator, and returns a `PathBuf` let mut new_path = path.join("a").join("b"); // `push` extends the `PathBuf` with a `&Path` new_path.push("c"); new_path.push("myfile.tar.gz"); // `set_file_name` updates the file name of the `PathBuf` new_path.set_file_name("package.tgz"); // Convert the `PathBuf` into a string slice match new_path.to_str() { None => panic!("new path is not a valid UTF-8 sequence"), Some(s) => println!("new path is {}", s), } } ``` Be sure to check other `Path` methods and the `Metadata` struct. ### See also: [OsStr][1] and [Metadata][2]. [1]: https://doc.rust-lang.org/std/ffi/struct.OsStr.html [2]: https://doc.rust-lang.org/std/fs/struct.Metadata.html ================================================ FILE: src/std_misc/process/pipe.md ================================================ # Pipes The `std::process::Child` struct represents a child process, and exposes the `stdin`, `stdout` and `stderr` handles for interaction with the underlying process via pipes. ```rust,ignore use std::io::prelude::*; use std::process::{Command, Stdio}; static PANGRAM: &'static str = "the quick brown fox jumps over the lazy dog\n"; fn main() { // Spawn the `wc` command let mut cmd = if cfg!(target_family = "windows") { let mut cmd = Command::new("powershell"); cmd.arg("-Command").arg("$input | Measure-Object -Line -Word -Character"); cmd } else { Command::new("wc") }; let process = match cmd .stdin(Stdio::piped()) .stdout(Stdio::piped()) .spawn() { Err(why) => panic!("couldn't spawn wc: {}", why), Ok(process) => process, }; // Write a string to the `stdin` of `wc`. // // `stdin` has type `Option`, but since we know this instance // must have one, we can directly `unwrap` it. match process.stdin.unwrap().write_all(PANGRAM.as_bytes()) { Err(why) => panic!("couldn't write to wc stdin: {}", why), Ok(_) => println!("sent pangram to wc"), } // Because `stdin` does not live after the above calls, it is `drop`ed, // and the pipe is closed. // // This is very important, otherwise `wc` wouldn't start processing the // input we just sent. // The `stdout` field also has type `Option` so must be unwrapped. let mut s = String::new(); match process.stdout.unwrap().read_to_string(&mut s) { Err(why) => panic!("couldn't read wc stdout: {}", why), Ok(_) => print!("wc responded with:\n{}", s), } } ``` ================================================ FILE: src/std_misc/process/wait.md ================================================ # Wait If you'd like to wait for a `process::Child` to finish, you must call `Child::wait`, which will return a `process::ExitStatus`. ```rust,ignore use std::process::Command; fn main() { let mut child = Command::new("sleep").arg("5").spawn().unwrap(); let _result = child.wait().unwrap(); println!("reached end of main"); } ``` ```bash $ rustc wait.rs && ./wait # `wait` keeps running for 5 seconds until the `sleep 5` command finishes reached end of main ``` ================================================ FILE: src/std_misc/process.md ================================================ # Child processes The `process::Output` struct represents the output of a finished child process, and the `process::Command` struct is a process builder. ```rust,editable,ignore use std::process::Command; fn main() { let output = Command::new("rustc") .arg("--version") .output().unwrap_or_else(|e| { panic!("failed to execute process: {}", e) }); if output.status.success() { let s = String::from_utf8_lossy(&output.stdout); print!("rustc succeeded and stdout was:\n{}", s); } else { let s = String::from_utf8_lossy(&output.stderr); print!("rustc failed and stderr was:\n{}", s); } } ``` (You are encouraged to try the previous example with an incorrect flag passed to `rustc`) ================================================ FILE: src/std_misc/threads/testcase_mapreduce.md ================================================ # Testcase: map-reduce Rust makes it very easy to parallelize data processing, without many of the headaches traditionally associated with such an attempt. The standard library provides great threading primitives out of the box. These, combined with Rust's concept of Ownership and aliasing rules, automatically prevent data races. The aliasing rules (one writable reference XOR many readable references) automatically prevent you from manipulating state that is visible to other threads. (Where synchronization is needed, there are synchronization primitives like `Mutex`es or `Channel`s.) In this example, we will calculate the sum of all digits in a block of numbers. We will do this by parcelling out chunks of the block into different threads. Each thread will sum its tiny block of digits, and subsequently we will sum the intermediate sums produced by each thread. Note that, although we're passing references across thread boundaries, Rust understands that we're only passing read-only references, and that thus no unsafety or data races can occur. Also because the references we're passing have `'static` lifetimes, Rust understands that our data won't be destroyed while these threads are still running. (When you need to share non-`static` data between threads, you can use a smart pointer like `Arc` to keep the data alive and avoid non-`static` lifetimes.) ```rust,editable use std::thread; // This is the `main` thread fn main() { // This is our data to process. // We will calculate the sum of all digits via a threaded map-reduce algorithm. // Each whitespace separated chunk will be handled in a different thread. // // TODO: see what happens to the output if you insert spaces! let data = "86967897737416471853297327050364959 11861322575564723963297542624962850 70856234701860851907960690014725639 38397966707106094172783238747669219 52380795257888236525459303330302837 58495327135744041048897885734297812 69920216438980873548808413720956532 16278424637452589860345374828574668"; // Make a vector to hold the child-threads which we will spawn. let mut children = vec![]; /************************************************************************* * "Map" phase * * Divide our data into segments, and apply initial processing ************************************************************************/ // split our data into segments for individual calculation // each chunk will be a reference (&str) into the actual data let chunked_data = data.split_whitespace(); // Iterate over the data segments. // .enumerate() adds the current loop index to whatever is iterated // the resulting tuple "(index, element)" is then immediately // "destructured" into two variables, "i" and "data_segment" with a // "destructuring assignment" for (i, data_segment) in chunked_data.enumerate() { println!("data segment {} is \"{}\"", i, data_segment); // Process each data segment in a separate thread // // spawn() returns a handle to the new thread, // which we MUST keep to access the returned value // // 'move || -> u32' is syntax for a closure that: // * takes no arguments ('||') // * takes ownership of its captured variables ('move') and // * returns an unsigned 32-bit integer ('-> u32') // // Rust is smart enough to infer the '-> u32' from // the closure itself so we could have left that out. // // TODO: try removing the 'move' and see what happens children.push(thread::spawn(move || -> u32 { // Calculate the intermediate sum of this segment: let result = data_segment // iterate over the characters of our segment.. .chars() // .. convert text-characters to their number value.. .map(|c| c.to_digit(10).expect("should be a digit")) // .. and sum the resulting iterator of numbers .sum(); // println! locks stdout, so no text-interleaving occurs println!("processed segment {}, result={}", i, result); // "return" not needed, because Rust is an "expression language", the // last evaluated expression in each block is automatically its value. result })); } /************************************************************************* * "Reduce" phase * * Collect our intermediate results, and combine them into a final result ************************************************************************/ // combine each thread's intermediate results into a single final sum. // // we use the "turbofish" ::<> to provide sum() with a type hint. // // TODO: try without the turbofish, by instead explicitly // specifying the type of final_result let final_result = children.into_iter().map(|c| c.join().unwrap()).sum::(); println!("Final sum result: {}", final_result); } ``` ### Assignments It is not wise to let our number of threads depend on user inputted data. What if the user decides to insert a lot of spaces? Do we _really_ want to spawn 2,000 threads? Modify the program so that the data is always chunked into a limited number of chunks, defined by a static constant at the beginning of the program. ### See also: * [Threads][thread] * [vectors][vectors] and [iterators][iterators] * [closures][closures], [move][move] semantics and [`move` closures][move_closure] * [destructuring][destructuring] assignments * [turbofish notation][turbofish] to help type inference * [unwrap vs. expect][unwrap] * [enumerate][enumerate] [thread]: ../threads.md [vectors]: ../../std/vec.md [iterators]: ../../trait/iter.md [destructuring]: https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html#destructuring-to-break-apart-values [closures]: ../../fn/closures.md [move]: ../../scope/move.md [move_closure]: https://doc.rust-lang.org/book/ch13-01-closures.html#closures-can-capture-their-environment [turbofish]: https://doc.rust-lang.org/book/appendix-02-operators.html?highlight=turbofish [unwrap]: ../../error/option_unwrap.md [enumerate]: https://doc.rust-lang.org/book/loops.html#enumerate ================================================ FILE: src/std_misc/threads.md ================================================ # Threads Rust provides a mechanism for spawning native OS threads via the `spawn` function, the argument of this function is a moving closure. ```rust,editable use std::thread; const NTHREADS: u32 = 10; // This is the `main` thread fn main() { // Make a vector to hold the children which are spawned. let mut children = vec![]; for i in 0..NTHREADS { // Spin up another thread children.push(thread::spawn(move || { println!("this is thread number {}", i); })); } for child in children { // Wait for the thread to finish. Returns a result. let _ = child.join(); } } ``` These threads will be scheduled by the OS. ================================================ FILE: src/std_misc.md ================================================ # Std misc Many other types are provided by the std library to support things such as: * Threads * Channels * File I/O These expand beyond what the [primitives] provide. ### See also: [primitives] and [the std library][std] [primitives]: primitives.md [std]: https://doc.rust-lang.org/std/ ================================================ FILE: src/testing/dev_dependencies.md ================================================ # Development dependencies Sometimes there is a need to have dependencies for tests (or examples, or benchmarks) only. Such dependencies are added to `Cargo.toml` in the `[dev-dependencies]` section. These dependencies are not propagated to other packages which depend on this package. One such example is [`pretty_assertions`](https://docs.rs/pretty_assertions/1.0.0/pretty_assertions/index.html), which extends standard `assert_eq!` and `assert_ne!` macros, to provide colorful diff. File `Cargo.toml`: ```toml # standard crate data is left out [dev-dependencies] pretty_assertions = "1" ``` File `src/lib.rs`: ```rust,ignore pub fn add(a: i32, b: i32) -> i32 { a + b } #[cfg(test)] mod tests { use super::*; use pretty_assertions::assert_eq; // crate for test-only use. Cannot be used in non-test code. #[test] fn test_add() { assert_eq!(add(2, 3), 5); } } ``` ## See Also [Cargo][cargo] docs on specifying dependencies. [cargo]: http://doc.crates.io/specifying-dependencies.html ================================================ FILE: src/testing/doc_testing.md ================================================ # Documentation testing The primary way of documenting a Rust project is through annotating the source code. Documentation comments are written in [CommonMark Markdown specification][commonmark] and support code blocks in them. Rust takes care about correctness, so these code blocks are compiled and used as documentation tests. ```rust,ignore /// First line is a short summary describing function. /// /// The next lines present detailed documentation. Code blocks start with /// triple backquotes and have implicit `fn main()` inside /// and `extern crate `. Assume we're testing a `playground` library /// crate or using the Playground's Test action: /// /// ``` /// let result = playground::add(2, 3); /// assert_eq!(result, 5); /// ``` pub fn add(a: i32, b: i32) -> i32 { a + b } /// Usually doc comments may include sections "Examples", "Panics" and "Failures". /// /// The next function divides two numbers. /// /// # Examples /// /// ``` /// let result = playground::div(10, 2); /// assert_eq!(result, 5); /// ``` /// /// # Panics /// /// The function panics if the second argument is zero. /// /// ```rust,should_panic /// // panics on division by zero /// playground::div(10, 0); /// ``` pub fn div(a: i32, b: i32) -> i32 { if b == 0 { panic!("Divide-by-zero error"); } a / b } ``` Code blocks in documentation are automatically tested when running the regular `cargo test` command: ```shell $ cargo test running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests playground running 3 tests test src/lib.rs - add (line 7) ... ok test src/lib.rs - div (line 21) ... ok test src/lib.rs - div (line 31) ... ok test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` ## Motivation behind documentation tests The main purpose of documentation tests is to serve as examples that exercise the functionality, which is one of the most important [guidelines][question-instead-of-unwrap]. It allows using examples from docs as complete code snippets. But using `?` makes compilation fail since `main` returns `unit`. The ability to hide some source lines from documentation comes to the rescue: one may write `fn try_main() -> Result<(), ErrorType>`, hide it and `unwrap` it in hidden `main`. Sounds complicated? Here's an example: ```rust,ignore /// Using hidden `try_main` in doc tests. /// /// ``` /// # // hidden lines start with `#` symbol, but they're still compilable! /// # fn try_main() -> Result<(), String> { // line that wraps the body shown in doc /// let res = playground::try_div(10, 2)?; /// # Ok(()) // returning from try_main /// # } /// # fn main() { // starting main that'll unwrap() /// # try_main().unwrap(); // calling try_main and unwrapping /// # // so that test will panic in case of error /// # } /// ``` pub fn try_div(a: i32, b: i32) -> Result { if b == 0 { Err(String::from("Divide-by-zero")) } else { Ok(a / b) } } ``` ## See Also * [RFC505][RFC505] on documentation style * [API Guidelines][doc-nursery] on documentation guidelines [doc-nursery]: https://rust-lang-nursery.github.io/api-guidelines/documentation.html [commonmark]: https://commonmark.org/ [RFC505]: https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-conventions.md [question-instead-of-unwrap]: https://rust-lang-nursery.github.io/api-guidelines/documentation.html#examples-use--not-try-not-unwrap-c-question-mark ================================================ FILE: src/testing/integration_testing.md ================================================ # Integration testing [Unit tests][unit] are testing one module in isolation at a time: they're small and can test private code. Integration tests are external to your crate and use only its public interface in the same way any other code would. Their purpose is to test that many parts of your library work correctly together. Cargo looks for integration tests in `tests` directory next to `src`. File `src/lib.rs`: ```rust,ignore // Define this in a crate called `adder`. pub fn add(a: i32, b: i32) -> i32 { a + b } ``` File with test: `tests/integration_test.rs`: ```rust,ignore #[test] fn test_add() { assert_eq!(adder::add(3, 2), 5); } ``` Running tests with `cargo test` command: ```shell $ cargo test running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Running target/debug/deps/integration_test-bcd60824f5fbfe19 running 1 test test test_add ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests adder running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` Each Rust source file in the `tests` directory is compiled as a separate crate. In order to share some code between integration tests we can make a module with public functions, importing and using it within tests. File `tests/common/mod.rs`: ```rust,ignore pub fn setup() { // some setup code, like creating required files/directories, starting // servers, etc. } ``` File with test: `tests/integration_test.rs` ```rust,ignore // importing common module. mod common; #[test] fn test_add() { // using common code. common::setup(); assert_eq!(adder::add(3, 2), 5); } ``` Creating the module as `tests/common.rs` also works, but is not recommended because the test runner will treat the file as a test crate and try to run tests inside it. [unit]: unit_testing.md [mod]: ../mod.md ================================================ FILE: src/testing/unit_testing.md ================================================ # Unit testing Tests are Rust functions that verify that the non-test code is functioning in the expected manner. The bodies of test functions typically perform some setup, run the code we want to test, then assert whether the results are what we expect. Most unit tests go into a `tests` [mod][mod] with the `#[cfg(test)]` [attribute][attribute]. Test functions are marked with the `#[test]` attribute. Tests fail when something in the test function [panics][panic]. There are some helper [macros][macros]: * `assert!(expression)` - panics if expression evaluates to `false`. * `assert_eq!(left, right)` and `assert_ne!(left, right)` - testing left and right expressions for equality and inequality respectively. ```rust,ignore pub fn add(a: i32, b: i32) -> i32 { a + b } // This is a really bad adding function, its purpose is to fail in this // example. #[allow(dead_code)] fn bad_add(a: i32, b: i32) -> i32 { a - b } #[cfg(test)] mod tests { // Note this useful idiom: importing names from outer (for mod tests) scope. use super::*; #[test] fn test_add() { assert_eq!(add(1, 2), 3); } #[test] fn test_bad_add() { // This assert would fire and test will fail. // Please note, that private functions can be tested too! assert_eq!(bad_add(1, 2), 3); } } ``` Tests can be run with `cargo test`. ```shell $ cargo test running 2 tests test tests::test_bad_add ... FAILED test tests::test_add ... ok failures: ---- tests::test_bad_add stdout ---- thread 'tests::test_bad_add' panicked at 'assertion failed: `(left == right)` left: `-1`, right: `3`', src/lib.rs:21:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: tests::test_bad_add test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` ## Tests and `?` None of the previous unit test examples had a return type. But in Rust 2018, your unit tests can return `Result<()>`, which lets you use `?` in them! This can make them much more concise. ```rust,editable fn sqrt(number: f64) -> Result { if number >= 0.0 { Ok(number.powf(0.5)) } else { Err("negative floats don't have square roots".to_owned()) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_sqrt() -> Result<(), String> { let x = 4.0; assert_eq!(sqrt(x)?.powf(2.0), x); Ok(()) } } ``` See ["The Edition Guide"][editionguide] for more details. ## Testing panics To check functions that should panic under certain circumstances, use attribute `#[should_panic]`. This attribute accepts optional parameter `expected = ` with the text of the panic message. If your function can panic in multiple ways, it helps make sure your test is testing the correct panic. **Note**: Rust also allows a shorthand form `#[should_panic = "message"]`, which works exactly like `#[should_panic(expected = "message")]`. Both are valid; the latter is more commonly used and is considered more explicit. ```rust,ignore pub fn divide_non_zero_result(a: u32, b: u32) -> u32 { if b == 0 { panic!("Divide-by-zero error"); } else if a < b { panic!("Divide result is zero"); } a / b } #[cfg(test)] mod tests { use super::*; #[test] fn test_divide() { assert_eq!(divide_non_zero_result(10, 2), 5); } #[test] #[should_panic] fn test_any_panic() { divide_non_zero_result(1, 0); } #[test] #[should_panic(expected = "Divide result is zero")] fn test_specific_panic() { divide_non_zero_result(1, 10); } #[test] #[should_panic = "Divide result is zero"] // This also works fn test_specific_panic_shorthand() { divide_non_zero_result(1, 10); } } ``` Running these tests gives us: ```shell $ cargo test running 4 tests test tests::test_any_panic ... ok test tests::test_divide ... ok test tests::test_specific_panic ... ok test tests::test_specific_panic_shorthand ... ok test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests tmp-test-should-panic running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` ## Running specific tests To run specific tests one may specify the test name to `cargo test` command. ```shell $ cargo test test_any_panic running 1 test test tests::test_any_panic ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out Doc-tests tmp-test-should-panic running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` To run multiple tests one may specify part of a test name that matches all the tests that should be run. ```shell $ cargo test panic running 3 tests test tests::test_any_panic ... ok test tests::test_specific_panic ... ok test tests::test_specific_panic_shorthand ... ok test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out Doc-tests tmp-test-should-panic running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` ## Ignoring tests Tests can be marked with the `#[ignore]` attribute to exclude some tests. Or to run them with command `cargo test -- --ignored` ```rust,ignore pub fn add(a: i32, b: i32) -> i32 { a + b } #[cfg(test)] mod tests { use super::*; #[test] fn test_add() { assert_eq!(add(2, 2), 4); } #[test] fn test_add_hundred() { assert_eq!(add(100, 2), 102); assert_eq!(add(2, 100), 102); } #[test] #[ignore] fn ignored_test() { assert_eq!(add(0, 0), 0); } } ``` ```shell $ cargo test running 3 tests test tests::ignored_test ... ignored test tests::test_add ... ok test tests::test_add_hundred ... ok test result: ok. 2 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out Doc-tests tmp-ignore running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out $ cargo test -- --ignored running 1 test test tests::ignored_test ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests tmp-ignore running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` [attribute]: ../attribute.md [panic]: ../std/panic.md [macros]: ../macros.md [mod]: ../mod.md [editionguide]: https://doc.rust-lang.org/edition-guide/rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html ================================================ FILE: src/testing.md ================================================ # Testing Rust is a programming language that cares a lot about correctness and it includes support for writing software tests within the language itself. Testing comes in three styles: * [Unit][unit] testing. * [Doc][doc] testing. * [Integration][integration] testing. Also Rust has support for specifying additional dependencies for tests: * [Dev-dependencies][dev-dependencies] ## See Also * [The Book][doc-testing] chapter on testing * [API Guidelines][doc-nursery] on doc-testing [unit]: testing/unit_testing.md [doc]: testing/doc_testing.md [integration]: testing/integration_testing.md [dev-dependencies]: testing/dev_dependencies.md [doc-testing]: https://doc.rust-lang.org/book/ch11-00-testing.html [doc-nursery]: https://rust-lang-nursery.github.io/api-guidelines/documentation.html ================================================ FILE: src/trait/clone.md ================================================ # Clone and Copy When dealing with resources, the default behavior is to transfer them during assignments or function calls. However, sometimes we need to make a copy of the resource as well. The [`Clone`][clone] trait helps us do exactly this. Most commonly, we can use the `.clone()` method defined by the `Clone` trait. ## Copy: Implicit Cloning The [`Copy`][copy] trait allows a type to be duplicated simply by copying bits, with no additional logic required. When a type implements `Copy`, assignments and function calls will implicitly copy the value instead of moving it. **Important:** `Copy` requires `Clone` - any type that implements `Copy` must also implement `Clone`. This is because `Copy` is defined as a subtrait: `trait Copy: Clone {}`. The `Clone` implementation for `Copy` types simply copies the bits. Not all types can implement `Copy`. A type can only be `Copy` if: - All of its components are `Copy` - It doesn't manage external resources (like heap memory, file handles, etc.) ```rust,editable // A unit struct without resources // Note: Copy requires Clone, so we must derive both #[derive(Debug, Clone, Copy)] struct Unit; // A tuple struct with resources that implements the `Clone` trait // This CANNOT be Copy because Box is not Copy #[derive(Clone, Debug)] struct Pair(Box, Box); fn main() { // Instantiate `Unit` let unit = Unit; // Copy `Unit` - this is an implicit copy, not a move! // Because Unit implements Copy, the value is duplicated automatically let copied_unit = unit; // Both `Unit`s can be used independently println!("original: {:?}", unit); println!("copy: {:?}", copied_unit); // Instantiate `Pair` let pair = Pair(Box::new(1), Box::new(2)); println!("original: {:?}", pair); // Move `pair` into `moved_pair`, moves resources // Pair does not implement Copy, so this is a move let moved_pair = pair; println!("moved: {:?}", moved_pair); // Error! `pair` has lost its resources //println!("original: {:?}", pair); // TODO ^ Try uncommenting this line // Clone `moved_pair` into `cloned_pair` (resources are included) // Unlike Copy, Clone is explicit - we must call .clone() let cloned_pair = moved_pair.clone(); // Drop the moved original pair using std::mem::drop drop(moved_pair); // Error! `moved_pair` has been dropped //println!("moved and dropped: {:?}", moved_pair); // TODO ^ Try uncommenting this line // The result from .clone() can still be used! println!("clone: {:?}", cloned_pair); } ``` [clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html [copy]: https://doc.rust-lang.org/std/marker/trait.Copy.html ================================================ FILE: src/trait/derive.md ================================================ # Derive The compiler is capable of providing basic implementations for some traits via the `#[derive]` [attribute][attribute]. These traits can still be manually implemented if a more complex behavior is required. The following is a list of derivable traits: * Comparison traits: [`Eq`][eq], [`PartialEq`][partial-eq], [`Ord`][ord], [`PartialOrd`][partial-ord]. * [`Clone`][clone], to create `T` from `&T` via a copy. * [`Copy`][copy], to give a type 'copy semantics' instead of 'move semantics'. * [`Hash`][hash], to compute a hash from `&T`. * [`Default`][default], to create an empty instance of a data type. * [`Debug`][debug], to format a value using the `{:?}` formatter. ```rust,editable // `Centimeters`, a tuple struct that can be compared #[derive(PartialEq, PartialOrd)] struct Centimeters(f64); // `Inches`, a tuple struct that can be printed #[derive(Debug)] struct Inches(i32); impl Inches { fn to_centimeters(&self) -> Centimeters { let &Inches(inches) = self; Centimeters(inches as f64 * 2.54) } } // `Seconds`, a tuple struct with no additional attributes struct Seconds(i32); fn main() { let _one_second = Seconds(1); // Error: `Seconds` can't be printed; it doesn't implement the `Debug` trait //println!("One second looks like: {:?}", _one_second); // TODO ^ Try uncommenting this line // Error: `Seconds` can't be compared; it doesn't implement the `PartialEq` trait //let _this_is_true = (_one_second == _one_second); // TODO ^ Try uncommenting this line let foot = Inches(12); println!("One foot equals {:?}", foot); let meter = Centimeters(100.0); let cmp = if foot.to_centimeters() < meter { "smaller" } else { "bigger" }; println!("One foot is {} than one meter.", cmp); } ``` ### See also: [`derive`][derive] [attribute]: ../attribute.md [eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html [partial-eq]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html [ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html [partial-ord]: https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html [clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html [copy]: https://doc.rust-lang.org/core/marker/trait.Copy.html [hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html [default]: https://doc.rust-lang.org/std/default/trait.Default.html [debug]: https://doc.rust-lang.org/std/fmt/trait.Debug.html [derive]: https://doc.rust-lang.org/reference/attributes.html#derive ================================================ FILE: src/trait/disambiguating.md ================================================ # Disambiguating overlapping traits A type can implement many different traits. What if two traits both require the same name for a function? For example, many traits might have a method named `get()`. They might even have different return types! Good news: because each trait implementation gets its own `impl` block, it's clear which trait's `get` method you're implementing. What about when it comes time to _call_ those methods? To disambiguate between them, we have to use Fully Qualified Syntax. ```rust,editable trait UsernameWidget { // Get the selected username out of this widget fn get(&self) -> String; } trait AgeWidget { // Get the selected age out of this widget fn get(&self) -> u8; } // A form with both a UsernameWidget and an AgeWidget struct Form { username: String, age: u8, } impl UsernameWidget for Form { fn get(&self) -> String { self.username.clone() } } impl AgeWidget for Form { fn get(&self) -> u8 { self.age } } fn main() { let form = Form { username: "rustacean".to_owned(), age: 28, }; // If you uncomment this line, you'll get an error saying // "multiple `get` found". Because, after all, there are multiple methods // named `get`. // println!("{}", form.get()); let username =

::get(&form); assert_eq!("rustacean".to_owned(), username); let age = ::get(&form); assert_eq!(28, age); } ``` ### See also: [The Rust Programming Language chapter on Fully Qualified syntax][trpl_fqsyntax] [trpl_fqsyntax]: https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name ================================================ FILE: src/trait/drop.md ================================================ # Drop The [`Drop`][Drop] trait only has one method: `drop`, which is called automatically when an object goes out of scope. The main use of the `Drop` trait is to free the resources that the implementor instance owns. `Box`, `Vec`, `String`, `File`, and `Process` are some examples of types that implement the `Drop` trait to free resources. The `Drop` trait can also be manually implemented for any custom data type. The following example adds a print to console to the `drop` function to announce when it is called. ```rust,editable struct Droppable { name: &'static str, } // This trivial implementation of `drop` adds a print to console. impl Drop for Droppable { fn drop(&mut self) { println!("> Dropping {}", self.name); } } fn main() { let _a = Droppable { name: "a" }; // block A { let _b = Droppable { name: "b" }; // block B { let _c = Droppable { name: "c" }; let _d = Droppable { name: "d" }; println!("Exiting block B"); } println!("Just exited block B"); println!("Exiting block A"); } println!("Just exited block A"); // Variable can be manually dropped using the `drop` function drop(_a); // TODO ^ Try commenting this line println!("end of the main function"); // `_a` *won't* be `drop`ed again here, because it already has been // (manually) `drop`ed } ``` For a more practical example, here's how the `Drop` trait can be used to automatically clean up temporary files when they're no longer needed: ```rust,editable use std::fs::File; use std::path::PathBuf; struct TempFile { file: File, path: PathBuf, } impl TempFile { fn new(path: PathBuf) -> std::io::Result { // Note: File::create() will overwrite existing files let file = File::create(&path)?; Ok(Self { file, path }) } } // When TempFile is dropped: // 1. First, our drop implementation will remove the file's name from the filesystem. // 2. Then, File's drop will close the file, removing its underlying content from the disk. impl Drop for TempFile { fn drop(&mut self) { if let Err(e) = std::fs::remove_file(&self.path) { eprintln!("Failed to remove temporary file: {}", e); } println!("> Dropped temporary file: {:?}", self.path); // File's drop is implicitly called here because it is a field of this struct. } } fn main() -> std::io::Result<()> { // Create a new scope to demonstrate drop behavior { let temp = TempFile::new("test.txt".into())?; println!("Temporary file created"); // File will be automatically cleaned up when temp goes out of scope } println!("End of scope - file should be cleaned up"); // We can also manually drop if needed let temp2 = TempFile::new("another_test.txt".into())?; drop(temp2); // Explicitly drop the file println!("Manually dropped file"); Ok(()) } ``` [Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html ================================================ FILE: src/trait/dyn.md ================================================ # Returning Traits with `dyn` The Rust compiler needs to know how much space every function's return type requires. This means all your functions have to return a concrete type. Unlike other languages, if you have a trait like `Animal`, you can't write a function that returns `Animal`, because its different implementations will need different amounts of memory. However, there's an easy workaround. Instead of returning a trait object directly, our functions return a `Box` which _contains_ some `Animal`. A `box` is just a reference to some memory in the heap. Because a reference has a statically-known size, and the compiler can guarantee it points to a heap-allocated `Animal`, we can return a trait from our function! Rust tries to be as explicit as possible whenever it allocates memory on the heap. So if your function returns a pointer-to-trait-on-heap in this way, you need to write the return type with the `dyn` keyword, e.g. `Box`. ```rust,editable struct Sheep {} struct Cow {} trait Animal { // Instance method signature fn noise(&self) -> &'static str; } // Implement the `Animal` trait for `Sheep`. impl Animal for Sheep { fn noise(&self) -> &'static str { "baaaaah!" } } // Implement the `Animal` trait for `Cow`. impl Animal for Cow { fn noise(&self) -> &'static str { "moooooo!" } } // Returns some struct that implements Animal, but we don't know which one at compile time. fn random_animal(random_number: f64) -> Box { if random_number < 0.5 { Box::new(Sheep {}) } else { Box::new(Cow {}) } } fn main() { let random_number = 0.234; let animal = random_animal(random_number); println!("You've randomly chosen an animal, and it says {}", animal.noise()); } ``` ================================================ FILE: src/trait/impl_trait.md ================================================ # `impl Trait` `impl Trait` can be used in two locations: 1. as an argument type 2. as a return type ## As an argument type If your function is generic over a trait but you don't mind the specific type, you can simplify the function declaration using `impl Trait` as the type of the argument. For example, consider the following code: ```rust,editable fn parse_csv_document(src: R) -> std::io::Result>> { src.lines() .map(|line| { // For each line in the source line.map(|line| { // If the line was read successfully, process it, if not, return the error line.split(',') // Split the line separated by commas .map(|entry| String::from(entry.trim())) // Remove leading and trailing whitespace .collect() // Collect all strings in a row into a Vec }) }) .collect() // Collect all lines into a Vec> } ``` `parse_csv_document` is generic, allowing it to take any type which implements BufRead, such as `BufReader` or `[u8]`, but it's not important what type `R` is, and `R` is only used to declare the type of `src`, so the function can also be written as: ```rust,editable fn parse_csv_document(src: impl std::io::BufRead) -> std::io::Result>> { src.lines() .map(|line| { // For each line in the source line.map(|line| { // If the line was read successfully, process it, if not, return the error line.split(',') // Split the line separated by commas .map(|entry| String::from(entry.trim())) // Remove leading and trailing whitespace .collect() // Collect all strings in a row into a Vec }) }) .collect() // Collect all lines into a Vec> } ``` Note that using `impl Trait` as an argument type means that you cannot explicitly state what form of the function you use, i.e. `parse_csv_document::(std::io::empty())` will not work with the second example. ## As a return type If your function returns a type that implements `MyTrait`, you can write its return type as `-> impl MyTrait`. This can help simplify your type signatures quite a lot! ```rust,editable use std::iter; use std::vec::IntoIter; // This function combines two `Vec` and returns an iterator over it. // Look how complicated its return type is! fn combine_vecs_explicit_return_type( v: Vec, u: Vec, ) -> iter::Cycle, IntoIter>> { v.into_iter().chain(u.into_iter()).cycle() } // This is the exact same function, but its return type uses `impl Trait`. // Look how much simpler it is! fn combine_vecs( v: Vec, u: Vec, ) -> impl Iterator { v.into_iter().chain(u.into_iter()).cycle() } fn main() { let v1 = vec![1, 2, 3]; let v2 = vec![4, 5]; let mut v3 = combine_vecs(v1, v2); assert_eq!(Some(1), v3.next()); assert_eq!(Some(2), v3.next()); assert_eq!(Some(3), v3.next()); assert_eq!(Some(4), v3.next()); assert_eq!(Some(5), v3.next()); println!("all done"); } ``` More importantly, some Rust types can't be written out. For example, every closure has its own unnamed concrete type. Before `impl Trait` syntax, you had to allocate on the heap in order to return a closure. But now you can do it all statically, like this: ```rust,editable // Returns a function that adds `y` to its input fn make_adder_function(y: i32) -> impl Fn(i32) -> i32 { let closure = move |x: i32| { x + y }; closure } fn main() { let plus_one = make_adder_function(1); assert_eq!(plus_one(2), 3); } ``` You can also use `impl Trait` to return an iterator that uses `map` or `filter` closures! This makes using `map` and `filter` easier. Because closure types don't have names, you can't write out an explicit return type if your function returns iterators with closures. But with `impl Trait` you can do this easily: ```rust,editable fn double_positives<'a>(numbers: &'a Vec) -> impl Iterator + 'a { numbers .iter() .filter(|x| x > &&0) .map(|x| x * 2) } fn main() { let singles = vec![-3, -2, 2, 3]; let doubles = double_positives(&singles); assert_eq!(doubles.collect::>(), vec![4, 6]); } ``` ================================================ FILE: src/trait/iter.md ================================================ # Iterators The [`Iterator`][iter] trait is used to implement iterators over collections such as arrays. The trait requires only a method to be defined for the `next` element, which may be manually defined in an `impl` block or automatically defined (as in arrays and ranges). As a point of convenience for common situations, the `for` construct turns some collections into iterators using the [`.into_iter()`][intoiter] method. ```rust,editable struct Fibonacci { curr: u32, next: u32, } // Implement `Iterator` for `Fibonacci`. // The `Iterator` trait only requires a method to be defined for the `next` element, // and an `associated type` to declare the return type of the iterator. impl Iterator for Fibonacci { // We can refer to this type using Self::Item type Item = u32; // Here, we define the sequence using `.curr` and `.next`. // The return type is `Option`: // * When the `Iterator` is finished, `None` is returned. // * Otherwise, the next value is wrapped in `Some` and returned. // We use Self::Item in the return type, so we can change // the type without having to update the function signatures. fn next(&mut self) -> Option { let current = self.curr; self.curr = self.next; self.next = current + self.next; // Since there's no endpoint to a Fibonacci sequence, the `Iterator` // will never return `None`, and `Some` is always returned. Some(current) } } // Returns a Fibonacci sequence generator fn fibonacci() -> Fibonacci { Fibonacci { curr: 0, next: 1 } } fn main() { // `0..3` is an `Iterator` that generates: 0, 1, and 2. let mut sequence = 0..3; println!("Four consecutive `next` calls on 0..3"); println!("> {:?}", sequence.next()); println!("> {:?}", sequence.next()); println!("> {:?}", sequence.next()); println!("> {:?}", sequence.next()); // `for` works through an `Iterator` until it returns `None`. // Each `Some` value is unwrapped and bound to a variable (here, `i`). println!("Iterate through 0..3 using `for`"); for i in 0..3 { println!("> {}", i); } // The `take(n)` method reduces an `Iterator` to its first `n` terms. println!("The first four terms of the Fibonacci sequence are: "); for i in fibonacci().take(4) { println!("> {}", i); } // The `skip(n)` method shortens an `Iterator` by dropping its first `n` terms. println!("The next four terms of the Fibonacci sequence are: "); for i in fibonacci().skip(4).take(4) { println!("> {}", i); } let array = [1u32, 3, 3, 7]; // The `iter` method produces an `Iterator` over an array/slice. println!("Iterate the following array {:?}", &array); for i in array.iter() { println!("> {}", i); } } ``` [intoiter]: https://doc.rust-lang.org/std/iter/trait.IntoIterator.html [iter]: https://doc.rust-lang.org/core/iter/trait.Iterator.html ================================================ FILE: src/trait/ops.md ================================================ # Operator Overloading In Rust, many of the operators can be overloaded via traits. That is, some operators can be used to accomplish different tasks based on their input arguments. This is possible because operators are syntactic sugar for method calls. For example, the `+` operator in `a + b` calls the `add` method (as in `a.add(b)`). This `add` method is part of the `Add` trait. Hence, the `+` operator can be used by any implementor of the `Add` trait. A list of the traits, such as `Add`, that overload operators can be found in [`core::ops`][ops]. ```rust,editable use std::ops; struct Foo; struct Bar; #[derive(Debug)] struct FooBar; #[derive(Debug)] struct BarFoo; // The `std::ops::Add` trait is used to specify the functionality of `+`. // Here, we make `Add` - the trait for addition with a RHS of type `Bar`. // The following block implements the operation: Foo + Bar = FooBar impl ops::Add for Foo { type Output = FooBar; fn add(self, _rhs: Bar) -> FooBar { println!("> Foo.add(Bar) was called"); FooBar } } // By reversing the types, we end up implementing non-commutative addition. // Here, we make `Add` - the trait for addition with a RHS of type `Foo`. // This block implements the operation: Bar + Foo = BarFoo impl ops::Add for Bar { type Output = BarFoo; fn add(self, _rhs: Foo) -> BarFoo { println!("> Bar.add(Foo) was called"); BarFoo } } fn main() { println!("Foo + Bar = {:?}", Foo + Bar); println!("Bar + Foo = {:?}", Bar + Foo); } ``` ### See Also [Add][add], [Syntax Index][syntax] [add]: https://doc.rust-lang.org/core/ops/trait.Add.html [ops]: https://doc.rust-lang.org/core/ops/ [syntax]:https://doc.rust-lang.org/book/appendix-02-operators.html ================================================ FILE: src/trait/supertraits.md ================================================ # Supertraits Rust doesn't have "inheritance", but you can define a trait as being a superset of another trait. For example: ```rust,editable trait Person { fn name(&self) -> String; } // Person is a supertrait of Student. // Implementing Student requires you to also impl Person. trait Student: Person { fn university(&self) -> String; } trait Programmer { fn fav_language(&self) -> String; } // CompSciStudent (computer science student) is a subtrait of both Programmer // and Student. Implementing CompSciStudent requires you to impl both supertraits. trait CompSciStudent: Programmer + Student { fn git_username(&self) -> String; } fn comp_sci_student_greeting(student: &dyn CompSciStudent) -> String { format!( "My name is {} and I attend {}. My favorite language is {}. My Git username is {}", student.name(), student.university(), student.fav_language(), student.git_username() ) } struct CSStudent { name: String, university: String, fav_language: String, git_username: String } impl Programmer for CSStudent { fn fav_language(&self) -> String { self.fav_language.clone() } } impl Student for CSStudent { fn university(&self) -> String { self.university.clone() } } impl Person for CSStudent { fn name(&self) -> String { self.name.clone() } } impl CompSciStudent for CSStudent { fn git_username(&self) -> String { self.git_username.clone() } } fn main() { let student = CSStudent { name: String::from("Alice"), university: String::from("MIT"), fav_language: String::from("Rust"), git_username: String::from("alice_codes"), }; let greeting = comp_sci_student_greeting(&student); println!("{}", greeting); } ``` ### See also: [The Rust Programming Language chapter on supertraits][trpl_supertraits] [trpl_supertraits]: https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#using-supertraits-to-require-one-traits-functionality-within-another-trait ================================================ FILE: src/trait.md ================================================ # Traits A `trait` is a collection of methods defined for an unknown type: `Self`. They can access other methods declared in the same trait. Traits can be implemented for any data type. In the example below, we define `Animal`, a group of methods. The `Animal` `trait` is then implemented for the `Sheep` data type, allowing the use of methods from `Animal` with a `Sheep`. ```rust,editable struct Sheep { naked: bool, name: &'static str } trait Animal { // Associated function signature; `Self` refers to the implementor type. fn new(name: &'static str) -> Self; // Method signatures; these will return a string. fn name(&self) -> &'static str; fn noise(&self) -> &'static str; // Traits can provide default method definitions. fn talk(&self) { println!("{} says {}", self.name(), self.noise()); } } impl Sheep { fn is_naked(&self) -> bool { self.naked } fn shear(&mut self) { if self.is_naked() { // Implementor methods can use the implementor's trait methods. println!("{} is already naked...", self.name()); } else { println!("{} gets a haircut!", self.name); self.naked = true; } } } // Implement the `Animal` trait for `Sheep`. impl Animal for Sheep { // `Self` is the implementor type: `Sheep`. fn new(name: &'static str) -> Sheep { Sheep { name: name, naked: false } } fn name(&self) -> &'static str { self.name } fn noise(&self) -> &'static str { if self.is_naked() { "baaaaah?" } else { "baaaaah!" } } // Default trait methods can be overridden. fn talk(&self) { // For example, we can add some quiet contemplation. println!("{} pauses briefly... {}", self.name, self.noise()); } } fn main() { // Type annotation is necessary in this case. let mut dolly: Sheep = Animal::new("Dolly"); // TODO ^ Try removing the type annotations. dolly.talk(); dolly.shear(); dolly.talk(); } ``` ================================================ FILE: src/types/alias.md ================================================ # Aliasing The `type` statement can be used to give a new name to an existing type. Types must have `UpperCamelCase` names, or the compiler will raise a warning. The exception to this rule are the primitive types: `usize`, `f32`, etc. ```rust,editable // `NanoSecond`, `Inch`, and `U64` are new names for `u64`. type NanoSecond = u64; type Inch = u64; type U64 = u64; fn main() { // `NanoSecond` = `Inch` = `U64` = `u64`. let nanoseconds: NanoSecond = 5 as u64; let inches: Inch = 2 as U64; // Note that type aliases *don't* provide any extra type safety, because // aliases are *not* new types println!("{} nanoseconds + {} inches = {} unit?", nanoseconds, inches, nanoseconds + inches); } ``` The main use of aliases is to reduce boilerplate; for example the `io::Result` type is an alias for the `Result` type. ### See also: [Attributes](../attribute.md) ================================================ FILE: src/types/cast.md ================================================ # Casting Rust provides no implicit type conversion (coercion) between primitive types. But, explicit type conversion (casting) can be performed using the `as` keyword. Rules for converting between integral types follow C conventions generally, except in cases where C has undefined behavior. The behavior of all casts between integral types is well defined in Rust. ```rust,editable,ignore,mdbook-runnable // Suppress all errors from casts which overflow. #![allow(overflowing_literals)] fn main() { let decimal = 65.4321_f32; // Error! No implicit conversion let integer: u8 = decimal; // FIXME ^ Comment out this line // Explicit conversion let integer = decimal as u8; let character = integer as char; // Error! There are limitations in conversion rules. // A float cannot be directly converted to a char. let character = decimal as char; // FIXME ^ Comment out this line println!("Casting: {} -> {} -> {}", decimal, integer, character); // when casting any value to an unsigned type, T, // T::MAX + 1 is added or subtracted until the value // fits into the new type ONLY when the #![allow(overflowing_literals)] // lint is specified like above. Otherwise there will be a compiler error. // 1000 already fits in a u16 println!("1000 as a u16 is: {}", 1000 as u16); // 1000 - 256 - 256 - 256 = 232 // Under the hood, the first 8 least significant bits (LSB) are kept, // while the rest towards the most significant bit (MSB) get truncated. println!("1000 as a u8 is : {}", 1000 as u8); // -1 + 256 = 255 println!(" -1 as a u8 is : {}", (-1i8) as u8); // For positive numbers, this is the same as the modulus println!("1000 mod 256 is : {}", 1000 % 256); // When casting to a signed type, the (bitwise) result is the same as // first casting to the corresponding unsigned type. If the most significant // bit of that value is 1, then the value is negative. // Unless it already fits, of course. println!(" 128 as a i16 is: {}", 128 as i16); // In boundary case 128 value in 8-bit two's complement representation is -128 println!(" 128 as a i8 is : {}", 128 as i8); // repeating the example above // 1000 as u8 -> 232 println!("1000 as a u8 is : {}", 1000 as u8); // and the value of 232 in 8-bit two's complement representation is -24 println!(" 232 as a i8 is : {}", 232 as i8); // Since Rust 1.45, the `as` keyword performs a *saturating cast* // when casting from float to int. If the floating point value exceeds // the upper bound or is less than the lower bound, the returned value // will be equal to the bound crossed. // 300.0 as u8 is 255 println!(" 300.0 as u8 is : {}", 300.0_f32 as u8); // -100.0 as u8 is 0 println!("-100.0 as u8 is : {}", -100.0_f32 as u8); // nan as u8 is 0 println!(" nan as u8 is : {}", f32::NAN as u8); // This behavior incurs a small runtime cost and can be avoided // with unsafe methods, however the results might overflow and // return **unsound values**. Use these methods wisely: unsafe { // 300.0 as u8 is 44 println!(" 300.0 as u8 is : {}", 300.0_f32.to_int_unchecked::()); // -100.0 as u8 is 156 println!("-100.0 as u8 is : {}", (-100.0_f32).to_int_unchecked::()); // nan as u8 is 0 println!(" nan as u8 is : {}", f32::NAN.to_int_unchecked::()); } } ``` ================================================ FILE: src/types/inference.md ================================================ # Inference The type inference engine is pretty smart. It does more than looking at the type of the value expression during an initialization. It also looks at how the variable is used afterwards to infer its type. Here's an advanced example of type inference: ```rust,editable fn main() { // Because of the annotation, the compiler knows that `elem` has type u8. let elem = 5u8; // Create an empty vector (a growable array). let mut vec = Vec::new(); // At this point the compiler doesn't know the exact type of `vec`, it // just knows that it's a vector of something (`Vec<_>`). // Insert `elem` in the vector. vec.push(elem); // Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec`) // TODO ^ Try commenting out the `vec.push(elem)` line println!("{:?}", vec); } ``` No type annotation of variables was needed, the compiler is happy and so is the programmer! ================================================ FILE: src/types/literals.md ================================================ # Literals Numeric literals can be type annotated by adding the type as a suffix. As an example, to specify that the literal `42` should have the type `i32`, write `42i32`. The type of unsuffixed numeric literals will depend on how they are used. If no constraint exists, the compiler will use `i32` for integers, and `f64` for floating-point numbers. ```rust,editable fn main() { // Suffixed literals, their types are known at initialization let x = 1u8; let y = 2u32; let z = 3f32; // Unsuffixed literals, their types depend on how they are used let i = 1; let f = 1.0; // `size_of_val` returns the size of a variable in bytes println!("size of `x` in bytes: {}", std::mem::size_of_val(&x)); println!("size of `y` in bytes: {}", std::mem::size_of_val(&y)); println!("size of `z` in bytes: {}", std::mem::size_of_val(&z)); println!("size of `i` in bytes: {}", std::mem::size_of_val(&i)); println!("size of `f` in bytes: {}", std::mem::size_of_val(&f)); } ``` There are some concepts used in the previous code that haven't been explained yet, here's a brief explanation for the impatient readers: * `std::mem::size_of_val` is a function, but called with its *full path*. Code can be split in logical units called *modules*. In this case, the `size_of_val` function is defined in the `mem` module, and the `mem` module is defined in the `std` *crate*. For more details, see [modules][mod] and [crates][crate]. [mod]: ../mod.md [crate]: ../crates.md ================================================ FILE: src/types.md ================================================ # Types Rust provides several mechanisms to change or define the type of primitive and user defined types. The following sections cover: * [Casting] between primitive types * Specifying the desired type of [literals] * Using [type inference] * [Aliasing] types [Casting]: types/cast.md [literals]: types/literals.md [type inference]: types/inference.md [Aliasing]: types/alias.md ================================================ FILE: src/unsafe/asm.md ================================================ # Inline assembly Rust provides support for inline assembly via the `asm!` macro. It can be used to embed handwritten assembly in the assembly output generated by the compiler. Generally this should not be necessary, but might be where the required performance or timing cannot be otherwise achieved. Accessing low level hardware primitives, e.g. in kernel code, may also demand this functionality. > **Note**: the examples here are given in x86/x86-64 assembly, but other architectures are also supported. Inline assembly is currently supported on the following architectures: - x86 and x86-64 - ARM - AArch64 - RISC-V ## Basic usage Let us start with the simplest possible example: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; unsafe { asm!("nop"); } # } ``` This will insert a NOP (no operation) instruction into the assembly generated by the compiler. Note that all `asm!` invocations have to be inside an `unsafe` block, as they could insert arbitrary instructions and break various invariants. The instructions to be inserted are listed in the first argument of the `asm!` macro as a string literal. ## Inputs and outputs Now inserting an instruction that does nothing is rather boring. Let us do something that actually acts on data: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let x: u64; unsafe { asm!("mov {}, 5", out(reg) x); } assert_eq!(x, 5); # } ``` This will write the value `5` into the `u64` variable `x`. You can see that the string literal we use to specify instructions is actually a template string. It is governed by the same rules as Rust [format strings][format-syntax]. The arguments that are inserted into the template however look a bit different than you may be familiar with. First we need to specify if the variable is an input or an output of the inline assembly. In this case it is an output. We declared this by writing `out`. We also need to specify in what kind of register the assembly expects the variable. In this case we put it in an arbitrary general purpose register by specifying `reg`. The compiler will choose an appropriate register to insert into the template and will read the variable from there after the inline assembly finishes executing. [format-syntax]: https://doc.rust-lang.org/std/fmt/#syntax Let us see another example that also uses an input: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let i: u64 = 3; let o: u64; unsafe { asm!( "mov {0}, {1}", "add {0}, 5", out(reg) o, in(reg) i, ); } assert_eq!(o, 8); # } ``` This will add `5` to the input in variable `i` and write the result to variable `o`. The particular way this assembly does this is first copying the value from `i` to the output, and then adding `5` to it. The example shows a few things: First, we can see that `asm!` allows multiple template string arguments; each one is treated as a separate line of assembly code, as if they were all joined together with newlines between them. This makes it easy to format assembly code. Second, we can see that inputs are declared by writing `in` instead of `out`. Third, we can see that we can specify an argument number, or name as in any format string. For inline assembly templates this is particularly useful as arguments are often used more than once. For more complex inline assembly using this facility is generally recommended, as it improves readability, and allows reordering instructions without changing the argument order. We can further refine the above example to avoid the `mov` instruction: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let mut x: u64 = 3; unsafe { asm!("add {0}, 5", inout(reg) x); } assert_eq!(x, 8); # } ``` We can see that `inout` is used to specify an argument that is both input and output. This is different from specifying an input and output separately in that it is guaranteed to assign both to the same register. It is also possible to specify different variables for the input and output parts of an `inout` operand: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let x: u64 = 3; let y: u64; unsafe { asm!("add {0}, 5", inout(reg) x => y); } assert_eq!(y, 8); # } ``` ## Late output operands The Rust compiler is conservative with its allocation of operands. It is assumed that an `out` can be written at any time, and can therefore not share its location with any other argument. However, to guarantee optimal performance it is important to use as few registers as possible, so they won't have to be saved and reloaded around the inline assembly block. To achieve this Rust provides a `lateout` specifier. This can be used on any output that is written only after all inputs have been consumed. There is also an `inlateout` variant of this specifier. Here is an example where `inlateout` *cannot* be used in `release` mode or other optimized cases: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let mut a: u64 = 4; let b: u64 = 4; let c: u64 = 4; unsafe { asm!( "add {0}, {1}", "add {0}, {2}", inout(reg) a, in(reg) b, in(reg) c, ); } assert_eq!(a, 12); # } ``` In unoptimized cases (e.g. `Debug` mode), replacing `inout(reg) a` with `inlateout(reg) a` in the above example can continue to give the expected result. However, with `release` mode or other optimized cases, using `inlateout(reg) a` can instead lead to the final value `a = 16`, causing the assertion to fail. This is because in optimized cases, the compiler is free to allocate the same register for inputs `b` and `c` since it knows that they have the same value. Furthermore, when `inlateout` is used, `a` and `c` could be allocated to the same register, in which case the first `add` instruction would overwrite the initial load from variable `c`. This is in contrast to how using `inout(reg) a` ensures a separate register is allocated for `a`. However, the following example can use `inlateout` since the output is only modified after all input registers have been read: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let mut a: u64 = 4; let b: u64 = 4; unsafe { asm!("add {0}, {1}", inlateout(reg) a, in(reg) b); } assert_eq!(a, 8); # } ``` As you can see, this assembly fragment will still work correctly if `a` and `b` are assigned to the same register. ## Explicit register operands Some instructions require that the operands be in a specific register. Therefore, Rust inline assembly provides some more specific constraint specifiers. While `reg` is generally available on any architecture, explicit registers are highly architecture specific. E.g. for x86 the general purpose registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi` among others can be addressed by their name. ```rust,no_run # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let cmd = 0xd1; unsafe { asm!("out 0x64, eax", in("eax") cmd); } # } ``` In this example we call the `out` instruction to output the content of the `cmd` variable to port `0x64`. Since the `out` instruction only accepts `eax` (and its sub registers) as operand we had to use the `eax` constraint specifier. > **Note**: unlike other operand types, explicit register operands cannot be used in the template string: you can't use `{}` and should write the register name directly instead. Also, they must appear at the end of the operand list after all other operand types. Consider this example which uses the x86 `mul` instruction: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; fn mul(a: u64, b: u64) -> u128 { let lo: u64; let hi: u64; unsafe { asm!( // The x86 mul instruction takes rax as an implicit input and writes // the 128-bit result of the multiplication to rax:rdx. "mul {}", in(reg) a, inlateout("rax") b => lo, lateout("rdx") hi ); } ((hi as u128) << 64) + lo as u128 } # } ``` This uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit result. The only explicit operand is a register, that we fill from the variable `a`. The second operand is implicit, and must be the `rax` register, which we fill from the variable `b`. The lower 64 bits of the result are stored in `rax` from which we fill the variable `lo`. The higher 64 bits are stored in `rdx` from which we fill the variable `hi`. ## Clobbered registers In many cases inline assembly will modify state that is not needed as an output. Usually this is either because we have to use a scratch register in the assembly or because instructions modify state that we don't need to further examine. This state is generally referred to as being "clobbered". We need to tell the compiler about this since it may need to save and restore this state around the inline assembly block. ```rust use std::arch::asm; # #[cfg(target_arch = "x86_64")] fn main() { // three entries of four bytes each let mut name_buf = [0_u8; 12]; // String is stored as ascii in ebx, edx, ecx in order // Because ebx is reserved, the asm needs to preserve the value of it. // So we push and pop it around the main asm. // 64 bit mode on 64 bit processors does not allow pushing/popping of // 32 bit registers (like ebx), so we have to use the extended rbx register instead. unsafe { asm!( "push rbx", "cpuid", "mov [rdi], ebx", "mov [rdi + 4], edx", "mov [rdi + 8], ecx", "pop rbx", // We use a pointer to an array for storing the values to simplify // the Rust code at the cost of a couple more asm instructions // This is more explicit with how the asm works however, as opposed // to explicit register outputs such as `out("ecx") val` // The *pointer itself* is only an input even though it's written behind in("rdi") name_buf.as_mut_ptr(), // select cpuid 0, also specify eax as clobbered inout("eax") 0 => _, // cpuid clobbers these registers too out("ecx") _, out("edx") _, ); } let name = core::str::from_utf8(&name_buf).unwrap(); println!("CPU Manufacturer ID: {}", name); } # #[cfg(not(target_arch = "x86_64"))] # fn main() {} ``` In the example above we use the `cpuid` instruction to read the CPU manufacturer ID. This instruction writes to `eax` with the maximum supported `cpuid` argument and `ebx`, `edx`, and `ecx` with the CPU manufacturer ID as ASCII bytes in that order. Even though `eax` is never read we still need to tell the compiler that the register has been modified so that the compiler can save any values that were in these registers before the asm. This is done by declaring it as an output but with `_` instead of a variable name, which indicates that the output value is to be discarded. This code also works around the limitation that `ebx` is a reserved register by LLVM. That means that LLVM assumes that it has full control over the register and it must be restored to its original state before exiting the asm block, so it cannot be used as an input or output **except** if the compiler uses it to fulfill a general register class (e.g. `in(reg)`). This makes `reg` operands dangerous when using reserved registers as we could unknowingly corrupt our input or output because they share the same register. To work around this we use `rdi` to store the pointer to the output array, save `ebx` via `push`, read from `ebx` inside the asm block into the array and then restore `ebx` to its original state via `pop`. The `push` and `pop` use the full 64-bit `rbx` version of the register to ensure that the entire register is saved. On 32 bit targets the code would instead use `ebx` in the `push`/`pop`. This can also be used with a general register class to obtain a scratch register for use inside the asm code: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; // Multiply x by 6 using shifts and adds let mut x: u64 = 4; unsafe { asm!( "mov {tmp}, {x}", "shl {tmp}, 1", "shl {x}, 2", "add {x}, {tmp}", x = inout(reg) x, tmp = out(reg) _, ); } assert_eq!(x, 4 * 6); # } ``` ## Symbol operands and ABI clobbers By default, `asm!` assumes that any register not specified as an output will have its contents preserved by the assembly code. The [`clobber_abi`] argument to `asm!` tells the compiler to automatically insert the necessary clobber operands according to the given calling convention ABI: any register which is not fully preserved in that ABI will be treated as clobbered. Multiple `clobber_abi` arguments may be provided and all clobbers from all specified ABIs will be inserted. [`clobber_abi`]: https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-clobbers ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; extern "C" fn foo(arg: i32) -> i32 { println!("arg = {}", arg); arg * 2 } fn call_foo(arg: i32) -> i32 { unsafe { let result; asm!( "call {}", // Function pointer to call in(reg) foo, // 1st argument in rdi in("rdi") arg, // Return value in rax out("rax") result, // Mark all registers which are not preserved by the "C" calling // convention as clobbered. clobber_abi("C"), ); result } } # } ``` ## Register template modifiers In some cases, fine control is needed over the way a register name is formatted when inserted into the template string. This is needed when an architecture's assembly language has several names for the same register, each typically being a "view" over a subset of the register (e.g. the low 32 bits of a 64-bit register). By default the compiler will always choose the name that refers to the full register size (e.g. `rax` on x86-64, `eax` on x86, etc). This default can be overridden by using modifiers on the template string operands, just like you would with format strings: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let mut x: u16 = 0xab; unsafe { asm!("mov {0:h}, {0:l}", inout(reg_abcd) x); } assert_eq!(x, 0xabab); # } ``` In this example, we use the `reg_abcd` register class to restrict the register allocator to the 4 legacy x86 registers (`ax`, `bx`, `cx`, `dx`) of which the first two bytes can be addressed independently. Let us assume that the register allocator has chosen to allocate `x` in the `ax` register. The `h` modifier will emit the register name for the high byte of that register and the `l` modifier will emit the register name for the low byte. The asm code will therefore be expanded as `mov ah, al` which copies the low byte of the value into the high byte. If you use a smaller data type (e.g. `u16`) with an operand and forget to use template modifiers, the compiler will emit a warning and suggest the correct modifier to use. ## Memory address operands Sometimes assembly instructions require operands passed via memory addresses/memory locations. You have to manually use the memory address syntax specified by the target architecture. For example, on x86/x86_64 using Intel assembly syntax, you should wrap inputs/outputs in `[]` to indicate they are memory operands: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; fn load_fpu_control_word(control: u16) { unsafe { asm!("fldcw [{}]", in(reg) &control, options(nostack)); } } # } ``` ## Labels Any reuse of a named label, local or otherwise, can result in an assembler or linker error or may cause other strange behavior. Reuse of a named label can happen in a variety of ways including: - explicitly: using a label more than once in one `asm!` block, or multiple times across blocks. - implicitly via inlining: the compiler is allowed to instantiate multiple copies of an `asm!` block, for example when the function containing it is inlined in multiple places. - implicitly via LTO: LTO can cause code from *other crates* to be placed in the same codegen unit, and so could bring in arbitrary labels. As a consequence, you should only use GNU assembler **numeric** [local labels] inside inline assembly code. Defining symbols in assembly code may lead to assembler and/or linker errors due to duplicate symbol definitions. Moreover, on x86 when using the default Intel syntax, due to [an LLVM bug], you shouldn't use labels exclusively made of `0` and `1` digits, e.g. `0`, `11` or `101010`, as they may end up being interpreted as binary values. Using `options(att_syntax)` will avoid any ambiguity, but that affects the syntax of the *entire* `asm!` block. (See [Options](#options), below, for more on `options`.) ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let mut a = 0; unsafe { asm!( "mov {0}, 10", "2:", "sub {0}, 1", "cmp {0}, 3", "jle 2f", "jmp 2b", "2:", "add {0}, 2", out(reg) a ); } assert_eq!(a, 5); # } ``` This will decrement the `{0}` register value from 10 to 3, then add 2 and store it in `a`. This example shows a few things: - First, that the same number can be used as a label multiple times in the same inline block. - Second, that when a numeric label is used as a reference (as an instruction operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) should be added to the numeric label. It will then refer to the nearest label defined by this number in this direction. [local labels]: https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels [an LLVM bug]: https://bugs.llvm.org/show_bug.cgi?id=36144 ## Options {#options} By default, an inline assembly block is treated the same way as an external FFI function call with a custom calling convention: it may read/write memory, have observable side effects, etc. However, in many cases it is desirable to give the compiler more information about what the assembly code is actually doing so that it can optimize better. Let's take our previous example of an `add` instruction: ```rust # #[cfg(target_arch = "x86_64")] { use std::arch::asm; let mut a: u64 = 4; let b: u64 = 4; unsafe { asm!( "add {0}, {1}", inlateout(reg) a, in(reg) b, options(pure, nomem, nostack), ); } assert_eq!(a, 8); # } ``` Options can be provided as an optional final argument to the `asm!` macro. We specified three options here: - `pure` means that the asm code has no observable side effects and that its output depends only on its inputs. This allows the compiler optimizer to call the inline asm fewer times or even eliminate it entirely. - `nomem` means that the asm code does not read or write to memory. By default the compiler will assume that inline assembly can read or write any memory address that is accessible to it (e.g. through a pointer passed as an operand, or a global). - `nostack` means that the asm code does not push any data onto the stack. This allows the compiler to use optimizations such as the stack red zone on x86-64 to avoid stack pointer adjustments. These allow the compiler to better optimize code using `asm!`, for example by eliminating pure `asm!` blocks whose outputs are not needed. See the [reference](https://doc.rust-lang.org/stable/reference/inline-assembly.html) for the full list of available options and their effects. ================================================ FILE: src/unsafe.md ================================================ # Unsafe Operations As an introduction to this section, to borrow from [the official docs][unsafe], "one should try to minimize the amount of unsafe code in a code base." With that in mind, let's get started! Unsafe annotations in Rust are used to bypass protections put in place by the compiler; specifically, there are four primary things that unsafe is used for: * dereferencing raw pointers * calling functions or methods which are `unsafe` (including calling a function over FFI, see [a previous chapter](std_misc/ffi.md) of the book) * accessing or modifying static mutable variables * implementing unsafe traits ### Raw Pointers Raw pointers `*` and references `&T` function similarly, but references are always safe because they are guaranteed to point to valid data due to the borrow checker. Dereferencing a raw pointer can only be done through an unsafe block. ```rust,editable fn main() { let raw_p: *const u32 = &10; unsafe { assert!(*raw_p == 10); } } ``` ### Calling Unsafe Functions Some functions can be declared as `unsafe`, meaning it is the programmer's responsibility to ensure correctness instead of the compiler's. One example of this is [`std::slice::from_raw_parts`] which will create a slice given a pointer to the first element and a length. ```rust,editable use std::slice; fn main() { let some_vector = vec![1, 2, 3, 4]; let pointer = some_vector.as_ptr(); let length = some_vector.len(); unsafe { let my_slice: &[u32] = slice::from_raw_parts(pointer, length); assert_eq!(some_vector.as_slice(), my_slice); } } ``` For `slice::from_raw_parts`, one of the assumptions which *must* be upheld is that the pointer passed in points to valid memory and that the memory pointed to is of the correct type. If these invariants aren't upheld then the program's behaviour is undefined and there is no knowing what will happen. [unsafe]: https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html [`std::slice::from_raw_parts`]: https://doc.rust-lang.org/std/slice/fn.from_raw_parts.html ================================================ FILE: src/variable_bindings/declare.md ================================================ # Declare first It is possible to declare variable bindings first and initialize them later, but all variable bindings must be initialized before they are used: the compiler forbids use of uninitialized variable bindings, as it would lead to undefined behavior. It is not common to declare a variable binding and initialize it later in the function. It is more difficult for a reader to find the initialization when initialization is separated from declaration. It is common to declare and initialize a variable binding near where the variable will be used. ```rust,editable,ignore,mdbook-runnable fn main() { // Declare a variable binding let a_binding; { let x = 2; // Initialize the binding a_binding = x * x; } println!("a binding: {}", a_binding); let another_binding; // Error! Use of uninitialized binding println!("another binding: {}", another_binding); // FIXME ^ Comment out this line another_binding = 1; println!("another binding: {}", another_binding); } ``` ================================================ FILE: src/variable_bindings/freeze.md ================================================ # Freezing When data is bound by the same name immutably, it also *freezes*. *Frozen* data can't be modified until the immutable binding goes out of scope: ```rust,editable,ignore,mdbook-runnable fn main() { let mut _mutable_integer = 7i32; { // Shadowing by immutable `_mutable_integer` let _mutable_integer = _mutable_integer; // Error! `_mutable_integer` is frozen in this scope _mutable_integer = 50; // FIXME ^ Comment out this line // `_mutable_integer` goes out of scope } // Ok! `_mutable_integer` is not frozen in this scope _mutable_integer = 3; } ``` ================================================ FILE: src/variable_bindings/mut.md ================================================ # Mutability Variable bindings are immutable by default, but this can be overridden using the `mut` modifier. ```rust,editable,ignore,mdbook-runnable fn main() { let _immutable_binding = 1; let mut mutable_binding = 1; println!("Before mutation: {}", mutable_binding); // Ok mutable_binding += 1; println!("After mutation: {}", mutable_binding); // Error! Cannot assign a new value to an immutable variable _immutable_binding += 1; } ``` The compiler will throw a detailed diagnostic about mutability errors. ================================================ FILE: src/variable_bindings/scope.md ================================================ # Scope and Shadowing Variable bindings have a scope, and are constrained to live in a *block*. A block is a collection of statements enclosed by braces `{}`. ```rust,editable,ignore,mdbook-runnable fn main() { // This binding lives in the main function let long_lived_binding = 1; // This is a block, and has a smaller scope than the main function { // This binding only exists in this block let short_lived_binding = 2; println!("inner short: {}", short_lived_binding); } // End of the block // Error! `short_lived_binding` doesn't exist in this scope println!("outer short: {}", short_lived_binding); // FIXME ^ Comment out this line println!("outer long: {}", long_lived_binding); } ``` Also, [variable shadowing][variable-shadow] is allowed. ```rust,editable,ignore,mdbook-runnable fn main() { let shadowed_binding = 1; { println!("before being shadowed: {}", shadowed_binding); // This binding *shadows* the outer one let shadowed_binding = "abc"; println!("shadowed in inner block: {}", shadowed_binding); } println!("outside inner block: {}", shadowed_binding); // This binding *shadows* the previous binding let shadowed_binding = 2; println!("shadowed in outer block: {}", shadowed_binding); } ``` [variable-shadow]: https://en.wikipedia.org/wiki/Variable_shadowing ================================================ FILE: src/variable_bindings.md ================================================ # Variable Bindings Rust provides type safety via static typing. Variable bindings can be type annotated when declared. However, in most cases, the compiler will be able to infer the type of the variable from the context, heavily reducing the annotation burden. Values (like literals) can be bound to variables, using the `let` binding. ```rust,editable fn main() { let an_integer = 1u32; let a_boolean = true; let unit = (); // copy `an_integer` into `copied_integer` let copied_integer = an_integer; println!("An integer: {:?}", copied_integer); println!("A boolean: {:?}", a_boolean); println!("Meet the unit value: {:?}", unit); // The compiler warns about unused variable bindings; these warnings can // be silenced by prefixing the variable name with an underscore let _unused_variable = 3u32; let noisy_unused_variable = 2u32; // FIXME ^ Prefix with an underscore to suppress the warning // Please note that warnings may not be shown in a browser } ``` ================================================ FILE: theme/css/language-picker.css ================================================ #language-list { left: auto; right: 10px; } [dir="rtl"] #language-list { left: 10px; right: auto; } #language-list a { color: inherit; } ================================================ FILE: theme/head.hbs ================================================ ================================================ FILE: triagebot.toml ================================================ [assign] [assign.owners] "*" = ["@marioidival"]

(&mut self, predicate: P) -> Option where // `FnMut` meaning any captured variable may at most be // modified, not consumed. `&Self::Item` states it takes // arguments to the closure by reference. P: FnMut(&Self::Item) -> bool; } ``` ```rust,editable fn main() { let vec1 = vec![1, 2, 3]; let vec2 = vec![4, 5, 6]; // `vec1.iter()` yields `&i32`. let mut iter = vec1.iter(); // `vec2.into_iter()` yields `i32`. let mut into_iter = vec2.into_iter(); // `iter()` yields `&i32`, and `find` passes `&Item` to the predicate. // Since `Item = &i32`, the closure argument has type `&&i32`, // which we pattern-match to dereference down to `i32`. println!("Find 2 in vec1: {:?}", iter.find(|&&x| x == 2)); // `into_iter()` yields `i32`, and `find` passes `&Item` to the predicate. // Since `Item = i32`, the closure argument has type `&i32`, // which we pattern-match to dereference down to `i32`. println!("Find 2 in vec2: {:?}", into_iter.find(|&x| x == 2)); let array1 = [1, 2, 3]; let array2 = [4, 5, 6]; // `array1.iter()` yields `&i32` println!("Find 2 in array1: {:?}", array1.iter().find(|&&x| x == 2)); // `array2.into_iter()` yields `i32` println!("Find 2 in array2: {:?}", array2.into_iter().find(|&x| x == 2)); } ``` `Iterator::find` gives you a reference to the item. But if you want the _index_ of the item, use `Iterator::position`. ```rust,editable fn main() { let vec = vec![1, 9, 3, 3, 13, 2]; // `position` passes the iterator’s `Item` by value to the predicate. // `vec.iter()` yields `&i32`, so the predicate receives `&i32`, // which we pattern-match to dereference to `i32`. let index_of_first_even_number = vec.iter().position(|&x| x % 2 == 0); assert_eq!(index_of_first_even_number, Some(5)); // `vec.into_iter()` yields `i32`, so the predicate receives `i32` directly. let index_of_first_negative_number = vec.into_iter().position(|x| x < 0); assert_eq!(index_of_first_negative_number, None); } ``` ### See also: [`std::iter::Iterator::find`][find] [`std::iter::Iterator::find_map`][find_map] [`std::iter::Iterator::position`][position] [`std::iter::Iterator::rposition`][rposition] [find]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find [find_map]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find_map [position]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.position [rposition]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.rposition ================================================ FILE: src/fn/closures/closure_examples.md ================================================ # Examples in `std` This section contains a few examples of using closures from the `std` library. ================================================ FILE: src/fn/closures/input_functions.md ================================================ # Input functions Since closures may be used as arguments, you might wonder if the same can be said about functions. And indeed they can! If you declare a function that takes a closure as parameter, then any function that satisfies the trait bound of that closure can be passed as a parameter. ```rust,editable // Define a function which takes a generic `F` argument // bounded by `Fn`, and calls it fn call_me(f: F) { f(); } // Define a wrapper function satisfying the `Fn` bound fn function() { println!("I'm a function!"); } fn main() { // Define a closure satisfying the `Fn` bound let closure = || println!("I'm a closure!"); call_me(closure); call_me(function); } ``` As an additional note, the `Fn`, `FnMut`, and `FnOnce` `traits` dictate how a closure captures variables from the enclosing scope. ### See also: [`Fn`][fn], [`FnMut`][fn_mut], and [`FnOnce`][fn_once] [fn]: https://doc.rust-lang.org/std/ops/trait.Fn.html [fn_mut]: https://doc.rust-lang.org/std/ops/trait.FnMut.html [fn_once]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html ================================================ FILE: src/fn/closures/input_parameters.md ================================================ # As input parameters While Rust chooses how to capture variables on the fly mostly without type annotation, this ambiguity is not allowed when writing functions. When taking a closure as an input parameter, the closure's complete type must be annotated using one of a few `traits`, and they're determined by what the closure does with captured value. In order of decreasing restriction, they are: * `Fn`: the closure uses the captured value by reference (`&T`) * `FnMut`: the closure uses the captured value by mutable reference (`&mut T`) * `FnOnce`: the closure uses the captured value by value (`T`) On a variable-by-variable basis, the compiler will capture variables in the least restrictive manner possible. For instance, consider a parameter annotated as `FnOnce`. This specifies that the closure *may* capture by `&T`, `&mut T`, or `T`, but the compiler will ultimately choose based on how the captured variables are used in the closure. This is because if a move is possible, then any type of borrow should also be possible. Note that the reverse is not true. If the parameter is annotated as `Fn`, then capturing variables by `&mut T` or `T` are not allowed. However, `&T` is allowed. In the following example, try swapping the usage of `Fn`, `FnMut`, and `FnOnce` to see what happens: ```rust,editable // A function which takes a closure as an argument and calls it. // denotes that F is a "Generic type parameter" fn apply(f: F) where // The closure takes no input and returns nothing. F: FnOnce() { // ^ TODO: Try changing this to `Fn` or `FnMut`. f(); } // A function which takes a closure and returns an `i32`. fn apply_to_3(f: F) -> i32 where // The closure takes an `i32` and returns an `i32`. F: Fn(i32) -> i32 { f(3) } fn main() { use std::mem; let greeting = "hello"; // A non-copy type. // `to_owned` creates owned data from borrowed one let mut farewell = "goodbye".to_owned(); // Capture 2 variables: `greeting` by reference and // `farewell` by value. let diary = || { // `greeting` is by reference: requires `Fn`. println!("I said {}.", greeting); // Mutation forces `farewell` to be captured by // mutable reference. Now requires `FnMut`. farewell.push_str("!!!"); println!("Then I screamed {}.", farewell); println!("Now I can sleep. zzzzz"); // Manually calling drop forces `farewell` to // be captured by value. Now requires `FnOnce`. mem::drop(farewell); }; // Call the function which applies the closure. apply(diary); // `double` satisfies `apply_to_3`'s trait bound let double = |x| 2 * x; println!("3 doubled: {}", apply_to_3(double)); } ``` ### See also: [`std::mem::drop`][drop], [`Fn`][fn], [`FnMut`][fnmut], [Generics][generics], [where][where] and [`FnOnce`][fnonce] [drop]: https://doc.rust-lang.org/std/mem/fn.drop.html [fn]: https://doc.rust-lang.org/std/ops/trait.Fn.html [fnmut]: https://doc.rust-lang.org/std/ops/trait.FnMut.html [fnonce]: https://doc.rust-lang.org/std/ops/trait.FnOnce.html [generics]: ../../generics.md [where]: ../../generics/where.md ================================================ FILE: src/fn/closures/output_parameters.md ================================================ # As output parameters Closures as input parameters are possible, so returning closures as output parameters should also be possible. However, anonymous closure types are, by definition, unknown, so we have to use `impl Trait` to return them. The valid traits for returning a closure are: * `Fn` * `FnMut` * `FnOnce` Beyond this, the `move` keyword must be used, which signals that all captures occur by value. This is required because any captures by reference would be dropped as soon as the function exited, leaving invalid references in the closure. ```rust,editable fn create_fn() -> impl Fn() { let text = "Fn".to_owned(); move || println!("This is a: {}", text) } fn create_fnmut() -> impl FnMut() { let text = "FnMut".to_owned(); move || println!("This is a: {}", text) } fn create_fnonce() -> impl FnOnce() { let text = "FnOnce".to_owned(); move || println!("This is a: {}", text) } fn main() { let fn_plain = create_fn(); let mut fn_mut = create_fnmut(); let fn_once = create_fnonce(); fn_plain(); fn_mut(); fn_once(); } ``` ### See also: [`Fn`][fn], [`FnMut`][fnmut], [Generics][generics] and [impl Trait][impltrait]. [fn]: https://doc.rust-lang.org/std/ops/trait.Fn.html [fnmut]: https://doc.rust-lang.org/std/ops/trait.FnMut.html [generics]: ../../generics.md [impltrait]: ../../trait/impl_trait.md ================================================ FILE: src/fn/closures.md ================================================ # Closures Closures are functions that can capture the enclosing environment. For example, a closure that captures the `x` variable: ```Rust |val| val + x ``` The syntax and capabilities of closures make them very convenient for on the fly usage. Calling a closure is exactly like calling a function. However, both input and return types *can* be inferred and input variable names *must* be specified. Other characteristics of closures include: * using `||` instead of `()` around input variables. * optional body delimitation (`{}`) for a single line expression (mandatory otherwise). * the ability to capture the outer environment variables. ```rust,editable fn main() { let outer_var = 42; // A regular function can't refer to variables in the enclosing environment //fn function(i: i32) -> i32 { i + outer_var } // TODO: uncomment the line above and see the compiler error. The compiler // suggests that we define a closure instead. // Closures are anonymous, here we are binding them to references. // Annotation is identical to function annotation but is optional // as are the `{}` wrapping the body. These nameless functions // are assigned to appropriately named variables. let closure_annotated = |i: i32| -> i32 { i + outer_var }; let closure_inferred = |i | i + outer_var ; // Call the closures. println!("closure_annotated: {}", closure_annotated(1)); println!("closure_inferred: {}", closure_inferred(1)); // Once closure's type has been inferred, it cannot be inferred again with another type. //println!("cannot reuse closure_inferred with another type: {}", closure_inferred(42i64)); // TODO: uncomment the line above and see the compiler error. // A closure taking no arguments which returns an `i32`. // The return type is inferred. let one = || 1; println!("closure returning one: {}", one()); } ``` ================================================ FILE: src/fn/diverging.md ================================================ # Diverging functions Diverging functions never return. They are marked using `!`, which is an empty type. ```rust fn foo() -> ! { panic!("This call never returns."); } ``` As opposed to all the other types, this one cannot be instantiated, because the set of all possible values this type can have is empty. Note that, it is different from the `()` type, which has exactly one possible value. For example, this function returns as usual, although there is no information in the return value. ```rust fn some_fn() { () } fn main() { let _a: () = some_fn(); println!("This function returns and you can see this line."); } ``` As opposed to this function, which will never return the control back to the caller. ```rust,ignore #![feature(never_type)] fn main() { let x: ! = panic!("This call never returns."); println!("You will never see this line!"); } ``` Although this might seem like an abstract concept, it is actually very useful and often handy. The main advantage of this type is that it can be cast to any other type, making it versatile in situations where an exact type is required, such as in match branches. This flexibility allows us to write code like this: ```rust fn main() { fn sum_odd_numbers(up_to: u32) -> u32 { let mut acc = 0; for i in 0..up_to { // Notice that the return type of this match expression must be u32 // because of the type of the "addition" variable. let addition: u32 = match i%2 == 1 { // The "i" variable is of type u32, which is perfectly fine. true => i, // On the other hand, the "continue" expression does not return // u32, but it is still fine, because it never returns and therefore // does not violate the type requirements of the match expression. false => continue, }; acc += addition; } acc } println!("Sum of odd numbers up to 9 (excluding): {}", sum_odd_numbers(9)); } ``` It is also the return type of functions that loop forever (e.g. `loop {}`) like network servers or functions that terminate the process (e.g. `exit()`). ================================================ FILE: src/fn/hof.md ================================================ # Higher Order Functions Rust provides Higher Order Functions (HOF). These are functions that take one or more functions and/or produce a more useful function. HOFs and lazy iterators give Rust its functional flavor. ```rust,editable fn is_odd(n: u32) -> bool { n % 2 == 1 } fn main() { println!("Find the sum of all the numbers with odd squares under 1000"); let upper = 1000; // Imperative approach // Declare accumulator variable let mut acc = 0; // Iterate: 0, 1, 2, ... to infinity for n in 0.. { // Square the number let n_squared = n * n; if n_squared >= upper { // Break loop if exceeded the upper limit break; } else if is_odd(n_squared) { // Accumulate value, if it's odd acc += n; } } println!("imperative style: {}", acc); // Functional approach let sum: u32 = (0..).take_while(|&n| n * n < upper) // Below upper limit .filter(|&n| is_odd(n * n)) // That are odd .sum(); // Sum them println!("functional style: {}", sum); } ``` [Option][option] and [Iterator][iter] implement their fair share of HOFs. [option]: https://doc.rust-lang.org/core/option/enum.Option.html [iter]: https://doc.rust-lang.org/core/iter/trait.Iterator.html ================================================ FILE: src/fn/methods.md ================================================ # Associated functions & Methods Some functions are connected to a particular type. These come in two forms: associated functions, and methods. Associated functions are functions that are defined on a type generally, while methods are associated functions that are called on a particular instance of a type. ```rust,editable struct Point { x: f64, y: f64, } // Implementation block, all `Point` associated functions & methods go in here impl Point { // This is an "associated function" because this function is associated with // a particular type, that is, Point. // // Associated functions don't need to be called with an instance. // These functions are generally used like constructors. fn origin() -> Point { Point { x: 0.0, y: 0.0 } } // Another associated function, taking two arguments: fn new(x: f64, y: f64) -> Point { Point { x: x, y: y } } } struct Rectangle { p1: Point, p2: Point, } impl Rectangle { // This is a method // `&self` is sugar for `self: &Self`, where `Self` is the type of the // caller object. In this case `Self` = `Rectangle` fn area(&self) -> f64 { // `self` gives access to the struct fields via the dot operator let Point { x: x1, y: y1 } = self.p1; let Point { x: x2, y: y2 } = self.p2; // `abs` is a `f64` method that returns the absolute value of the // caller ((x1 - x2) * (y1 - y2)).abs() } fn perimeter(&self) -> f64 { let Point { x: x1, y: y1 } = self.p1; let Point { x: x2, y: y2 } = self.p2; 2.0 * ((x1 - x2).abs() + (y1 - y2).abs()) } // This method requires the caller object to be mutable // `&mut self` desugars to `self: &mut Self` fn translate(&mut self, x: f64, y: f64) { self.p1.x += x; self.p2.x += x; self.p1.y += y; self.p2.y += y; } } // `Pair` owns resources: two heap allocated integers struct Pair(Box, Box); impl Pair { // This method "consumes" the resources of the caller object // `self` desugars to `self: Self` fn destroy(self) { // Destructure `self` let Pair(first, second) = self; println!("Destroying Pair({}, {})", first, second); // `first` and `second` go out of scope and get freed } } fn main() { let rectangle = Rectangle { // Associated functions are called using double colons p1: Point::origin(), p2: Point::new(3.0, 4.0), }; // Methods are called using the dot operator // Note that the first argument `&self` is implicitly passed, i.e. // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)` println!("Rectangle perimeter: {}", rectangle.perimeter()); println!("Rectangle area: {}", rectangle.area()); let mut square = Rectangle { p1: Point::origin(), p2: Point::new(1.0, 1.0), }; // Error! `rectangle` is immutable, but this method requires a mutable // object //rectangle.translate(1.0, 0.0); // TODO ^ Try uncommenting this line // Okay! Mutable objects can call mutable methods square.translate(1.0, 1.0); let pair = Pair(Box::new(1), Box::new(2)); pair.destroy(); // Error! Previous `destroy` call "consumed" `pair` //pair.destroy(); // TODO ^ Try uncommenting this line } ``` ================================================ FILE: src/fn.md ================================================ # Functions Functions are declared using the `fn` keyword. Its arguments are type annotated, just like variables, and, if the function returns a value, the return type must be specified after an arrow `->`. The final expression in the function will be used as return value. Alternatively, the `return` statement can be used to return a value earlier from within the function, even from inside loops or `if` statements. Let's rewrite FizzBuzz using functions! ```rust,editable // Unlike C/C++, there's no restriction on the order of function definitions fn main() { // We can use this function here, and define it somewhere later fizzbuzz_to(100); } // Function that returns a boolean value fn is_divisible_by(lhs: u32, rhs: u32) -> bool { // Corner case, early return if rhs == 0 { return false; } // This is an expression, the `return` keyword is not necessary here lhs % rhs == 0 } // Functions that "don't" return a value, actually return the unit type `()` fn fizzbuzz(n: u32) -> () { if is_divisible_by(n, 15) { println!("fizzbuzz"); } else if is_divisible_by(n, 3) { println!("fizz"); } else if is_divisible_by(n, 5) { println!("buzz"); } else { println!("{}", n); } } // When a function returns `()`, the return type can be omitted from the // signature fn fizzbuzz_to(n: u32) { for n in 1..=n { fizzbuzz(n); } } ``` ================================================ FILE: src/generics/assoc_items/the_problem.md ================================================ # The Problem A `trait` that is generic over its container type has type specification requirements - users of the `trait` *must* specify all of its generic types. In the example below, the `Contains` `trait` allows the use of the generic types `A` and `B`. The trait is then implemented for the `Container` type, specifying `i32` for `A` and `B` so that it can be used with `fn difference()`. Because `Contains` is generic, we are forced to explicitly state *all* of the generic types for `fn difference()`. In practice, we want a way to express that `A` and `B` are determined by the *input* `C`. As you will see in the next section, associated types provide exactly that capability. ```rust,editable struct Container(i32, i32); // A trait which checks if 2 items are stored inside of container. // Also retrieves first or last value. trait Contains { fn contains(&self, _: &A, _: &B) -> bool; // Explicitly requires `A` and `B`. fn first(&self) -> i32; // Doesn't explicitly require `A` or `B`. fn last(&self) -> i32; // Doesn't explicitly require `A` or `B`. } impl Contains for Container { // True if the numbers stored are equal. fn contains(&self, number_1: &i32, number_2: &i32) -> bool { (&self.0 == number_1) && (&self.1 == number_2) } // Grab the first number. fn first(&self) -> i32 { self.0 } // Grab the last number. fn last(&self) -> i32 { self.1 } } // `C` contains `A` and `B`. In light of that, having to express `A` and // `B` again is a nuisance. fn difference(container: &C) -> i32 where C: Contains { container.last() - container.first() } fn main() { let number_1 = 3; let number_2 = 10; let container = Container(number_1, number_2); println!("Does container contain {} and {}: {}", &number_1, &number_2, container.contains(&number_1, &number_2)); println!("First number: {}", container.first()); println!("Last number: {}", container.last()); println!("The difference is: {}", difference(&container)); } ``` ### See also: [`struct`s][structs], and [`trait`s][traits] [structs]: ../../custom_types/structs.md [traits]: ../../trait.md ================================================ FILE: src/generics/assoc_items/types.md ================================================ # Associated types The use of "Associated types" improves the overall readability of code by moving inner types locally into a trait as *output* types. Syntax for the `trait` definition is as follows: ```rust // `A` and `B` are defined in the trait via the `type` keyword. // (Note: `type` in this context is different from `type` when used for // aliases). trait Contains { type A; type B; // Updated syntax to refer to these new types generically. fn contains(&self, _: &Self::A, _: &Self::B) -> bool; } ``` Note that functions that use the `trait` `Contains` are no longer required to express `A` or `B` at all: ```rust,ignore // Without using associated types fn difference(container: &C) -> i32 where C: Contains { ... } // Using associated types fn difference(container: &C) -> i32 { ... } ``` Let's rewrite the example from the previous section using associated types: ```rust,editable struct Container(i32, i32); // A trait which checks if 2 items are stored inside of container. // Also retrieves first or last value. trait Contains { // Define generic types here which methods will be able to utilize. type A; type B; fn contains(&self, _: &Self::A, _: &Self::B) -> bool; fn first(&self) -> i32; fn last(&self) -> i32; } impl Contains for Container { // Specify what types `A` and `B` are. If the `input` type // is `Container(i32, i32)`, the `output` types are determined // as `i32` and `i32`. type A = i32; type B = i32; // `&Self::A` and `&Self::B` are also valid here. fn contains(&self, number_1: &i32, number_2: &i32) -> bool { (&self.0 == number_1) && (&self.1 == number_2) } // Grab the first number. fn first(&self) -> i32 { self.0 } // Grab the last number. fn last(&self) -> i32 { self.1 } } fn difference(container: &C) -> i32 { container.last() - container.first() } fn main() { let number_1 = 3; let number_2 = 10; let container = Container(number_1, number_2); println!("Does container contain {} and {}: {}", &number_1, &number_2, container.contains(&number_1, &number_2)); println!("First number: {}", container.first()); println!("Last number: {}", container.last()); println!("The difference is: {}", difference(&container)); } ``` ================================================ FILE: src/generics/assoc_items.md ================================================ # Associated items "Associated Items" refers to a set of rules pertaining to [`item`][items]s of various types. It is an extension to `trait` generics, and allows `trait`s to internally define new items. One such item is called an *associated type*, providing simpler usage patterns when the `trait` is generic over its container type. ### See also: [RFC][RFC] [items]: https://doc.rust-lang.org/reference/items.html [RFC]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md ================================================ FILE: src/generics/bounds/testcase_empty.md ================================================ # Testcase: empty bounds A consequence of how bounds work is that even if a `trait` doesn't include any functionality, you can still use it as a bound. `Eq` and `Copy` are examples of such `trait`s from the `std` library. ```rust,editable struct Cardinal; struct BlueJay; struct Turkey; trait Red {} trait Blue {} impl Red for Cardinal {} impl Blue for BlueJay {} // These functions are only valid for types which implement these // traits. The fact that the traits are empty is irrelevant. fn red(_: &T) -> &'static str { "red" } fn blue(_: &T) -> &'static str { "blue" } fn main() { let cardinal = Cardinal; let blue_jay = BlueJay; let _turkey = Turkey; // `red()` won't work on a blue jay nor vice versa // because of the bounds. println!("A cardinal is {}", red(&cardinal)); println!("A blue jay is {}", blue(&blue_jay)); //println!("A turkey is {}", red(&_turkey)); // ^ TODO: Try uncommenting this line. } ``` ### See also: [`std::cmp::Eq`][eq], [`std::marker::Copy`][copy], and [`trait`s][traits] [eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html [copy]: https://doc.rust-lang.org/std/marker/trait.Copy.html [traits]: ../../trait.md ================================================ FILE: src/generics/bounds.md ================================================ # Bounds When working with generics, the type parameters often must use traits as *bounds* to stipulate what functionality a type implements. For example, the following example uses the trait `Display` to print and so it requires `T` to be bound by `Display`; that is, `T` *must* implement `Display`. ```rust,ignore // Define a function `printer` that takes a generic type `T` which // must implement trait `Display`. fn printer(t: T) { println!("{}", t); } ``` Bounding restricts the generic to types that conform to the bounds. That is: ```rust,ignore struct S(T); // Error! `Vec` does not implement `Display`. This // specialization will fail. let s = S(vec![1]); ``` Another effect of bounding is that generic instances are allowed to access the [methods] of traits specified in the bounds. For example: ```rust,editable // A trait which implements the print marker: `{:?}`. use std::fmt::Debug; trait HasArea { fn area(&self) -> f64; } impl HasArea for Rectangle { fn area(&self) -> f64 { self.length * self.height } } #[derive(Debug)] struct Rectangle { length: f64, height: f64 } #[allow(dead_code)] struct Triangle { length: f64, height: f64 } // The generic `T` must implement `Debug`. Regardless // of the type, this will work properly. fn print_debug(t: &T) { println!("{:?}", t); } // `T` must implement `HasArea`. Any type which meets // the bound can access `HasArea`'s function `area`. fn area(t: &T) -> f64 { t.area() } fn main() { let rectangle = Rectangle { length: 3.0, height: 4.0 }; let _triangle = Triangle { length: 3.0, height: 4.0 }; print_debug(&rectangle); println!("Area: {}", area(&rectangle)); //print_debug(&_triangle); //println!("Area: {}", area(&_triangle)); // ^ TODO: Try uncommenting these. // | Error: Does not implement either `Debug` or `HasArea`. } ``` As an additional note, [`where`][where] clauses can also be used to apply bounds in some cases to be more expressive. ### See also: [`std::fmt`][fmt], [`struct`s][structs], and [`trait`s][traits] [fmt]: ../hello/print.md [methods]: ../fn/methods.md [structs]: ../custom_types/structs.md [traits]: ../trait.md [where]: ../generics/where.md ================================================ FILE: src/generics/gen_fn.md ================================================ # Functions The same set of rules can be applied to functions: a type `T` becomes generic when preceded by ``. Using generic functions sometimes requires explicitly specifying type parameters. This may be the case if the function is called where the return type is generic, or if the compiler doesn't have enough information to infer the necessary type parameters. A function call with explicitly specified type parameters looks like: `fun::()`. ```rust,editable struct A; // Concrete type `A`. struct S(A); // Concrete type `S`. struct SGen(T); // Generic type `SGen`. // The following functions all take ownership of the variable passed into // them and immediately go out of scope, freeing the variable. // Define a function `reg_fn` that takes an argument `_s` of type `S`. // This has no `` so this is not a generic function. fn reg_fn(_s: S) {} // Define a function `gen_spec_t` that takes an argument `_s` of type `SGen`. // It has been explicitly given the type parameter `A`, but because `A` has not // been specified as a generic type parameter for `gen_spec_t`, it is not generic. fn gen_spec_t(_s: SGen) {} // Define a function `gen_spec_i32` that takes an argument `_s` of type `SGen`. // It has been explicitly given the type parameter `i32`, which is a specific type. // Because `i32` is not a generic type, this function is also not generic. fn gen_spec_i32(_s: SGen) {} // Define a function `generic` that takes an argument `_s` of type `SGen`. // Because `SGen` is preceded by ``, this function is generic over `T`. fn generic(_s: SGen) {} fn main() { // Using the non-generic functions reg_fn(S(A)); // Concrete type. gen_spec_t(SGen(A)); // Implicitly specified type parameter `A`. gen_spec_i32(SGen(6)); // Implicitly specified type parameter `i32`. // Explicitly specified type parameter `char` to `generic()`. generic::(SGen('a')); // Implicitly specified type parameter `char` to `generic()`. generic(SGen('c')); } ``` ### See also: [functions][fn] and [`struct`s][structs] [fn]: ../fn.md [structs]: ../custom_types/structs.md ================================================ FILE: src/generics/gen_trait.md ================================================ # Traits Of course `trait`s can also be generic. Here we define one which reimplements the `Drop` `trait` as a generic method to `drop` itself and an input. ```rust,editable // Non-copyable types. struct Empty; struct Null; // A trait generic over `T`. trait DoubleDrop { // Define a method on the caller type which takes an // additional single parameter `T` and does nothing with it. fn double_drop(self, _: T); } // Implement `DoubleDrop` for any generic parameter `T` and // caller `U`. impl DoubleDrop for U { // This method takes ownership of both passed arguments, // deallocating both. fn double_drop(self, _: T) {} } fn main() { let empty = Empty; let null = Null; // Deallocate `empty` and `null`. empty.double_drop(null); //empty; //null; // ^ TODO: Try uncommenting these lines. } ``` ### See also: [`Drop`][Drop], [`struct`][structs], and [`trait`][traits] [Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html [structs]: ../custom_types/structs.md [traits]: ../trait.md ================================================ FILE: src/generics/impl.md ================================================ # Implementation Similar to functions, implementations require care to remain generic. ```rust struct S; // Concrete type `S` struct GenericVal(T); // Generic type `GenericVal` // impl of GenericVal where we explicitly specify type parameters: impl GenericVal {} // Specify `f32` impl GenericVal {} // Specify `S` as defined above // `` Must precede the type to remain generic impl GenericVal {} ``` ```rust,editable struct Val { val: f64, } struct GenVal { gen_val: T, } // impl of Val impl Val { fn value(&self) -> &f64 { &self.val } } // impl of GenVal for a generic type `T` impl GenVal { fn value(&self) -> &T { &self.gen_val } } fn main() { let x = Val { val: 3.0 }; let y = GenVal { gen_val: 3i32 }; println!("{}, {}", x.value(), y.value()); } ``` ### See also: [functions returning references][fn], [`impl`][methods], and [`struct`][structs] [fn]: ../scope/lifetime/fn.md [methods]: ../fn/methods.md [specialization_plans]: https://blog.rust-lang.org/2015/05/11/traits.html#the-future [structs]: ../custom_types/structs.md ================================================ FILE: src/generics/multi_bounds.md ================================================ # Multiple bounds Multiple bounds for a single type can be applied with a `+`. Like normal, different types are separated with `,`. ```rust,editable use std::fmt::{Debug, Display}; fn compare_prints(t: &T) { println!("Debug: `{:?}`", t); println!("Display: `{}`", t); } fn compare_types(t: &T, u: &U) { println!("t: `{:?}`", t); println!("u: `{:?}`", u); } fn main() { let string = "words"; let array = [1, 2, 3]; let vec = vec![1, 2, 3]; compare_prints(&string); //compare_prints(&array); // TODO ^ Try uncommenting this. compare_types(&array, &vec); } ``` ### See also: [`std::fmt`][fmt] and [`trait`s][traits] [fmt]: ../hello/print.md [traits]: ../trait.md ================================================ FILE: src/generics/new_types.md ================================================ # New Type Idiom The `newtype` idiom gives compile time guarantees that the right type of value is supplied to a program. For example, an age verification function that checks age in years, *must* be given a value of type `Years`. ```rust, editable struct Years(i64); struct Days(i64); impl Years { pub fn to_days(&self) -> Days { Days(self.0 * 365) } } impl Days { /// truncates partial years pub fn to_years(&self) -> Years { Years(self.0 / 365) } } fn is_adult(age: &Years) -> bool { age.0 >= 18 } fn main() { let age = Years(25); let age_days = age.to_days(); println!("Is an adult? {}", is_adult(&age)); println!("Is an adult? {}", is_adult(&age_days.to_years())); // println!("Is an adult? {}", is_adult(&age_days)); } ``` Uncomment the last print statement to observe that the type supplied must be `Years`. To obtain the `newtype`'s value as the base type, you may use the tuple or destructuring syntax like so: ```rust, editable struct Years(i64); fn main() { let years = Years(42); let years_as_primitive_1: i64 = years.0; // Tuple let Years(years_as_primitive_2) = years; // Destructuring } ``` ### See also: [`structs`][struct] [struct]: ../custom_types/structs.md ================================================ FILE: src/generics/phantom/testcase_units.md ================================================ # Testcase: unit clarification A useful method of unit conversions can be examined by implementing `Add` with a phantom type parameter. The `Add` `trait` is examined below: ```rust,ignore // This construction would impose: `Self + RHS = Output` // where RHS defaults to Self if not specified in the implementation. pub trait Add { type Output; fn add(self, rhs: RHS) -> Self::Output; } // `Output` must be `T` so that `T + T = T`. impl Add for T { type Output = T; ... } ``` The whole implementation: ```rust,editable use std::ops::Add; use std::marker::PhantomData; /// Create void enumerations to define unit types. #[derive(Debug, Clone, Copy)] enum Inch {} #[derive(Debug, Clone, Copy)] enum Mm {} /// `Length` is a type with phantom type parameter `Unit`, /// and is not generic over the length type (that is `f64`). /// /// `f64` already implements the `Clone` and `Copy` traits. #[derive(Debug, Clone, Copy)] struct Length(f64, PhantomData); /// The `Add` trait defines the behavior of the `+` operator. impl Add for Length { type Output = Length; // add() returns a new `Length` struct containing the sum. fn add(self, rhs: Length) -> Length { // `+` calls the `Add` implementation for `f64`. Length(self.0 + rhs.0, PhantomData) } } fn main() { // Specifies `one_foot` to have phantom type parameter `Inch`. let one_foot: Length = Length(12.0, PhantomData); // `one_meter` has phantom type parameter `Mm`. let one_meter: Length = Length(1000.0, PhantomData); // `+` calls the `add()` method we implemented for `Length`. // // Since `Length` implements `Copy`, `add()` does not consume // `one_foot` and `one_meter` but copies them into `self` and `rhs`. let two_feet = one_foot + one_foot; let two_meters = one_meter + one_meter; // Addition works. println!("one foot + one_foot = {:?} in", two_feet.0); println!("one meter + one_meter = {:?} mm", two_meters.0); // Nonsensical operations fail as they should: // Compile-time Error: type mismatch. //let one_feter = one_foot + one_meter; } ``` ### See also: [Borrowing (`&`)], [Bounds (`X: Y`)], [enum], [impl & self], [Overloading], [ref], [Traits (`X for Y`)], and [TupleStructs]. [Borrowing (`&`)]: ../../scope/borrow.md [Bounds (`X: Y`)]: ../../generics/bounds.md [enum]: ../../custom_types/enum.md [impl & self]: ../../fn/methods.md [Overloading]: ../../trait/ops.md [ref]: ../../scope/borrow/ref.md [Traits (`X for Y`)]: ../../trait.md [TupleStructs]: ../../custom_types/structs.md [std::marker::PhantomData]: https://doc.rust-lang.org/std/marker/struct.PhantomData.html ================================================ FILE: src/generics/phantom.md ================================================ # Phantom type parameters A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time. Data types can use extra generic type parameters to act as markers or to perform type checking at compile time. These extra parameters hold no storage values, and have no runtime behavior. In the following example, we combine [std::marker::PhantomData] with the phantom type parameter concept to create tuples containing different data types. ```rust,editable use std::marker::PhantomData; // A phantom tuple struct which is generic over `A` with hidden parameter `B`. #[derive(PartialEq)] // Allow equality test for this type. struct PhantomTuple(A, PhantomData); // A phantom type struct which is generic over `A` with hidden parameter `B`. #[derive(PartialEq)] // Allow equality test for this type. struct PhantomStruct { first: A, phantom: PhantomData } // Note: Storage is allocated for generic type `A`, but not for `B`. // Therefore, `B` cannot be used in computations. fn main() { // Here, `f32` and `f64` are the hidden parameters. // PhantomTuple type specified as ``. let _tuple1: PhantomTuple = PhantomTuple('Q', PhantomData); // PhantomTuple type specified as ``. let _tuple2: PhantomTuple = PhantomTuple('Q', PhantomData); // Type specified as ``. let _struct1: PhantomStruct = PhantomStruct { first: 'Q', phantom: PhantomData, }; // Type specified as ``. let _struct2: PhantomStruct = PhantomStruct { first: 'Q', phantom: PhantomData, }; // Compile-time Error! Type mismatch so these cannot be compared: // println!("_tuple1 == _tuple2 yields: {}", // _tuple1 == _tuple2); // Compile-time Error! Type mismatch so these cannot be compared: // println!("_struct1 == _struct2 yields: {}", // _struct1 == _struct2); } ``` ### See also: [Derive], [struct], and [tuple](../primitives/tuples.html). [Derive]: ../trait/derive.md [struct]: ../custom_types/structs.md [std::marker::PhantomData]: https://doc.rust-lang.org/std/marker/struct.PhantomData.html ================================================ FILE: src/generics/where.md ================================================ # Where clauses A bound can also be expressed using a `where` clause immediately before the opening `{`, rather than at the type's first mention. Additionally, `where` clauses can apply bounds to arbitrary types, rather than just to type parameters. Some cases that a `where` clause is useful: * When specifying generic types and bounds separately is clearer: ```rust,ignore impl MyTrait for YourType {} // Expressing bounds with a `where` clause impl MyTrait for YourType where A: TraitB + TraitC, D: TraitE + TraitF {} ``` * When using a `where` clause is more expressive than using normal syntax. The `impl` in this example cannot be directly expressed without a `where` clause: ```rust,editable use std::fmt::Debug; trait PrintInOption { fn print_in_option(self); } // Because we would otherwise have to express this as `T: Debug` or // use another method of indirect approach, this requires a `where` clause: impl PrintInOption for T where Option: Debug { // We want `Option: Debug` as our bound because that is what's // being printed. Doing otherwise would be using the wrong bound. fn print_in_option(self) { println!("{:?}", Some(self)); } } fn main() { let vec = vec![1, 2, 3]; vec.print_in_option(); } ``` ### See also: [RFC][where], [`struct`][struct], and [`trait`][trait] [struct]: ../custom_types/structs.md [trait]: ../trait.md [where]: https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md ================================================ FILE: src/generics.md ================================================ # Generics *Generics* is the topic of generalizing types and functionalities to broader cases. This is extremely useful for reducing code duplication in many ways, but can call for rather involved syntax. Namely, being generic requires taking great care to specify over which types a generic type is actually considered valid. The simplest and most common use of generics is for type parameters. A type parameter is specified as generic by the use of angle brackets and upper [camel case][camelcase]: ``. "Generic type parameters" are typically represented as ``. In Rust, "generic" also describes anything that accepts one or more generic type parameters ``. Any type specified as a generic type parameter is generic, and everything else is concrete (non-generic). For example, defining a *generic function* named `foo` that takes an argument `T` of any type: ```rust,ignore fn foo(arg: T) { ... } ``` Because `T` has been specified as a generic type parameter using ``, it is considered generic when used here as `(arg: T)`. This is the case even if `T` has previously been defined as a `struct`. This example shows some of the syntax in action: ```rust,editable // A concrete type `A`. struct A; // In defining the type `Single`, the first use of `A` is not preceded by ``. // Therefore, `Single` is a concrete type, and `A` is defined as above. struct Single(A); // ^ Here is `Single`s first use of the type `A`. // Here, `` precedes the first use of `T`, so `SingleGen` is a generic type. // Because the type parameter `T` is generic, it could be anything, including // the concrete type `A` defined at the top. struct SingleGen(T); fn main() { // `Single` is concrete and explicitly takes `A`. let _s = Single(A); // Create a variable `_char` of type `SingleGen` // and give it the value `SingleGen('a')`. // Here, `SingleGen` has a type parameter explicitly specified. let _char: SingleGen = SingleGen('a'); // `SingleGen` can also have a type parameter implicitly specified: let _t = SingleGen(A); // Uses `A` defined at the top. let _i32 = SingleGen(6); // Uses `i32`. let _char = SingleGen('a'); // Uses `char`. } ``` ### See also: [`structs`][structs] [structs]: custom_types/structs.md [camelcase]: https://en.wikipedia.org/wiki/CamelCase ================================================ FILE: src/hello/comment.md ================================================ # Comments Any program requires comments, and Rust supports a few different varieties: ## Regular Comments These are ignored by the compiler: * **Line comments**: Start with `//` and continue to the end of the line * **Block comments**: Enclosed in `/* ... */` and can span multiple lines ## Documentation Comments (Doc Comments) which are parsed into HTML library [documentation][docs]: - `///` - Generates docs for the item that follows it - `//!` - Generates docs for the enclosing item (typically used at the top of a file or module) ```rust,editable fn main() { // Line comments start with two slashes. // Everything after the slashes is ignored by the compiler. // Example: This line won't execute // println!("Hello, world!"); // Try removing the slashes above and running the code again. /* * Block comments are useful for temporarily disabling code. * They can also be nested: /* like this */ which makes it easy * to comment out large sections quickly. */ /* Note: The asterisk column on the left is just for style - it's not required by the language. */ // Block comments make it easy to toggle code on/off by adding // or removing just one slash: /* <- Add a '/' here to uncomment the entire block below println!("Now"); println!("everything"); println!("executes!"); // Line comments inside remain unaffected // */ // Block comments can also be used within expressions: let x = 5 + /* 90 + */ 5; println!("Is `x` 10 or 100? x = {}", x); } ``` ### See also: [Library documentation][docs] [docs]: ../meta/doc.md ================================================ FILE: src/hello/print/fmt.md ================================================ # Formatting We've seen that formatting is specified via a *format string*: * `format!("{}", foo)` -> `"3735928559"` * `format!("0x{:X}", foo)` -> [`"0xDEADBEEF"`][deadbeef] * `format!("0o{:o}", foo)` -> `"0o33653337357"` The same variable (`foo`) can be formatted differently depending on which *argument type* is used: `X` vs `o` vs *unspecified*. This formatting functionality is implemented via traits, and there is one trait for each argument type. The most common formatting trait is `Display`, which handles cases where the argument type is left unspecified: `{}` for instance. ```rust,editable use std::fmt::{self, Formatter, Display}; struct City { name: &'static str, // Latitude lat: f32, // Longitude lon: f32, } impl Display for City { // `f` is a buffer, and this method must write the formatted string into it. fn fmt(&self, f: &mut Formatter) -> fmt::Result { let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' }; let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' }; // `write!` is like `format!`, but it will write the formatted string // into a buffer (the first argument). write!(f, "{}: {:.3}°{} {:.3}°{}", self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c) } } #[derive(Debug)] struct Color { red: u8, green: u8, blue: u8, } fn main() { for city in [ City { name: "Dublin", lat: 53.347778, lon: -6.259722 }, City { name: "Oslo", lat: 59.95, lon: 10.75 }, City { name: "Vancouver", lat: 49.25, lon: -123.1 }, ] { println!("{}", city); } for color in [ Color { red: 128, green: 255, blue: 90 }, Color { red: 0, green: 3, blue: 254 }, Color { red: 0, green: 0, blue: 0 }, ] { // Switch this to use {} once you've added an implementation // for fmt::Display. println!("{:?}", color); } } ``` You can view a [full list of formatting traits][fmt_traits] and their argument types in the [`std::fmt`][fmt] documentation. ### Activity Add an implementation of the `fmt::Display` trait for the `Color` struct above so that the output displays as: ```text RGB (128, 255, 90) 0x80FF5A RGB (0, 3, 254) 0x0003FE RGB (0, 0, 0) 0x000000 ``` Two hints if you get stuck: * You [may need to list each color more than once][named_parameters]. * You can [pad with zeros to a width of 2][fmt_width] with `:0>2`. For hexadecimals, you can use `:02X`. Bonus: * If you would like to experiment with [type casting][type_casting] in advance, the formula for [calculating a color in the RGB color space][rgb_color] is `RGB = (R * 65_536) + (G * 256) + B`, where `R is RED, G is GREEN, and B is BLUE`. An unsigned 8-bit integer (`u8`) can only hold numbers up to 255. To cast `u8` to `u32`, you can write `variable_name as u32`. ### See also: [`std::fmt`][fmt] [rgb_color]: https://www.rapidtables.com/web/color/RGB_Color.html#rgb-format [named_parameters]: https://doc.rust-lang.org/std/fmt/#named-parameters [deadbeef]: https://en.wikipedia.org/wiki/Deadbeef#Magic_debug_values [fmt]: https://doc.rust-lang.org/std/fmt/ [fmt_traits]: https://doc.rust-lang.org/std/fmt/#formatting-traits [fmt_width]: https://doc.rust-lang.org/std/fmt/#width [type_casting]: ../../types/cast.md ================================================ FILE: src/hello/print/print_debug.md ================================================ # Debug All types which want to use `std::fmt` formatting `traits` require an implementation to be printable. Automatic implementations are only provided for types such as in the `std` library. All others *must* be manually implemented somehow. The `fmt::Debug` `trait` makes this very straightforward. *All* types can `derive` (automatically create) the `fmt::Debug` implementation. This is not true for `fmt::Display` which must be manually implemented. ```rust // This structure cannot be printed either with `fmt::Display` or // with `fmt::Debug`. struct UnPrintable(i32); // The `derive` attribute automatically creates the implementation // required to make this `struct` printable with `fmt::Debug`. #[derive(Debug)] struct DebugPrintable(i32); ``` All `std` library types are automatically printable with `{:?}` too: ```rust,editable // Derive the `fmt::Debug` implementation for `Structure`. `Structure` // is a structure which contains a single `i32`. #[derive(Debug)] struct Structure(i32); // Put a `Structure` inside of the structure `Deep`. Make it printable // also. #[derive(Debug)] struct Deep(Structure); fn main() { // Printing with `{:?}` is similar to with `{}`. println!("{:?} months in a year.", 12); println!("{1:?} {0:?} is the {actor:?} name.", "Slater", "Christian", actor="actor's"); // `Structure` is printable! println!("Now {:?} will print!", Structure(3)); // The problem with `derive` is there is no control over how // the results look. What if I want this to just show a `7`? println!("Now {:?} will print!", Deep(Structure(7))); } ``` So `fmt::Debug` definitely makes this printable but sacrifices some elegance. Rust also provides "pretty printing" with `{:#?}`. ```rust,editable #[derive(Debug)] struct Person<'a> { name: &'a str, age: u8 } fn main() { let name = "Peter"; let age = 27; let peter = Person { name, age }; // Pretty print println!("{:#?}", peter); } ``` One can manually implement `fmt::Display` to control the display. ### See also: [`attributes`][attributes], [`derive`][derive], [`std::fmt`][fmt], and [`struct`][structs] [attributes]: https://doc.rust-lang.org/reference/attributes.html [derive]: ../../trait/derive.md [fmt]: https://doc.rust-lang.org/std/fmt/ [structs]: ../../custom_types/structs.md ================================================ FILE: src/hello/print/print_display/testcase_list.md ================================================ # Testcase: List Implementing `fmt::Display` for a structure where the elements must each be handled sequentially is tricky. The problem is that each `write!` generates a `fmt::Result`. Proper handling of this requires dealing with *all* the results. Rust provides the `?` operator for exactly this purpose. Using `?` on `write!` looks like this: ```rust,ignore // Try `write!` to see if it errors. If it errors, return // the error. Otherwise continue. write!(f, "{}", value)?; ``` With `?` available, implementing `fmt::Display` for a `Vec` is straightforward: ```rust,editable use std::fmt; // Import the `fmt` module. // Define a structure named `List` containing a `Vec`. struct List(Vec); impl fmt::Display for List { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Extract the value using tuple indexing, // and create a reference to `vec`. let vec = &self.0; write!(f, "[")?; // Iterate over `v` in `vec` while enumerating the iteration // index in `index`. for (index, v) in vec.iter().enumerate() { // For every element except the first, add a comma. // Use the ? operator to return on errors. if index != 0 { write!(f, ", ")?; } write!(f, "{}", v)?; } // Close the opened bracket and return a fmt::Result value. write!(f, "]") } } fn main() { let v = List(vec![1, 2, 3]); println!("{}", v); } ``` ### Activity Try changing the program so that the index of each element in the vector is also printed. The new output should look like this: ```rust,ignore [0: 1, 1: 2, 2: 3] ``` ### See also: [`for`][for], [`ref`][ref], [`Result`][result], [`struct`][struct], [`?`][q_mark], and [`vec!`][vec] [for]: ../../../flow_control/for.md [result]: ../../../std/result.md [ref]: ../../../scope/borrow/ref.md [struct]: ../../../custom_types/structs.md [q_mark]: ../../../std/result/question_mark.md [vec]: ../../../std/vec.md ================================================ FILE: src/hello/print/print_display.md ================================================ # Display `fmt::Debug` hardly looks compact and clean, so it is often advantageous to customize the output appearance. This is done by manually implementing [`fmt::Display`][fmt], which uses the `{}` print marker. Implementing it looks like this: ```rust // Import (via `use`) the `fmt` module to make it available. use std::fmt; // Define a structure for which `fmt::Display` will be implemented. This is // a tuple struct named `Structure` that contains an `i32`. struct Structure(i32); // To use the `{}` marker, the trait `fmt::Display` must be implemented // manually for the type. impl fmt::Display for Structure { // This trait requires `fmt` with this exact signature. fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Write strictly the first element into the supplied output // stream: `f`. Returns `fmt::Result` which indicates whether the // operation succeeded or failed. Note that `write!` uses syntax which // is very similar to `println!`. write!(f, "{}", self.0) } } ``` `fmt::Display` may be cleaner than `fmt::Debug` but this presents a problem for the `std` library. How should ambiguous types be displayed? For example, if the `std` library implemented a single style for all `Vec`, what style should it be? Would it be either of these two? * `Vec`: `/:/etc:/home/username:/bin` (split on `:`) * `Vec`: `1,2,3` (split on `,`) No, because there is no ideal style for all types and the `std` library doesn't presume to dictate one. `fmt::Display` is not implemented for `Vec` or for any other generic containers. `fmt::Debug` must then be used for these generic cases. This is not a problem though because for any new *container* type which is *not* generic, `fmt::Display` can be implemented. ```rust,editable use std::fmt; // Import `fmt` // A structure holding two numbers. `Debug` will be derived so the results can // be contrasted with `Display`. #[derive(Debug)] struct MinMax(i64, i64); // Implement `Display` for `MinMax`. impl fmt::Display for MinMax { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Use `self.number` to refer to each positional data point. write!(f, "({}, {})", self.0, self.1) } } // Define a structure where the fields are nameable for comparison. #[derive(Debug)] struct Point2D { x: f64, y: f64, } // Similarly, implement `Display` for `Point2D`. impl fmt::Display for Point2D { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Customize so only `x` and `y` are denoted. write!(f, "x: {}, y: {}", self.x, self.y) } } fn main() { let minmax = MinMax(0, 14); println!("Compare structures:"); println!("Display: {}", minmax); println!("Debug: {:?}", minmax); let big_range = MinMax(-300, 300); let small_range = MinMax(-3, 3); println!("The big range is {big} and the small is {small}", small = small_range, big = big_range); let point = Point2D { x: 3.3, y: 7.2 }; println!("Compare points:"); println!("Display: {}", point); println!("Debug: {:?}", point); // Error. Both `Debug` and `Display` were implemented, but `{:b}` // requires `fmt::Binary` to be implemented. This will not work. // println!("What does Point2D look like in binary: {:b}?", point); } ``` So, `fmt::Display` has been implemented but `fmt::Binary` has not, and therefore cannot be used. `std::fmt` has many such [`traits`][traits] and each requires its own implementation. This is detailed further in [`std::fmt`][fmt]. ### Activity After checking the output of the above example, use the `Point2D` struct as a guide to add a `Complex` struct to the example. When printed in the same way, the output should be: ```txt Display: 3.3 +7.2i Debug: Complex { real: 3.3, imag: 7.2 } Display: 4.7 -2.3i Debug: Complex { real: 4.7, imag: -2.3 } ``` Bonus: Add a space after the `+`/`-` signs. Hints in case you get stuck: - Check the documentation for [`Sign/#/0`][fmt_sign0] in `std::fmt`. - Bonus: Check [`if`-`else`][if_else] branching and the [`abs`][f64_abs] function. ### See also: [`derive`][derive], [`std::fmt`][fmt], [`macros`][macros], [`struct`][structs], [`trait`][traits], and [`use`][use] [derive]: ../../trait/derive.md [f64_abs]: https://doc.rust-lang.org/std/primitive.f64.html#method.abs [fmt]: https://doc.rust-lang.org/std/fmt/ [fmt_sign0]: https://doc.rust-lang.org/std/fmt/#sign0 [if_else]: ../../flow_control/if_else.md [macros]: ../../macros.md [structs]: ../../custom_types/structs.md [traits]: https://doc.rust-lang.org/std/fmt/#formatting-traits [use]: ../../mod/use.md ================================================ FILE: src/hello/print.md ================================================ # Formatted print Printing is handled by a series of [`macros`][macros] defined in [`std::fmt`][fmt] some of which are: * `format!`: write formatted text to [`String`][string] * `print!`: same as `format!` but the text is printed to the console (io::stdout). * `println!`: same as `print!` but a newline is appended. * `eprint!`: same as `print!` but the text is printed to the standard error (io::stderr). * `eprintln!`: same as `eprint!` but a newline is appended. All parse text in the same fashion. As a plus, Rust checks formatting correctness at compile time. ```rust,editable,ignore,mdbook-runnable fn main() { // In general, the `{}` will be automatically replaced with any // arguments. These will be stringified. println!("{} days", 31); // Positional arguments can be used. Specifying an integer inside `{}` // determines which additional argument will be replaced. Arguments start // at 0 immediately after the format string. println!("{0}, this is {1}. {1}, this is {0}", "Alice", "Bob"); // As can named arguments. println!("{subject} {verb} {object}", object="the lazy dog", subject="the quick brown fox", verb="jumps over"); // Different formatting can be invoked by specifying the format character // after a `:`. println!("Base 10: {}", 69420); // 69420 println!("Base 2 (binary): {:b}", 69420); // 10000111100101100 println!("Base 8 (octal): {:o}", 69420); // 207454 println!("Base 16 (hexadecimal): {:x}", 69420); // 10f2c // You can right-justify text with a specified width. This will // output " 1". (Four white spaces and a "1", for a total width of 5.) println!("{number:>5}", number=1); // You can pad numbers with extra zeroes, println!("{number:0>5}", number=1); // 00001 // and left-adjust by flipping the sign. This will output "10000". println!("{number:0<5}", number=1); // 10000 // You can use named arguments in the format specifier by appending a `$`. println!("{number:0>width$}", number=1, width=5); // Rust even checks to make sure the correct number of arguments are used. println!("My name is {0}, {1} {0}", "Bond"); // FIXME ^ Add the missing argument: "James" // Only types that implement fmt::Display can be formatted with `{}`. User- // defined types do not implement fmt::Display by default. #[allow(dead_code)] // disable `dead_code` which warn against unused module struct Structure(i32); // This will not compile because `Structure` does not implement // fmt::Display. // println!("This struct `{}` won't print...", Structure(3)); // TODO ^ Try uncommenting this line // For Rust 1.58 and above, you can directly capture the argument from a // surrounding variable. Just like the above, this will output // " 1", 4 white spaces and a "1". let number: f64 = 1.0; let width: usize = 5; println!("{number:>width$}"); } ``` [`std::fmt`][fmt] contains many [`traits`][traits] which govern the display of text. The base form of two important ones are listed below: * `fmt::Debug`: Uses the `{:?}` marker. Format text for debugging purposes. * `fmt::Display`: Uses the `{}` marker. Format text in a more elegant, user friendly fashion. Here, we used `fmt::Display` because the std library provides implementations for these types. To print text for custom types, more steps are required. Implementing the `fmt::Display` trait automatically implements the [`ToString`] trait which allows us to [convert] the type to [`String`][string]. In *line 43*, `#[allow(dead_code)]` is an [attribute] which only applies to the module after it. ### Activities * Fix the issue in the above code (see FIXME) so that it runs without error. * Try uncommenting the line that attempts to format the `Structure` struct (see TODO) * Add a `println!` macro call that prints: `Pi is roughly 3.142` by controlling the number of decimal places shown. For the purposes of this exercise, use `let pi = 3.141592` as an estimate for pi. (Hint: you may need to check the [`std::fmt`][fmt] documentation for setting the number of decimals to display) ### See also: [`std::fmt`][fmt], [`macros`][macros], [`struct`][structs], [`traits`][traits], and [`dead_code`][dead_code] [fmt]: https://doc.rust-lang.org/std/fmt/ [macros]: ../macros.md [string]: ../std/str.md [structs]: ../custom_types/structs.md [traits]: https://doc.rust-lang.org/std/fmt/#formatting-traits [`ToString`]: https://doc.rust-lang.org/std/string/trait.ToString.html [convert]: ../conversion/string.md [attribute]: ../attribute.md [dead_code]: ../attribute/unused.md ================================================ FILE: src/hello.md ================================================ # Hello World This is the source code of the traditional Hello World program. ```rust,editable // This is a comment, and is ignored by the compiler. // You can test this code by clicking the "Run" button over there -> // or if you prefer to use your keyboard, you can use the "Ctrl + Enter" // shortcut. // This code is editable, feel free to hack it! // You can always return to the original code by clicking the "Reset" button -> // This is the main function. fn main() { // Statements here are executed when the compiled binary is called. // Print text to the console. println!("Hello World!"); } ``` `println!` is a [*macro*][macros] that prints text to the console. A binary can be generated using the Rust compiler: `rustc`. ```bash $ rustc hello.rs ``` `rustc` will produce a `hello` binary that can be executed. ```bash $ ./hello Hello World! ``` ### Activity Click 'Run' above to see the expected output. Next, add a new line with a second `println!` macro so that the output shows: ```text Hello World! I'm a Rustacean! ``` [macros]: macros.md ================================================ FILE: src/index.md ================================================ # Rust by Example [Rust][rust] is a modern systems programming language focusing on safety, speed, and concurrency. It accomplishes these goals by being memory safe without using garbage collection. Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries. To get even more out of these examples, don't forget to [install Rust locally][install] and check out the [official docs][std]. Additionally for the curious, you can also [check out the source code for this site][home]. Now let's begin! - [Hello World](hello.md) - Start with a traditional Hello World program. - [Primitives](primitives.md) - Learn about signed integers, unsigned integers and other primitives. - [Custom Types](custom_types.md) - `struct` and `enum`. - [Variable Bindings](variable_bindings.md) - mutable bindings, scope, shadowing. - [Types](types.md) - Learn about changing and defining types. - [Conversion](conversion.md) - Convert between different types, such as strings, integers, and floats. - [Expressions](expression.md) - Learn about Expressions & how to use them. - [Flow of Control](flow_control.md) - `if`/`else`, `for`, and others. - [Functions](fn.md) - Learn about Methods, Closures and Higher Order Functions. - [Modules](mod.md) - Organize code using modules - [Crates](crates.md) - A crate is a compilation unit in Rust. Learn to create a library. - [Cargo](cargo.md) - Go through some basic features of the official Rust package management tool. - [Attributes](attribute.md) - An attribute is metadata applied to some module, crate or item. - [Generics](generics.md) - Learn about writing a function or data type which can work for multiple types of arguments. - [Scoping rules](scope.md) - Scopes play an important part in ownership, borrowing, and lifetimes. - [Traits](trait.md) - A trait is a collection of methods defined for an unknown type: `Self` - [Macros](macros.md) - Macros are a way of writing code that writes other code, which is known as metaprogramming. - [Error handling](error.md) - Learn Rust way of handling failures. - [Std library types](std.md) - Learn about some custom types provided by `std` library. - [Std misc](std_misc.md) - More custom types for file handling, threads. - [Testing](testing.md) - All sorts of testing in Rust. - [Unsafe Operations](unsafe.md) - Learn about entering a block of unsafe operations. - [Compatibility](compatibility.md) - Handling Rust's evolution and potential compatibility issues. - [Meta](meta.md) - Documentation, Benchmarking. [rust]: https://www.rust-lang.org/ [install]: https://www.rust-lang.org/tools/install [std]: https://doc.rust-lang.org/std/ [home]: https://github.com/rust-lang/rust-by-example ================================================ FILE: src/macros/designators.md ================================================ # Designators The arguments of a macro are prefixed by a dollar sign `$` and type annotated with a *designator*: ```rust,editable macro_rules! create_function { // This macro takes an argument of designator `ident` and // creates a function named `$func_name`. // The `ident` designator is used for variable/function names. ($func_name:ident) => { fn $func_name() { // The `stringify!` macro converts an `ident` into a string. println!("You called {:?}()", stringify!($func_name)); } }; } // Create functions named `foo` and `bar` with the above macro. create_function!(foo); create_function!(bar); macro_rules! print_result { // This macro takes an expression of type `expr` and prints // it as a string along with its result. // The `expr` designator is used for expressions. ($expression:expr) => { // `stringify!` will convert the expression *as it is* into a string. println!("{:?} = {:?}", stringify!($expression), $expression); }; } fn main() { foo(); bar(); print_result!(1u32 + 1); // Recall that blocks are expressions too! print_result!({ let x = 1u32; x * x + 2 * x - 1 }); } ``` These are some of the available designators: * `block` * `expr` is used for expressions * `ident` is used for variable/function names * `item` * `literal` is used for literal constants * `pat` (*pattern*) * `path` * `stmt` (*statement*) * `tt` (*token tree*) * `ty` (*type*) * `vis` (*visibility qualifier*) For a complete list, see the [Rust Reference]. [Rust Reference]: https://doc.rust-lang.org/reference/macros-by-example.html ================================================ FILE: src/macros/dry.md ================================================ # DRY (Don't Repeat Yourself) Macros allow writing DRY code by factoring out the common parts of functions and/or test suites. Here is an example that implements and tests the `+=`, `*=` and `-=` operators on `Vec`: ```rust,editable use std::ops::{Add, Mul, Sub}; macro_rules! assert_equal_len { // The `tt` (token tree) designator is used for // operators and tokens. ($a:expr, $b:expr, $func:ident, $op:tt) => { assert!($a.len() == $b.len(), "{:?}: dimension mismatch: {:?} {:?} {:?}", stringify!($func), ($a.len(),), stringify!($op), ($b.len(),)); }; } macro_rules! op { ($func:ident, $bound:ident, $op:tt, $method:ident) => { fn $func + Copy>(xs: &mut Vec, ys: &Vec) { assert_equal_len!(xs, ys, $func, $op); for (x, y) in xs.iter_mut().zip(ys.iter()) { *x = $bound::$method(*x, *y); // *x = x.$method(*y); } } }; } // Implement `add_assign`, `mul_assign`, and `sub_assign` functions. op!(add_assign, Add, +=, add); op!(mul_assign, Mul, *=, mul); op!(sub_assign, Sub, -=, sub); mod test { use std::iter; macro_rules! test { ($func:ident, $x:expr, $y:expr, $z:expr) => { #[test] fn $func() { for size in 0usize..10 { let mut x: Vec<_> = iter::repeat($x).take(size).collect(); let y: Vec<_> = iter::repeat($y).take(size).collect(); let z: Vec<_> = iter::repeat($z).take(size).collect(); super::$func(&mut x, &y); assert_eq!(x, z); } } }; } // Test `add_assign`, `mul_assign`, and `sub_assign`. test!(add_assign, 1u32, 2u32, 3u32); test!(mul_assign, 2u32, 3u32, 6u32); test!(sub_assign, 3u32, 2u32, 1u32); } ``` ```shell $ rustc --test dry.rs && ./dry running 3 tests test test::mul_assign ... ok test test::add_assign ... ok test test::sub_assign ... ok test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured ``` ================================================ FILE: src/macros/dsl.md ================================================ # Domain Specific Languages (DSLs) A DSL is a mini "language" embedded in a Rust macro. It is completely valid Rust because the macro system expands into normal Rust constructs, but it looks like a small language. This allows you to define concise or intuitive syntax for some special functionality (within bounds). Suppose that I want to define a little calculator API. I would like to supply an expression and have the output printed to console. ```rust,editable macro_rules! calculate { (eval $e:expr) => { { let val: usize = $e; // Force types to be unsigned integers println!("{} = {}", stringify!{$e}, val); } }; } fn main() { calculate! { eval 1 + 2 // hehehe `eval` is _not_ a Rust keyword! } calculate! { eval (1 + 2) * (3 / 4) } } ``` Output: ```txt 1 + 2 = 3 (1 + 2) * (3 / 4) = 0 ``` This was a very simple example, but much more complex interfaces have been developed, such as [`lazy_static`](https://crates.io/crates/lazy_static) or [`clap`](https://crates.io/crates/clap). Also, note the two pairs of braces in the macro. The outer ones are part of the syntax of `macro_rules!`, in addition to `()` or `[]`. ================================================ FILE: src/macros/overload.md ================================================ # Overload Macros can be overloaded to accept different combinations of arguments. In that regard, `macro_rules!` can work similarly to a match block: ```rust,editable // `test!` will compare `$left` and `$right` // in different ways depending on how you invoke it: macro_rules! test { // Arguments don't need to be separated by a comma. // Any template can be used! ($left:expr; and $right:expr) => { println!("{:?} and {:?} is {:?}", stringify!($left), stringify!($right), $left && $right) }; // ^ each arm must end with a semicolon. ($left:expr; or $right:expr) => { println!("{:?} or {:?} is {:?}", stringify!($left), stringify!($right), $left || $right) }; } fn main() { test!(1i32 + 1 == 2i32; and 2i32 * 2 == 4i32); test!(true; or false); } ``` ================================================ FILE: src/macros/repeat.md ================================================ # Repeat Macros can use `+` in the argument list to indicate that an argument may repeat at least once, or `*`, to indicate that the argument may repeat zero or more times. In the following example, surrounding the matcher with `$(...),+` will match one or more expression, separated by commas. Also note that the semicolon is optional on the last case. ```rust,editable // `find_min!` will calculate the minimum of any number of arguments. macro_rules! find_min { // Base case: ($x:expr) => ($x); // `$x` followed by at least one `$y,` ($x:expr, $($y:expr),+) => ( // Call `find_min!` on the tail `$y` std::cmp::min($x, find_min!($($y),+)) ) } fn main() { println!("{}", find_min!(1)); println!("{}", find_min!(1 + 2, 2)); println!("{}", find_min!(5, 2 * 3, 4)); } ``` ================================================ FILE: src/macros/syntax.md ================================================ # Syntax In following subsections, we will show how to define macros in Rust. There are three basic ideas: - [Patterns and Designators][designators] - [Overloading][overloading] - [Repetition][repetition] [designators]: designators.md [overloading]: overload.md [repetition]: repeat.md ================================================ FILE: src/macros/variadics.md ================================================ # Variadic Interfaces A _variadic_ interface takes an arbitrary number of arguments. For example, `println!` can take an arbitrary number of arguments, as determined by the format string. We can extend our `calculate!` macro from the previous section to be variadic: ```rust,editable macro_rules! calculate { // The pattern for a single `eval` (eval $e:expr) => { { let val: usize = $e; // Force types to be integers println!("{} = {}", stringify!{$e}, val); } }; // Decompose multiple `eval`s recursively (eval $e:expr, $(eval $es:expr),+) => {{ calculate! { eval $e } calculate! { $(eval $es),+ } }}; } fn main() { calculate! { // Look ma! Variadic `calculate!`! eval 1 + 2, eval 3 + 4, eval (2 * 3) + 1 } } ``` Output: ```txt 1 + 2 = 3 3 + 4 = 7 (2 * 3) + 1 = 7 ``` ================================================ FILE: src/macros.md ================================================ # `macro_rules!` Rust provides a powerful macro system that allows metaprogramming. As you've seen in previous chapters, macros look like functions, except that their name ends with a bang `!`, but instead of generating a function call, macros are expanded into source code that gets compiled with the rest of the program. However, unlike macros in C and other languages, Rust macros are expanded into abstract syntax trees, rather than string preprocessing, so you don't get unexpected precedence bugs. Macros are created using the `macro_rules!` macro. ```rust,editable // This is a simple macro named `say_hello`. macro_rules! say_hello { // `()` indicates that the macro takes no argument. () => { // The macro will expand into the contents of this block. println!("Hello!") }; } fn main() { // This call will expand into `println!("Hello!")` say_hello!() } ``` So why are macros useful? 1. Don't repeat yourself. There are many cases where you may need similar functionality in multiple places but with different types. Often, writing a macro is a useful way to avoid repeating code. (More on this later) 2. Domain-specific languages. Macros allow you to define special syntax for a specific purpose. (More on this later) 3. Variadic interfaces. Sometimes you want to define an interface that takes a variable number of arguments. An example is `println!` which could take any number of arguments, depending on the format string. (More on this later) ================================================ FILE: src/meta/doc.md ================================================ # Documentation Use `cargo doc` to build documentation in `target/doc`, `cargo doc --open` will automatically open it in your web browser. Use `cargo test` to run all tests (including documentation tests), and `cargo test --doc` to only run documentation tests. These commands will appropriately invoke `rustdoc` (and `rustc`) as required. ## Doc comments Doc comments are very useful for big projects that require documentation. When running `rustdoc`, these are the comments that get compiled into documentation. They are denoted by a `///`, and support [Markdown]. ````rust,editable,ignore #![crate_name = "doc"] /// A human being is represented here pub struct Person { /// A person must have a name, no matter how much Juliet may hate it name: String, } impl Person { /// Creates a person with the given name. /// /// # Examples /// /// ``` /// // You can have rust code between fences inside the comments /// // If you pass --test to `rustdoc`, it will even test it for you! /// use doc::Person; /// let person = Person::new("name"); /// ``` pub fn new(name: &str) -> Person { Person { name: name.to_string(), } } /// Gives a friendly hello! /// /// Says "Hello, [name](Person::name)" to the `Person` it is called on. pub fn hello(&self) { println!("Hello, {}!", self.name); } } fn main() { let john = Person::new("John"); john.hello(); } ```` To run the tests, first build the code as a library, then tell `rustdoc` where to find the library so it can link it into each doctest program: ```shell $ rustc doc.rs --crate-type lib $ rustdoc --test --extern doc="libdoc.rlib" doc.rs ``` ## Doc attributes Below are a few examples of the most common `#[doc]` attributes used with `rustdoc`. ### `inline` Used to inline docs, instead of linking out to separate page. ```rust,ignore #[doc(inline)] pub use bar::Bar; /// bar docs pub mod bar { /// the docs for Bar pub struct Bar; } ``` ### `no_inline` Used to prevent linking out to separate page or anywhere. ```rust,ignore // Example from libcore/prelude #[doc(no_inline)] pub use crate::mem::drop; ``` ### `hidden` Using this tells `rustdoc` not to include this in documentation: ```rust,editable,ignore // Example from the futures-rs library #[doc(hidden)] pub use self::async_await::*; ``` For documentation, `rustdoc` is widely used by the community. It's what is used to generate the [std library docs](https://doc.rust-lang.org/std/). ### See also: - [The Rust Book: Making Useful Documentation Comments][book] - [The rustdoc Book][rustdoc-book] - [The Reference: Doc comments][ref-comments] - [RFC 1574: API Documentation Conventions][api-conv] - [RFC 1946: Relative links to other items from doc comments (intra-rustdoc links)][intra-links] - [Is there any documentation style guide for comments? (reddit)][reddit] [markdown]: https://en.wikipedia.org/wiki/Markdown [book]: https://doc.rust-lang.org/book/ch14-02-publishing-to-crates-io.html#making-useful-documentation-comments [ref-comments]: https://doc.rust-lang.org/stable/reference/comments.html#doc-comments [rustdoc-book]: https://doc.rust-lang.org/rustdoc/index.html [api-conv]: https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text [intra-links]: https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html [reddit]: https://www.reddit.com/r/rust/comments/ahb50s/is_there_any_documentation_style_guide_for/ ================================================ FILE: src/meta/playground.md ================================================ # Playground The [Rust Playground](https://play.rust-lang.org/) is a way to experiment with Rust code through a web interface. ## Using it with `mdbook` In [`mdbook`][mdbook], you can make code examples playable and editable. ```rust,editable fn main() { println!("Hello World!"); } ``` This allows the reader to both run your code sample, but also modify and tweak it. The key here is the adding of the word `editable` to your codefence block separated by a comma. ````markdown ```rust,editable //...place your code here ``` ```` Additionally, you can add `ignore` if you want `mdbook` to skip your code when it builds and tests. ````markdown ```rust,editable,ignore //...place your code here ``` ```` ## Using it with docs You may have noticed in some of the [official Rust docs][official-rust-docs] a button that says "Run", which opens the code sample up in a new tab in Rust Playground. This feature is enabled if you use the `#[doc]` attribute called [`html_playground_url`][html-playground-url]. ```text #![doc(html_playground_url = "https://play.rust-lang.org/")] //! ``` //! println!("Hello World"); //! ``` ``` ### See also: - [The Rust Playground][rust-playground] - [The Rust Playground On Github][rust-playground-github] - [The rustdoc Book][rustdoc-book] [rust-playground]: https://play.rust-lang.org/ [rust-playground-github]: https://github.com/integer32llc/rust-playground/ [mdbook]: https://github.com/rust-lang/mdBook [official-rust-docs]: https://doc.rust-lang.org/core/ [rustdoc-book]: https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html [html-playground-url]: https://doc.rust-lang.org/rustdoc/write-documentation/the-doc-attribute.html#html_playground_url ================================================ FILE: src/meta.md ================================================ # Meta Some topics aren't exactly relevant to how you program runs but provide you tooling or infrastructure support which just makes things better for everyone. These topics include: - [Documentation][doc]: Generate library documentation for users via the included `rustdoc`. - [Playground][playground]: Integrate the Rust Playground in your documentation. [doc]: meta/doc.md [playground]: meta/playground.md ================================================ FILE: src/mod/split.md ================================================ # File hierarchy Modules can be mapped to a file/directory hierarchy. Let's break down the [visibility example][visibility] in files: ```shell $ tree . . ├── my │   ├── inaccessible.rs │   └── nested.rs ├── my.rs └── split.rs ``` In `split.rs`: ```rust,ignore // This declaration will look for a file named `my.rs` and will // insert its contents inside a module named `my` under this scope mod my; fn function() { println!("called `function()`"); } fn main() { my::function(); function(); my::indirect_access(); my::nested::function(); } ``` In `my.rs`: ```rust,ignore // Similarly `mod inaccessible` and `mod nested` will locate the `nested.rs` // and `inaccessible.rs` files and insert them here under their respective // modules mod inaccessible; pub mod nested; pub fn function() { println!("called `my::function()`"); } fn private_function() { println!("called `my::private_function()`"); } pub fn indirect_access() { print!("called `my::indirect_access()`, that\n> "); private_function(); } ``` In `my/nested.rs`: ```rust,ignore pub fn function() { println!("called `my::nested::function()`"); } #[allow(dead_code)] fn private_function() { println!("called `my::nested::private_function()`"); } ``` In `my/inaccessible.rs`: ```rust,ignore #[allow(dead_code)] pub fn public_function() { println!("called `my::inaccessible::public_function()`"); } ``` Let's check that things still work as before: ```shell $ rustc split.rs && ./split called `my::function()` called `function()` called `my::indirect_access()`, that > called `my::private_function()` called `my::nested::function()` ``` [visibility]: visibility.md ================================================ FILE: src/mod/struct_visibility.md ================================================ # Struct visibility Structs have an extra level of visibility with their fields. The visibility defaults to private, and can be overridden with the `pub` modifier. This visibility only matters when a struct is accessed from outside the module where it is defined, and has the goal of hiding information (encapsulation). ```rust,editable mod my { // A public struct with a public field of generic type `T` pub struct OpenBox { pub contents: T, } // A public struct with a private field of generic type `T` pub struct ClosedBox { contents: T, } impl ClosedBox { // A public constructor method pub fn new(contents: T) -> ClosedBox { ClosedBox { contents: contents, } } } } fn main() { // Public structs with public fields can be constructed as usual let open_box = my::OpenBox { contents: "public information" }; // and their fields can be normally accessed. println!("The open box contains: {}", open_box.contents); // Public structs with private fields cannot be constructed using field names. // Error! `ClosedBox` has private fields //let closed_box = my::ClosedBox { contents: "classified information" }; // TODO ^ Try uncommenting this line // However, structs with private fields can be created using // public constructors let _closed_box = my::ClosedBox::new("classified information"); // and the private fields of a public struct cannot be accessed. // Error! The `contents` field is private //println!("The closed box contains: {}", _closed_box.contents); // TODO ^ Try uncommenting this line } ``` ### See also: [generics][generics] and [methods][methods] [generics]: ../generics.md [methods]: ../fn/methods.md ================================================ FILE: src/mod/super.md ================================================ # `super` and `self` The `super` and `self` keywords can be used in the path to remove ambiguity when accessing items and to prevent unnecessary hardcoding of paths. ```rust,editable fn function() { println!("called `function()`"); } mod cool { pub fn function() { println!("called `cool::function()`"); } } mod my { fn function() { println!("called `my::function()`"); } mod cool { pub fn function() { println!("called `my::cool::function()`"); } } pub fn indirect_call() { // Let's access all the functions named `function` from this scope! print!("called `my::indirect_call()`, that\n> "); // The `self` keyword refers to the current module scope - in this case `my`. // Calling `self::function()` and calling `function()` directly both give // the same result, because they refer to the same function. self::function(); function(); // We can also use `self` to access another module inside `my`: self::cool::function(); // The `super` keyword refers to the parent scope (outside the `my` module). super::function(); // This will bind to the `cool::function` in the *crate* scope. // In this case the crate scope is the outermost scope. { use crate::cool::function as root_function; root_function(); } } } fn main() { my::indirect_call(); } ``` ================================================ FILE: src/mod/use.md ================================================ # The `use` declaration The `use` declaration can be used to bind a full path to a new name, for easier access. It is often used like this: ```rust,editable,ignore use crate::deeply::nested::{ my_first_function, my_second_function, AndATraitType }; fn main() { my_first_function(); } ``` You can use the `as` keyword to bind imports to a different name: ```rust,editable // Bind the `deeply::nested::function` path to `other_function`. use deeply::nested::function as other_function; fn function() { println!("called `function()`"); } mod deeply { pub mod nested { pub fn function() { println!("called `deeply::nested::function()`"); } } } fn main() { // Easier access to `deeply::nested::function` other_function(); println!("Entering block"); { // This is equivalent to `use deeply::nested::function as function`. // This `function()` will shadow the outer one. use crate::deeply::nested::function; // `use` bindings have a local scope. In this case, the // shadowing of `function()` is only in this block. function(); println!("Leaving block"); } function(); } ``` ================================================ FILE: src/mod/visibility.md ================================================ # Visibility By default, the items in a module have private visibility, but this can be overridden with the `pub` modifier. Only the public items of a module can be accessed from outside the module scope. ```rust,editable // A module named `my_mod` mod my_mod { // Items in modules default to private visibility. fn private_function() { println!("called `my_mod::private_function()`"); } // Use the `pub` modifier to override default visibility. pub fn function() { println!("called `my_mod::function()`"); } // Items can access other items in the same module, // even when private. pub fn indirect_access() { print!("called `my_mod::indirect_access()`, that\n> "); private_function(); } // Modules can also be nested pub mod nested { pub fn function() { println!("called `my_mod::nested::function()`"); } #[allow(dead_code)] fn private_function() { println!("called `my_mod::nested::private_function()`"); } // Functions declared using `pub(in path)` syntax are only visible // within the given path. `path` must be a parent or ancestor module pub(in crate::my_mod) fn public_function_in_my_mod() { print!("called `my_mod::nested::public_function_in_my_mod()`, that\n> "); public_function_in_nested(); } // Functions declared using `pub(self)` syntax are only visible within // the current module, which is the same as leaving them private pub(self) fn public_function_in_nested() { println!("called `my_mod::nested::public_function_in_nested()`"); } // Functions declared using `pub(super)` syntax are only visible within // the parent module pub(super) fn public_function_in_super_mod() { println!("called `my_mod::nested::public_function_in_super_mod()`"); } } pub fn call_public_function_in_my_mod() { print!("called `my_mod::call_public_function_in_my_mod()`, that\n> "); nested::public_function_in_my_mod(); print!("> "); nested::public_function_in_super_mod(); } // pub(crate) makes functions visible only within the current crate pub(crate) fn public_function_in_crate() { println!("called `my_mod::public_function_in_crate()`"); } // Nested modules follow the same rules for visibility mod private_nested { #[allow(dead_code)] pub fn function() { println!("called `my_mod::private_nested::function()`"); } // Private parent items will still restrict the visibility of a child item, // even if it is declared as visible within a bigger scope. #[allow(dead_code)] pub(crate) fn restricted_function() { println!("called `my_mod::private_nested::restricted_function()`"); } } } fn function() { println!("called `function()`"); } fn main() { // Modules allow disambiguation between items that have the same name. function(); my_mod::function(); // Public items, including those inside nested modules, can be // accessed from outside the parent module. my_mod::indirect_access(); my_mod::nested::function(); my_mod::call_public_function_in_my_mod(); // pub(crate) items can be called from anywhere in the same crate my_mod::public_function_in_crate(); // pub(in path) items can only be called from within the module specified // Error! function `public_function_in_my_mod` is private //my_mod::nested::public_function_in_my_mod(); // TODO ^ Try uncommenting this line // Private items of a module cannot be directly accessed, even if // nested in a public module: // Error! `private_function` is private //my_mod::private_function(); // TODO ^ Try uncommenting this line // Error! `private_function` is private //my_mod::nested::private_function(); // TODO ^ Try uncommenting this line // Error! `private_nested` is a private module //my_mod::private_nested::function(); // TODO ^ Try uncommenting this line // Error! `private_nested` is a private module //my_mod::private_nested::restricted_function(); // TODO ^ Try uncommenting this line } ``` ================================================ FILE: src/mod.md ================================================ # Modules Rust provides a powerful module system that can be used to hierarchically split code in logical units (modules), and manage visibility (public/private) between them. A module is a collection of items: functions, structs, traits, `impl` blocks, and even other modules. ================================================ FILE: src/primitives/array.md ================================================ # Arrays and Slices An array is a collection of objects of the same type `T`, stored in contiguous memory. Arrays are created using brackets `[]`, and their length, which is known at compile time, is part of their type signature `[T; length]`. Slices are similar to arrays, but their length is not known at compile time. Instead, a slice is a two-word object; the first word is a pointer to the data, the second word is the length of the slice. The word size is the same as usize, determined by the processor architecture, e.g. 64 bits on an x86-64. Slices can be used to borrow a section of an array and have the type signature `&[T]`. ```rust,editable,ignore,mdbook-runnable use std::mem; // This function borrows a slice. fn analyze_slice(slice: &[i32]) { println!("First element of the slice: {}", slice[0]); println!("The slice has {} elements", slice.len()); } fn main() { // Fixed-size array (type signature is superfluous). let xs: [i32; 5] = [1, 2, 3, 4, 5]; // All elements can be initialized to the same value. let ys: [i32; 500] = [0; 500]; // Indexing starts at 0. println!("First element of the array: {}", xs[0]); println!("Second element of the array: {}", xs[1]); // `len` returns the count of elements in the array. println!("Number of elements in array: {}", xs.len()); // Arrays are stack allocated. println!("Array occupies {} bytes", mem::size_of_val(&xs)); // Arrays can be automatically borrowed as slices. println!("Borrow the whole array as a slice."); analyze_slice(&xs); // Slices can point to a section of an array. // They are of the form [starting_index..ending_index]. // `starting_index` is the first position in the slice. // `ending_index` is one more than the last position in the slice. println!("Borrow a section of the array as a slice."); analyze_slice(&ys[1 .. 4]); // Example of empty slice `&[]`: let empty_array: [u32; 0] = []; assert_eq!(&empty_array, &[]); assert_eq!(&empty_array, &[][..]); // Same but more verbose // Arrays can be safely accessed using `.get`, which returns an // `Option`. This can be matched as shown below, or used with // `.expect()` if you would like the program to exit with a nice // message instead of happily continue. for i in 0..xs.len() + 1 { // Oops, one element too far! match xs.get(i) { Some(xval) => println!("{}: {}", i, xval), None => println!("Slow down! {} is too far!", i), } } // Out of bound indexing on array with constant value causes compile time error. //println!("{}", xs[5]); // Out of bound indexing on slice causes runtime error. //println!("{}", xs[..][5]); } ``` ================================================ FILE: src/primitives/literals.md ================================================ # Literals and operators Integers `1`, floats `1.2`, characters `'a'`, strings `"abc"`, booleans `true` and the unit type `()` can be expressed using literals. Integers can, alternatively, be expressed using hexadecimal, octal or binary notation using these prefixes respectively: `0x`, `0o` or `0b`. Underscores can be inserted in numeric literals to improve readability, e.g. `1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`. Rust also supports scientific [E-notation][enote], e.g. `1e6`, `7.6e-4`. The associated type is `f64`. We need to tell the compiler the type of the literals we use. For now, we'll use the `u32` suffix to indicate that the literal is an unsigned 32-bit integer, and the `i32` suffix to indicate that it's a signed 32-bit integer. The operators available and their precedence [in Rust][rust op-prec] are similar to other [C-like languages][op-prec]. ```rust,editable fn main() { // Integer addition println!("1 + 2 = {}", 1u32 + 2); // Integer subtraction println!("1 - 2 = {}", 1i32 - 2); // TODO ^ Try changing `1i32` to `1u32` to see why the type is important // Scientific notation println!("1e4 is {}, -2.5e-3 is {}", 1e4, -2.5e-3); // Short-circuiting boolean logic println!("true AND false is {}", true && false); println!("true OR false is {}", true || false); println!("NOT true is {}", !true); // Bitwise operations println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101); println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101); println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101); println!("1 << 5 is {}", 1u32 << 5); println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2); // Use underscores to improve readability! println!("One million is written as {}", 1_000_000u32); } ``` [enote]: https://en.wikipedia.org/wiki/Scientific_notation#E_notation [rust op-prec]: https://doc.rust-lang.org/reference/expressions.html#expression-precedence [op-prec]: https://en.wikipedia.org/wiki/Operator_precedence#Programming_languages ================================================ FILE: src/primitives/tuples.md ================================================ # Tuples A tuple is a collection of values of different types. Tuples are constructed using parentheses `()`, and each tuple itself is a value with type signature `(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions can use tuples to return multiple values, as tuples can hold any number of values. ```rust,editable // Tuples can be used as function arguments and as return values. fn reverse(pair: (i32, bool)) -> (bool, i32) { // `let` can be used to bind the members of a tuple to variables. let (int_param, bool_param) = pair; (bool_param, int_param) } // The following struct is for the activity. #[derive(Debug)] struct Matrix(f32, f32, f32, f32); fn main() { // A tuple with a bunch of different types. let long_tuple = (1u8, 2u16, 3u32, 4u64, -1i8, -2i16, -3i32, -4i64, 0.1f32, 0.2f64, 'a', true); // Values can be extracted from the tuple using tuple indexing. println!("Long tuple first value: {}", long_tuple.0); println!("Long tuple second value: {}", long_tuple.1); // Tuples can be tuple members. let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16); // Tuples are printable. println!("tuple of tuples: {:?}", tuple_of_tuples); // But long Tuples (more than 12 elements) cannot be printed. //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13); //println!("Too long tuple: {:?}", too_long_tuple); // TODO ^ Uncomment the above 2 lines to see the compiler error let pair = (1, true); println!("Pair is {:?}", pair); println!("The reversed pair is {:?}", reverse(pair)); // To create one element tuples, the comma is required to tell them apart // from a literal surrounded by parentheses. println!("One element tuple: {:?}", (5u32,)); println!("Just an integer: {:?}", (5u32)); // Tuples can be destructured to create bindings. let tuple = (1, "hello", 4.5, true); let (a, b, c, d) = tuple; println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d); let matrix = Matrix(1.1, 1.2, 2.1, 2.2); println!("{:?}", matrix); } ``` ### Activity 1. *Recap*: Add the `fmt::Display` trait to the `Matrix` struct in the above example, so that if you switch from printing the debug format `{:?}` to the display format `{}`, you see the following output: ```text ( 1.1 1.2 ) ( 2.1 2.2 ) ``` You may want to refer back to the example for [print display][print_display]. 2. Add a `transpose` function using the `reverse` function as a template, which accepts a matrix as an argument, and returns a matrix in which two elements have been swapped. For example: ```rust,ignore println!("Matrix:\n{}", matrix); println!("Transpose:\n{}", transpose(matrix)); ``` Results in the output: ```text Matrix: ( 1.1 1.2 ) ( 2.1 2.2 ) Transpose: ( 1.1 2.1 ) ( 1.2 2.2 ) ``` [print_display]: ../hello/print/print_display.md ================================================ FILE: src/primitives.md ================================================ # Primitives Rust provides access to a wide variety of `primitives`. A sample includes: ### Scalar Types * Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size) * Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer size) * Floating point: `f32`, `f64` * `char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each) * `bool` either `true` or `false` * The unit type `()`, whose only possible value is an empty tuple: `()` Despite the value of a unit type being a tuple, it is not considered a compound type because it does not contain multiple values. ### Compound Types * Arrays like `[1, 2, 3]` * Tuples like `(1, true)` Variables can always be *type annotated*. Numbers may additionally be annotated via a *suffix* or *by default*. Integers default to `i32` and floats to `f64`. Note that Rust can also infer types from context. ```rust,editable,ignore,mdbook-runnable fn main() { // Variables can be type annotated. let logical: bool = true; let a_float: f64 = 1.0; // Regular annotation let an_integer = 5i32; // Suffix annotation // Or a default will be used. let default_float = 3.0; // `f64` let default_integer = 7; // `i32` // A type can also be inferred from context. let mut inferred_type = 12; // Type i64 is inferred from another line. inferred_type = 4294967296i64; // A mutable variable's value can be changed. let mut mutable = 12; // Mutable `i32` mutable = 21; // Error! The type of a variable can't be changed. mutable = true; // Variables can be overwritten with shadowing. let mutable = true; /* Compound types - Array and Tuple */ // Array signature consists of Type T and length as [T; length]. let my_array: [i32; 5] = [1, 2, 3, 4, 5]; // Tuple is a collection of values of different types // and is constructed using parentheses (). let my_tuple = (5u32, 1u8, true, -5.04f32); } ``` ### See also: [the `std` library][std], [`mut`][mut], [`inference`][inference], and [`shadowing`][shadowing] [std]: https://doc.rust-lang.org/std/ [mut]: variable_bindings/mut.md [inference]: types/inference.md [shadowing]: variable_bindings/scope.md ================================================ FILE: src/scope/borrow/alias.md ================================================ # Aliasing Data can be immutably borrowed any number of times, but while immutably borrowed, the original data can't be mutably borrowed. On the other hand, only *one* mutable borrow is allowed at a time. The original data can be borrowed again only *after* the mutable reference has been used for the last time. ```rust,editable struct Point { x: i32, y: i32, z: i32 } fn main() { let mut point = Point { x: 0, y: 0, z: 0 }; let borrowed_point = &point; let another_borrow = &point; // Data can be accessed via the references and the original owner println!("Point has coordinates: ({}, {}, {})", borrowed_point.x, another_borrow.y, point.z); // Error! Can't borrow `point` as mutable because it's currently // borrowed as immutable. // let mutable_borrow = &mut point; // TODO ^ Try uncommenting this line // The borrowed values are used again here println!("Point has coordinates: ({}, {}, {})", borrowed_point.x, another_borrow.y, point.z); // The immutable references are no longer used for the rest of the code so // it is possible to reborrow with a mutable reference. let mutable_borrow = &mut point; // Change data via mutable reference mutable_borrow.x = 5; mutable_borrow.y = 2; mutable_borrow.z = 1; // Error! Can't borrow `point` as immutable because it's currently // borrowed as mutable. // let y = &point.y; // TODO ^ Try uncommenting this line // Error! Can't print because `println!` takes an immutable reference. // println!("Point Z coordinate is {}", point.z); // TODO ^ Try uncommenting this line // Ok! Mutable references can be passed as immutable to `println!` println!("Point has coordinates: ({}, {}, {})", mutable_borrow.x, mutable_borrow.y, mutable_borrow.z); // The mutable reference is no longer used for the rest of the code so it // is possible to reborrow let new_borrowed_point = &point; println!("Point now has coordinates: ({}, {}, {})", new_borrowed_point.x, new_borrowed_point.y, new_borrowed_point.z); } ``` ================================================ FILE: src/scope/borrow/mut.md ================================================ # Mutability Mutable data can be mutably borrowed using `&mut T`. This is called a *mutable reference* and gives read/write access to the borrower. In contrast, `&T` borrows the data via an immutable reference, and the borrower can read the data but not modify it: ```rust,editable,ignore,mdbook-runnable #[allow(dead_code)] #[derive(Clone, Copy)] struct Book { // `&'static str` is a reference to a string allocated in read only memory author: &'static str, title: &'static str, year: u32, } // This function takes a reference to a book fn borrow_book(book: &Book) { println!("I immutably borrowed {} - {} edition", book.title, book.year); } // This function takes a reference to a mutable book and changes `year` to 2014 fn new_edition(book: &mut Book) { book.year = 2014; println!("I mutably borrowed {} - {} edition", book.title, book.year); } fn main() { // Create an immutable Book named `immutabook` let immutabook = Book { // string literals have type `&'static str` author: "Douglas Hofstadter", title: "Gödel, Escher, Bach", year: 1979, }; // Create a mutable copy of `immutabook` and call it `mutabook` let mut mutabook = immutabook; // Immutably borrow an immutable object borrow_book(&immutabook); // Immutably borrow a mutable object borrow_book(&mutabook); // Borrow a mutable object as mutable new_edition(&mut mutabook); // Error! Cannot borrow an immutable object as mutable new_edition(&mut immutabook); // FIXME ^ Comment out this line } ``` ### See also: [`static`][static] [static]: ../lifetime/static_lifetime.md ================================================ FILE: src/scope/borrow/ref.md ================================================ # The ref pattern When doing pattern matching or destructuring via the `let` binding, the `ref` keyword can be used to take references to the fields of a struct/tuple. The example below shows a few instances where this can be useful: ```rust,editable #[derive(Clone, Copy)] struct Point { x: i32, y: i32 } fn main() { let c = 'Q'; // A `ref` borrow on the left side of an assignment is equivalent to // an `&` borrow on the right side. let ref ref_c1 = c; let ref_c2 = &c; println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2); let point = Point { x: 0, y: 0 }; // `ref` is also valid when destructuring a struct. let _copy_of_x = { // `ref_to_x` is a reference to the `x` field of `point`. let Point { x: ref ref_to_x, y: _ } = point; // Return a copy of the `x` field of `point`. *ref_to_x }; // A mutable copy of `point` let mut mutable_point = point; { // `ref` can be paired with `mut` to take mutable references. let Point { x: _, y: ref mut mut_ref_to_y } = mutable_point; // Mutate the `y` field of `mutable_point` via a mutable reference. *mut_ref_to_y = 1; } println!("point is ({}, {})", point.x, point.y); println!("mutable_point is ({}, {})", mutable_point.x, mutable_point.y); // A mutable tuple that includes a pointer let mut mutable_tuple = (Box::new(5u32), 3u32); { // Destructure `mutable_tuple` to change the value of `last`. let (_, ref mut last) = mutable_tuple; *last = 2u32; } println!("tuple is {:?}", mutable_tuple); } ``` ================================================ FILE: src/scope/borrow.md ================================================ # Borrowing Most of the time, we'd like to access data without taking ownership over it. To accomplish this, Rust uses a *borrowing* mechanism. Instead of passing objects by value (`T`), objects can be passed by reference (`&T`). The compiler statically guarantees (via its borrow checker) that references *always* point to valid objects. That is, while references to an object exist, the object cannot be destroyed. ```rust,editable,ignore,mdbook-runnable // This function takes ownership of a box and destroys it fn eat_box_i32(boxed_i32: Box) { println!("Destroying box that contains {}", boxed_i32); } // This function borrows an i32 fn borrow_i32(borrowed_i32: &i32) { println!("This int is: {}", borrowed_i32); } fn main() { // Create a boxed i32 in the heap, and an i32 on the stack // Remember: numbers can have arbitrary underscores added for readability // 5_i32 is the same as 5i32 let boxed_i32 = Box::new(5_i32); let stacked_i32 = 6_i32; // Borrow the contents of the box. Ownership is not taken, // so the contents can be borrowed again. borrow_i32(&boxed_i32); borrow_i32(&stacked_i32); { // Take a reference to the data contained inside the box let _ref_to_i32: &i32 = &boxed_i32; // Error! // Can't destroy `boxed_i32` while the inner value is borrowed later in scope. eat_box_i32(boxed_i32); // FIXME ^ Comment out this line // Attempt to borrow `_ref_to_i32` after inner value is destroyed borrow_i32(_ref_to_i32); // `_ref_to_i32` goes out of scope and is no longer borrowed. } // `boxed_i32` can now give up ownership to `eat_box_i32` and be destroyed eat_box_i32(boxed_i32); } ``` ================================================ FILE: src/scope/lifetime/elision.md ================================================ # Elision Some lifetime patterns are overwhelmingly common and so the borrow checker will allow you to omit them to save typing and to improve readability. This is known as elision. Elision exists in Rust solely because these patterns are common. The following code shows a few examples of elision. For a more comprehensive description of elision, see [lifetime elision][elision] in the book. ```rust,editable // `elided_input` and `annotated_input` essentially have identical signatures // because the lifetime of `elided_input` is inferred by the compiler: fn elided_input(x: &i32) { println!("`elided_input`: {}", x); } fn annotated_input<'a>(x: &'a i32) { println!("`annotated_input`: {}", x); } // Similarly, `elided_pass` and `annotated_pass` have identical signatures // because the lifetime is added implicitly to `elided_pass`: fn elided_pass(x: &i32) -> &i32 { x } fn annotated_pass<'a>(x: &'a i32) -> &'a i32 { x } fn main() { let x = 3; elided_input(&x); annotated_input(&x); println!("`elided_pass`: {}", elided_pass(&x)); println!("`annotated_pass`: {}", annotated_pass(&x)); } ``` ### See also: [elision][elision] [elision]: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision ================================================ FILE: src/scope/lifetime/explicit.md ================================================ # Explicit annotation The borrow checker uses explicit lifetime annotations to determine how long references should be valid. In cases where lifetimes are not elided[^1], Rust requires explicit annotations to determine what the lifetime of a reference should be. The syntax for explicitly annotating a lifetime uses an apostrophe character as follows: ```rust,ignore foo<'a> // `foo` has a lifetime parameter `'a` ``` Similar to [closures][anonymity], using lifetimes requires generics. Additionally, this lifetime syntax indicates that the lifetime of `foo` may not exceed that of `'a`. Explicit annotation of a type has the form `&'a T` where `'a` has already been introduced. In cases with multiple lifetimes, the syntax is similar: ```rust,ignore foo<'a, 'b> // `foo` has lifetime parameters `'a` and `'b` ``` In this case, the lifetime of `foo` cannot exceed that of either `'a` *or* `'b`. See the following example for explicit lifetime annotation in use: ```rust,editable,ignore,mdbook-runnable // `print_refs` takes two references to `i32` which have different // lifetimes `'a` and `'b`. These two lifetimes must both be at // least as long as the function `print_refs`. fn print_refs<'a, 'b>(x: &'a i32, y: &'b i32) { println!("x is {} and y is {}", x, y); } // A function which takes no arguments, but has a lifetime parameter `'a`. fn failed_borrow<'a>() { let _x = 12; // ERROR: `_x` does not live long enough let _y: &'a i32 = &_x; // Attempting to use the lifetime `'a` as an explicit type annotation // inside the function will fail because the lifetime of `&_x` is shorter // than that of `_y`. A short lifetime cannot be coerced into a longer one. } fn main() { // Create variables to be borrowed below. let (four, nine) = (4, 9); // Borrows (`&`) of both variables are passed into the function. print_refs(&four, &nine); // Any input which is borrowed must outlive the borrower. // In other words, the lifetime of `four` and `nine` must // be longer than that of `print_refs`. failed_borrow(); // `failed_borrow` contains no references to force `'a` to be // longer than the lifetime of the function, but `'a` is longer. // Because the lifetime is never constrained, it defaults to `'static`. } ``` [^1]: [elision] implicitly annotates lifetimes and so is different. ### See also: [generics][generics] and [closures][closures] [anonymity]: ../../fn/closures/anonymity.md [closures]: ../../fn/closures.md [elision]: elision.md [generics]: ../../generics.md ================================================ FILE: src/scope/lifetime/fn.md ================================================ # Functions Ignoring [elision], function signatures with lifetimes have a few constraints: * any reference *must* have an annotated lifetime. * any reference being returned *must* have the same lifetime as an input or be `static`. Additionally, note that returning references without input is banned if it would result in returning references to invalid data. The following example shows off some valid forms of functions with lifetimes: ```rust,editable // One input reference with lifetime `'a` which must live // at least as long as the function. fn print_one<'a>(x: &'a i32) { println!("`print_one`: x is {}", x); } // Mutable references are possible with lifetimes as well. fn add_one<'a>(x: &'a mut i32) { *x += 1; } // Multiple elements with different lifetimes. In this case, it // would be fine for both to have the same lifetime `'a`, but // in more complex cases, different lifetimes may be required. fn print_multi<'a, 'b>(x: &'a i32, y: &'b i32) { println!("`print_multi`: x is {}, y is {}", x, y); } // Returning references that have been passed in is acceptable. // However, the correct lifetime must be returned. fn pass_x<'a, 'b>(x: &'a i32, _: &'b i32) -> &'a i32 { x } //fn invalid_output<'a>() -> &'a String { &String::from("foo") } // The above is invalid: `'a` must live longer than the function. // Here, `&String::from("foo")` would create a `String`, followed by a // reference. Then the data is dropped upon exiting the scope, leaving // a reference to invalid data to be returned. fn main() { let x = 7; let y = 9; print_one(&x); print_multi(&x, &y); let z = pass_x(&x, &y); print_one(z); let mut t = 3; add_one(&mut t); print_one(&t); } ``` ### See also: [Functions][fn] [fn]: ../../fn.md [elision]: elision.md ================================================ FILE: src/scope/lifetime/lifetime_bounds.md ================================================ # Bounds Just like generic types can be bounded, lifetimes (themselves generic) use bounds as well. The `:` character has a slightly different meaning here, but `+` is the same. Note how the following read: 1. `T: 'a`: *All* references in `T` must outlive lifetime `'a`. 2. `T: Trait + 'a`: Type `T` must implement trait `Trait` and *all* references in `T` must outlive `'a`. The example below shows the above syntax in action used after keyword `where`: ```rust,editable use std::fmt::Debug; // Trait to bound with. #[derive(Debug)] struct Ref<'a, T: 'a>(&'a T); // `Ref` contains a reference to a generic type `T` that has // some lifetime `'a` unknown by `Ref`. `T` is bounded such that any // *references* in `T` must outlive `'a`. Additionally, the lifetime // of `Ref` may not exceed `'a`. // A generic function which prints using the `Debug` trait. fn print(t: T) where T: Debug { println!("`print`: t is {:?}", t); } // Here a reference to `T` is taken where `T` implements // `Debug` and all *references* in `T` outlive `'a`. In // addition, `'a` must outlive the function. fn print_ref<'a, T>(t: &'a T) where T: Debug + 'a { println!("`print_ref`: t is {:?}", t); } fn main() { let x = 7; let ref_x = Ref(&x); print_ref(&ref_x); print(ref_x); } ``` ### See also: [generics][generics], [bounds in generics][bounds], and [multiple bounds in generics][multibounds] [generics]: ../../generics.md [bounds]: ../../generics/bounds.md [multibounds]: ../../generics/multi_bounds.md ================================================ FILE: src/scope/lifetime/lifetime_coercion.md ================================================ # Coercion A longer lifetime can be coerced into a shorter one so that it works inside a scope it normally wouldn't work in. This comes in the form of inferred coercion by the Rust compiler, and also in the form of declaring a lifetime difference: ```rust,editable // Here, Rust infers a lifetime that is as short as possible. // The two references are then coerced to that lifetime. fn multiply<'a>(first: &'a i32, second: &'a i32) -> i32 { first * second } // `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`. // Here, we take in an `&'a i32` and return a `&'b i32` as a result of coercion. fn choose_first<'a: 'b, 'b>(first: &'a i32, _: &'b i32) -> &'b i32 { first } fn main() { let first = 2; // Longer lifetime { let second = 3; // Shorter lifetime println!("The product is {}", multiply(&first, &second)); println!("{} is the first", choose_first(&first, &second)); }; } ``` ================================================ FILE: src/scope/lifetime/methods.md ================================================ # Methods Methods are annotated similarly to functions: ```rust,editable struct Owner(i32); impl Owner { // Annotate lifetimes as in a standalone function. fn add_one<'a>(&'a mut self) { self.0 += 1; } fn print<'a>(&'a self) { println!("`print`: {}", self.0); } } fn main() { let mut owner = Owner(18); owner.add_one(); owner.print(); } ``` ### See also: [methods] [methods]: ../../fn/methods.md ================================================ FILE: src/scope/lifetime/static_lifetime.md ================================================ # Static Rust has a few reserved lifetime names. One of those is `'static`. You might encounter it in two situations: ```rust, ignore // A reference with 'static lifetime: let s: &'static str = "hello world"; // 'static as part of a trait bound: fn generic(x: T) where T: 'static {} ``` Both are related but subtly different and this is a common source for confusion when learning Rust. Here are some examples for each situation: ## Reference lifetime As a reference lifetime `'static` indicates that the data pointed to by the reference lives for the remaining lifetime of the running program. It can still be coerced to a shorter lifetime. There are two common ways to make a variable with `'static` lifetime, and both are stored in the read-only memory of the binary: * Make a constant with the `static` declaration. * Make a `string` literal which has type: `&'static str`. See the following example for a display of each method: ```rust,editable // Make a constant with `'static` lifetime. static NUM: i32 = 18; // Returns a reference to `NUM` where its `'static` // lifetime is coerced to that of the input argument. fn coerce_static<'a>(_: &'a i32) -> &'a i32 { &NUM } fn main() { { // Make a `string` literal and print it: let static_string = "I'm in read-only memory"; println!("static_string: {}", static_string); // When `static_string` goes out of scope, the reference // can no longer be used, but the data remains in the binary. } { // Make an integer to use for `coerce_static`: let lifetime_num = 9; // Coerce `NUM` to lifetime of `lifetime_num`: let coerced_static = coerce_static(&lifetime_num); println!("coerced_static: {}", coerced_static); } println!("NUM: {} stays accessible!", NUM); } ``` Since `'static` references only need to be valid for the _remainder_ of a program's life, they can be created while the program is executed. Just to demonstrate, the below example uses [`Box::leak`](https://doc.rust-lang.org/std/boxed/struct.Box.html#method.leak) to dynamically create `'static` references. In that case it definitely doesn't live for the entire duration, but only from the leaking point onward. ```rust,editable,compile_fail extern crate rand; use rand::Fill; fn random_vec() -> &'static [u64; 100] { let mut rng = rand::rng(); let mut boxed = Box::new([0; 100]); boxed.fill(&mut rng); Box::leak(boxed) } fn main() { let first: &'static [u64; 100] = random_vec(); let second: &'static [u64; 100] = random_vec(); assert_ne!(first, second) } ``` ## Trait bound As a trait bound, it means the type does not contain any non-static references. Eg. the receiver can hold on to the type for as long as they want and it will never become invalid until they drop it. It's important to understand this means that any owned data always passes a `'static` lifetime bound, but a reference to that owned data generally does not: ```rust,editable,compile_fail use std::fmt::Debug; fn print_it(input: impl Debug + 'static) { println!("'static value passed in is: {:?}", input); } fn main() { // i is owned and contains no references, thus it's 'static: let i = 5; print_it(i); // oops, &i only has the lifetime defined by the scope of // main(), so it's not 'static: print_it(&i); } ``` The compiler will tell you: ```ignore error[E0597]: `i` does not live long enough --> src/lib.rs:15:15 | 15 | print_it(&i); | ---------^^-- | | | | | borrowed value does not live long enough | argument requires that `i` is borrowed for `'static` 16 | } | - `i` dropped here while still borrowed ``` ### See also: [`'static` constants][static_const] [static_const]: ../../custom_types/constants.md ================================================ FILE: src/scope/lifetime/struct.md ================================================ # Structs Annotation of lifetimes in structures are also similar to functions: ```rust,editable // A type `Borrowed` which houses a reference to an // `i32`. The reference to `i32` must outlive `Borrowed`. #[derive(Debug)] struct Borrowed<'a>(&'a i32); // Similarly, both references here must outlive this structure. #[derive(Debug)] struct NamedBorrowed<'a> { x: &'a i32, y: &'a i32, } // An enum which is either an `i32` or a reference to one. #[derive(Debug)] enum Either<'a> { Num(i32), Ref(&'a i32), } fn main() { let x = 18; let y = 15; let single = Borrowed(&x); let double = NamedBorrowed { x: &x, y: &y }; let reference = Either::Ref(&x); let number = Either::Num(y); println!("x is borrowed in {:?}", single); println!("x and y are borrowed in {:?}", double); println!("x is borrowed in {:?}", reference); println!("y is *not* borrowed in {:?}", number); } ``` ### See also: [`struct`s][structs] [structs]: ../../custom_types/structs.md ================================================ FILE: src/scope/lifetime/trait.md ================================================ # Traits Annotation of lifetimes in trait methods basically are similar to functions. Note that `impl` may have annotation of lifetimes too. ```rust,editable // A struct with annotation of lifetimes. #[derive(Debug)] struct Borrowed<'a> { x: &'a i32, } // Annotate lifetimes to impl. impl<'a> Default for Borrowed<'a> { fn default() -> Self { Self { x: &10, } } } fn main() { let b: Borrowed = Default::default(); println!("b is {:?}", b); } ``` ### See also: [`trait`s][trait] [trait]: ../../trait.md ================================================ FILE: src/scope/lifetime.md ================================================ # Lifetimes A *lifetime* is a construct the compiler (or more specifically, its *borrow checker*) uses to ensure all borrows are valid. Specifically, a variable's lifetime begins when it is created and ends when it is destroyed. While lifetimes and scopes are often referred to together, they are not the same. Take, for example, the case where we borrow a variable via `&`. The borrow has a lifetime that is determined by where it is declared. As a result, the borrow is valid as long as it ends before the lender is destroyed. However, the scope of the borrow is determined by where the reference is used. In the following example and in the rest of this section, we will see how lifetimes relate to scopes, as well as how the two differ. ```rust,editable // Lifetimes are annotated below with lines denoting the creation // and destruction of each variable. // `i` has the longest lifetime because its scope entirely encloses // both `borrow1` and `borrow2`. The duration of `borrow1` compared // to `borrow2` is irrelevant since they are disjoint. fn main() { let i = 3; // Lifetime for `i` starts. ────────────────┐ // │ { // │ let borrow1 = &i; // `borrow1` lifetime starts. ──┐│ // ││ println!("borrow1: {}", borrow1); // ││ } // `borrow1` ends. ─────────────────────────────────┘│ // │ // │ { // │ let borrow2 = &i; // `borrow2` lifetime starts. ──┐│ // ││ println!("borrow2: {}", borrow2); // ││ } // `borrow2` ends. ─────────────────────────────────┘│ // │ } // Lifetime ends. ─────────────────────────────────────┘ ``` Note that no names or types are assigned to label lifetimes. This restricts how lifetimes will be able to be used as we will see. ================================================ FILE: src/scope/move/mut.md ================================================ # Mutability Mutability of data can be changed when ownership is transferred. ```rust,editable fn main() { let immutable_box = Box::new(5u32); println!("immutable_box contains {}", immutable_box); // Mutability error //*immutable_box = 4; // *Move* the box, changing the ownership (and mutability) let mut mutable_box = immutable_box; println!("mutable_box contains {}", mutable_box); // Modify the contents of the box *mutable_box = 4; println!("mutable_box now contains {}", mutable_box); } ``` ================================================ FILE: src/scope/move/partial_move.md ================================================ # Partial moves Within the [destructuring] of a single variable, both `by-move` and `by-reference` pattern bindings can be used at the same time. Doing this will result in a _partial move_ of the variable, which means that parts of the variable will be moved while other parts stay. In such a case, the parent variable cannot be used afterwards as a whole, however the parts that are only referenced (and not moved) can still be used. Note that types that implement the [`Drop` trait][droptrait] cannot be partially moved from, because its `drop` method would use it afterwards as a whole. ```rust,editable fn main() { #[derive(Debug)] struct Person { name: String, age: Box, } // Error! cannot move out of a type which implements the `Drop` trait //impl Drop for Person { // fn drop(&mut self) { // println!("Dropping the person struct {:?}", self) // } //} // TODO ^ Try uncommenting these lines let person = Person { name: String::from("Alice"), age: Box::new(20), }; // `name` is moved out of person, but `age` is referenced let Person { name, ref age } = person; println!("The person's age is {}", age); println!("The person's name is {}", name); // Error! borrow of partially moved value: `person` partial move occurs //println!("The person struct is {:?}", person); // `person` cannot be used but `person.age` can be used as it is not moved println!("The person's age from person struct is {}", person.age); } ``` (In this example, we store the `age` variable on the heap to illustrate the partial move: deleting `ref` in the above code would give an error as the ownership of `person.age` would be moved to the variable `age`. If `Person.age` were stored on the stack, `ref` would not be required as the definition of `age` would copy the data from `person.age` without moving it.) ### See also: [destructuring][destructuring] [droptrait]: ../../trait/drop.md [destructuring]: ../../flow_control/match/destructuring.md ================================================ FILE: src/scope/move.md ================================================ # Ownership and moves Because variables are in charge of freeing their own resources, **resources can only have one owner**. This prevents resources from being freed more than once. Note that not all variables own resources (e.g. [references]). When doing assignments (`let x = y`) or passing function arguments by value (`foo(x)`), the *ownership* of the resources is transferred. In Rust-speak, this is known as a *move*. After moving resources, the previous owner can no longer be used. This avoids creating dangling pointers. ```rust,editable // This function takes ownership of the heap allocated memory fn destroy_box(c: Box) { println!("Destroying a box that contains {}", c); // `c` is destroyed and the memory freed } fn main() { // _Stack_ allocated integer let x = 5u32; // *Copy* `x` into `y` - no resources are moved let y = x; // Both values can be independently used println!("x is {}, and y is {}", x, y); // `a` is a pointer to a _heap_ allocated integer let a = Box::new(5i32); println!("a contains: {}", a); // *Move* `a` into `b` let b = a; // The pointer address of `a` is copied (not the data) into `b`. // Both are now pointers to the same heap allocated data, but // `b` now owns it. // Error! `a` can no longer access the data, because it no longer owns the // heap memory //println!("a contains: {}", a); // TODO ^ Try uncommenting this line // This function takes ownership of the heap allocated memory from `b` destroy_box(b); // Since the heap memory has been freed at this point, this action would // result in dereferencing freed memory, but it's forbidden by the compiler // Error! Same reason as the previous Error //println!("b contains: {}", b); // TODO ^ Try uncommenting this line } ``` [references]: ../flow_control/match/destructuring/destructure_pointers.md ================================================ FILE: src/scope/raii.md ================================================ # RAII Variables in Rust do more than just hold data in the stack: they also *own* resources, e.g. `Box` owns memory in the heap. Rust enforces [RAII][raii] (Resource Acquisition Is Initialization), so whenever an object goes out of scope, its destructor is called and its owned resources are freed. This behavior shields against *resource leak* bugs, so you'll never have to manually free memory or worry about memory leaks again! Here's a quick showcase: ```rust,editable // raii.rs fn create_box() { // Allocate an integer on the heap let _box1 = Box::new(3i32); // `_box1` is destroyed here, and memory gets freed } fn main() { // Allocate an integer on the heap let _box2 = Box::new(5i32); // A nested scope: { // Allocate an integer on the heap let _box3 = Box::new(4i32); // `_box3` is destroyed here, and memory gets freed } // Creating lots of boxes just for fun // There's no need to manually free memory! for _ in 0u32..1_000 { create_box(); } // `_box2` is destroyed here, and memory gets freed } ``` Of course, we can double check for memory errors using [`valgrind`][valgrind]: ```shell $ rustc raii.rs && valgrind ./raii ==26873== Memcheck, a memory error detector ==26873== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al. ==26873== Using Valgrind-3.9.0 and LibVEX; rerun with -h for copyright info ==26873== Command: ./raii ==26873== ==26873== ==26873== HEAP SUMMARY: ==26873== in use at exit: 0 bytes in 0 blocks ==26873== total heap usage: 1,013 allocs, 1,013 frees, 8,696 bytes allocated ==26873== ==26873== All heap blocks were freed -- no leaks are possible ==26873== ==26873== For counts of detected and suppressed errors, rerun with: -v ==26873== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2) ``` No leaks here! ## Destructor The notion of a destructor in Rust is provided through the [`Drop`] trait. The destructor is called when the resource goes out of scope. This trait is not required to be implemented for every type, only implement it for your type if you require its own destructor logic. Run the below example to see how the [`Drop`] trait works. When the variable in the `main` function goes out of scope the custom destructor will be invoked. ```rust,editable struct ToDrop; impl Drop for ToDrop { fn drop(&mut self) { println!("ToDrop is being dropped"); } } fn main() { let x = ToDrop; println!("Made a ToDrop!"); } ``` ### See also: [Box][box] [raii]: https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization [box]: ../std/box.md [valgrind]: http://valgrind.org/info/ [`Drop`]: https://doc.rust-lang.org/std/ops/trait.Drop.html ================================================ FILE: src/scope.md ================================================ # Scoping rules Scopes play an important part in ownership, borrowing, and lifetimes. That is, they indicate to the compiler when borrows are valid, when resources can be freed, and when variables are created or destroyed. ================================================ FILE: src/std/arc.md ================================================ # Arc When shared ownership between threads is needed, `Arc`(Atomically Reference Counted) can be used. This struct, via the `Clone` implementation can create a reference pointer for the location of a value in the memory heap while increasing the reference counter. As it shares ownership between threads, when the last reference pointer to a value is out of scope, the variable is dropped. ```rust,editable use std::time::Duration; use std::sync::Arc; use std::thread; fn main() { // This variable declaration is where its value is specified. let apple = Arc::new("the same apple"); for _ in 0..10 { // Here there is no value specification as it is a pointer to a // reference in the memory heap. let apple = Arc::clone(&apple); thread::spawn(move || { // As Arc was used, threads can be spawned using the value allocated // in the Arc variable pointer's location. println!("{:?}", apple); }); } // Make sure all Arc instances are printed from spawned threads. thread::sleep(Duration::from_secs(1)); } ``` ================================================ FILE: src/std/box.md ================================================ # Box, stack and heap All values in Rust are stack allocated by default. Values can be *boxed* (allocated on the heap) by creating a `Box`. A box is a smart pointer to a heap allocated value of type `T`. When a box goes out of scope, its destructor is called, the inner object is destroyed, and the memory on the heap is freed. Boxed values can be dereferenced using the `*` operator; this removes one layer of indirection. ```rust,editable use std::mem; #[allow(dead_code)] #[derive(Debug, Clone, Copy)] struct Point { x: f64, y: f64, } // A Rectangle can be specified by where its top left and bottom right // corners are in space #[allow(dead_code)] struct Rectangle { top_left: Point, bottom_right: Point, } fn origin() -> Point { Point { x: 0.0, y: 0.0 } } fn boxed_origin() -> Box { // Allocate this point on the heap, and return a pointer to it Box::new(Point { x: 0.0, y: 0.0 }) } fn main() { // (all the type annotations are superfluous) // Stack allocated variables let point: Point = origin(); let rectangle: Rectangle = Rectangle { top_left: origin(), bottom_right: Point { x: 3.0, y: -4.0 } }; // Heap allocated rectangle let boxed_rectangle: Box = Box::new(Rectangle { top_left: origin(), bottom_right: Point { x: 3.0, y: -4.0 }, }); // The output of functions can be boxed let boxed_point: Box = Box::new(origin()); // Double indirection let box_in_a_box: Box> = Box::new(boxed_origin()); println!("Point occupies {} bytes on the stack", mem::size_of_val(&point)); println!("Rectangle occupies {} bytes on the stack", mem::size_of_val(&rectangle)); // box size == pointer size println!("Boxed point occupies {} bytes on the stack", mem::size_of_val(&boxed_point)); println!("Boxed rectangle occupies {} bytes on the stack", mem::size_of_val(&boxed_rectangle)); println!("Boxed box occupies {} bytes on the stack", mem::size_of_val(&box_in_a_box)); // Copy the data contained in `boxed_point` into `unboxed_point` let unboxed_point: Point = *boxed_point; println!("Unboxed point occupies {} bytes on the stack", mem::size_of_val(&unboxed_point)); } ``` ================================================ FILE: src/std/hash/alt_key_types.md ================================================ # Alternate/custom key types Any type that implements the `Eq` and `Hash` traits can be a key in `HashMap`. This includes: * `bool` (though not very useful since there are only two possible keys) * `int`, `uint`, and all variations thereof * `String` and `&str` (protip: you can have a `HashMap` keyed by `String` and call `.get()` with an `&str`) Note that `f32` and `f64` do *not* implement `Hash`, likely because [floating-point precision errors][floating] would make using them as hashmap keys horribly error-prone. All collection classes implement `Eq` and `Hash` if their contained type also respectively implements `Eq` and `Hash`. For example, `Vec` will implement `Hash` if `T` implements `Hash`. You can easily implement `Eq` and `Hash` for a custom type with just one line: `#[derive(PartialEq, Eq, Hash)]` The compiler will do the rest. If you want more control over the details, you can implement `Eq` and/or `Hash` yourself. This guide will not cover the specifics of implementing `Hash`. To play around with using a `struct` in `HashMap`, let's try making a very simple user logon system: ```rust,editable use std::collections::HashMap; // Eq requires that you derive PartialEq on the type. #[derive(PartialEq, Eq, Hash)] struct Account<'a>{ username: &'a str, password: &'a str, } struct AccountInfo<'a>{ name: &'a str, email: &'a str, } type Accounts<'a> = HashMap, AccountInfo<'a>>; fn try_logon<'a>(accounts: &Accounts<'a>, username: &'a str, password: &'a str){ println!("Username: {}", username); println!("Password: {}", password); println!("Attempting logon..."); let logon = Account { username, password, }; match accounts.get(&logon) { Some(account_info) => { println!("Successful logon!"); println!("Name: {}", account_info.name); println!("Email: {}", account_info.email); }, _ => println!("Login failed!"), } } fn main(){ let mut accounts: Accounts = HashMap::new(); let account = Account { username: "j.everyman", password: "password123", }; let account_info = AccountInfo { name: "John Everyman", email: "j.everyman@email.com", }; accounts.insert(account, account_info); try_logon(&accounts, "j.everyman", "psasword123"); try_logon(&accounts, "j.everyman", "password123"); } ``` [hash]: https://en.wikipedia.org/wiki/Hash_function [floating]: https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems ================================================ FILE: src/std/hash/hashset.md ================================================ # HashSet Consider a `HashSet` as a `HashMap` where we just care about the keys ( `HashSet` is, in actuality, just a wrapper around `HashMap`). "What's the point of that?" you ask. "I could just store the keys in a `Vec`." A `HashSet`'s unique feature is that it is guaranteed to not have duplicate elements. That's the contract that any set collection fulfills. `HashSet` is just one implementation. (see also: [`BTreeSet`][treeset]) If you insert a value that is already present in the `HashSet`, (i.e. the new value is equal to the existing and they both have the same hash), then the new value will replace the old. This is great for when you never want more than one of something, or when you want to know if you've already got something. But sets can do more than that. Sets have 4 primary operations (all of the following calls return an iterator): * `union`: get all the unique elements in both sets. * `difference`: get all the elements that are in the first set but not the second. * `intersection`: get all the elements that are only in *both* sets. * `symmetric_difference`: get all the elements that are in one set or the other, but *not* both. Try all of these in the following example: ```rust,editable,ignore,mdbook-runnable use std::collections::HashSet; fn main() { let mut a: HashSet = vec![1i32, 2, 3].into_iter().collect(); let mut b: HashSet = vec![2i32, 3, 4].into_iter().collect(); assert!(a.insert(4)); assert!(a.contains(&4)); // `HashSet::insert()` returns false if // there was a value already present. assert!(b.insert(4), "Value 4 is already in set B!"); // FIXME ^ Comment out this line b.insert(5); // If a collection's element type implements `Debug`, // then the collection implements `Debug`. // It usually prints its elements in the format `[elem1, elem2, ...]` println!("A: {:?}", a); println!("B: {:?}", b); // Print [1, 2, 3, 4, 5] in arbitrary order println!("Union: {:?}", a.union(&b).collect::>()); // This should print [1] println!("Difference: {:?}", a.difference(&b).collect::>()); // Print [2, 3, 4] in arbitrary order. println!("Intersection: {:?}", a.intersection(&b).collect::>()); // Print [1, 5] println!("Symmetric Difference: {:?}", a.symmetric_difference(&b).collect::>()); } ``` (Examples are adapted from the [documentation.][hash-set]) [treeset]: https://doc.rust-lang.org/std/collections/struct.BTreeSet.html [hash-set]: https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.difference ================================================ FILE: src/std/hash.md ================================================ # HashMap Where vectors store values by an integer index, `HashMap`s store values by key. `HashMap` keys can be booleans, integers, strings, or any other type that implements the `Eq` and `Hash` traits. More on this in the next section. Like vectors, `HashMap`s are growable, but HashMaps can also shrink themselves when they have excess space. You can create a HashMap with a certain starting capacity using `HashMap::with_capacity(uint)`, or use `HashMap::new()` to get a HashMap with a default initial capacity (recommended). ```rust,editable use std::collections::HashMap; fn call(number: &str) -> &str { match number { "798-1364" => "We're sorry, the call cannot be completed as dialed. Please hang up and try again.", "645-7689" => "Hello, this is Mr. Awesome's Pizza. My name is Fred. What can I get for you today?", _ => "Hi! Who is this again?" } } fn main() { let mut contacts = HashMap::new(); contacts.insert("Daniel", "798-1364"); contacts.insert("Ashley", "645-7689"); contacts.insert("Katie", "435-8291"); contacts.insert("Robert", "956-1745"); // Takes a reference and returns Option<&V> match contacts.get(&"Daniel") { Some(&number) => println!("Calling Daniel: {}", call(number)), _ => println!("Don't have Daniel's number."), } // `HashMap::insert()` returns `None` // if the inserted value is new, `Some(value)` otherwise contacts.insert("Daniel", "164-6743"); match contacts.get(&"Ashley") { Some(&number) => println!("Calling Ashley: {}", call(number)), _ => println!("Don't have Ashley's number."), } contacts.remove(&"Ashley"); // `HashMap::iter()` returns an iterator that yields // (&'a key, &'a value) pairs in arbitrary order. for (contact, &number) in contacts.iter() { println!("Calling {}: {}", contact, call(number)); } } ``` For more information on how hashing and hash maps (sometimes called hash tables) work, have a look at [Hash Table Wikipedia][wiki-hash] [wiki-hash]: https://en.wikipedia.org/wiki/Hash_table ================================================ FILE: src/std/option.md ================================================ # `Option` Sometimes it's desirable to catch the failure of some parts of a program instead of calling `panic!`; this can be accomplished using the `Option` enum. The `Option` enum has two variants: * `None`, to indicate failure or lack of value, and * `Some(value)`, a tuple struct that wraps a `value` with type `T`. ```rust,editable,ignore,mdbook-runnable // An integer division that doesn't `panic!` fn checked_division(dividend: i32, divisor: i32) -> Option { if divisor == 0 { // Failure is represented as the `None` variant None } else { // Result is wrapped in a `Some` variant Some(dividend / divisor) } } // This function handles a division that may not succeed fn try_division(dividend: i32, divisor: i32) { // `Option` values can be pattern matched, just like other enums match checked_division(dividend, divisor) { None => println!("{} / {} failed!", dividend, divisor), Some(quotient) => { println!("{} / {} = {}", dividend, divisor, quotient) }, } } fn main() { try_division(4, 2); try_division(1, 0); // Binding `None` to a variable needs to be type annotated let none: Option = None; let _equivalent_none = None::; let optional_float = Some(0f32); // Unwrapping a `Some` variant will extract the value wrapped. println!("{:?} unwraps to {:?}", optional_float, optional_float.unwrap()); // Unwrapping a `None` variant will `panic!` println!("{:?} unwraps to {:?}", none, none.unwrap()); } ``` ================================================ FILE: src/std/panic.md ================================================ # `panic!` The `panic!` macro can be used to generate a panic and start unwinding its stack. While unwinding, the runtime will take care of freeing all the resources *owned* by the thread by calling the destructor of all its objects. Since we are dealing with programs with only one thread, `panic!` will cause the program to report the panic message and exit. ```rust,editable,ignore,mdbook-runnable // Re-implementation of integer division (/) fn division(dividend: i32, divisor: i32) -> i32 { if divisor == 0 { // Division by zero triggers a panic panic!("division by zero"); } else { dividend / divisor } } // The `main` task fn main() { // Heap allocated integer let _x = Box::new(0i32); // This operation will trigger a task failure division(3, 0); println!("This point won't be reached!"); // `_x` should get destroyed at this point } ``` Let's check that `panic!` doesn't leak memory. ```shell $ rustc panic.rs && valgrind ./panic ==4401== Memcheck, a memory error detector ==4401== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al. ==4401== Using Valgrind-3.10.0.SVN and LibVEX; rerun with -h for copyright info ==4401== Command: ./panic ==4401== thread '