diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 8ae1302..778465f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -25,95 +25,94 @@ jobs: - name: Test code snippets run: mdbook test - # TODO: Activate when first translation is available - # i18n-helpers: - # runs-on: ubuntu-latest - # steps: - # - name: Checkout - # uses: actions/checkout@v3 - - # - name: Install Gettext - # run: sudo apt install gettext - - # - name: Setup Rust cache - # uses: ./.github/workflows/setup-rust-cache - - # - name: Install mdbook - # uses: ./.github/workflows/install-mdbook - - # - name: Generate po/messages.pot - # run: mdbook build -d po - # env: - # MDBOOK_OUTPUT: '{"xgettext": {"pot-file": "messages.pot"}}' - - # - name: Test messages.pot - # run: msgfmt --statistics -o /dev/null po/messages.pot - - # - name: Expand includes without translation - # run: mdbook build -d expanded - # env: - # MDBOOK_OUTPUT: '{"markdown": {}}' - - # - name: Expand includes with no-op translation - # run: mdbook build -d no-op - # env: - # MDBOOK_OUTPUT: '{"markdown": {}}' - # MDBOOK_PREPROCESSOR__GETTEXT__PO_FILE: po/messages.pot - - # - name: Compare no translation to no-op translation - # run: diff --color=always --unified --recursive expanded no-op - - # find-translations: - # runs-on: ubuntu-latest - # outputs: - # languages: ${{ steps.find-translations.outputs.languages }} - # steps: - # - name: Checkout - # uses: actions/checkout@v3 - - # - name: Find translations - # id: find-translations - # shell: python - # run: | - # import os, json, pathlib - # languages = [p.stem for p in pathlib.Path("po").iterdir() if p.suffix == ".po"] - # github_output = open(os.environ["GITHUB_OUTPUT"], "a") - # github_output.write("languages=") - # json.dump(sorted(languages), github_output) - - # translations: - # runs-on: ubuntu-latest - # needs: - # - find-translations - # strategy: - # matrix: - # language: ${{ fromJSON(needs.find-translations.outputs.languages) }} - # env: - # MDBOOK_BOOK__LANGUAGE: ${{ matrix.language }} - # steps: - # - name: Checkout - # uses: actions/checkout@v3 - - # - name: Install Gettext - # run: sudo apt install gettext - - # - name: Setup Rust cache - # uses: ./.github/workflows/setup-rust-cache - - # - name: Install mdbook - # uses: ./.github/workflows/install-mdbook - - # - name: Test ${{ matrix.language }} translation - # run: msgfmt --statistics -o /dev/null po/${{ matrix.language }}.po - - # - name: Build book with ${{ matrix.language }} translation - # run: mdbook build - - # - name: Upload ${{ matrix.language }} translation - # uses: actions/upload-artifact@v3 - # with: - # name: rust-design-patterns-${{ matrix.language }} - # path: book/ - - # - name: Test code snippets with ${{ matrix.language }} translation - # run: mdbook test + i18n-helpers: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Install Gettext + run: sudo apt install gettext + + - name: Setup Rust cache + uses: ./.github/workflows/setup-rust-cache + + - name: Install mdbook + uses: ./.github/workflows/install-mdbook + + - name: Generate po/messages.pot + run: mdbook build -d po + env: + MDBOOK_OUTPUT: '{"xgettext": {"pot-file": "messages.pot"}}' + + - name: Test messages.pot + run: msgfmt --statistics -o /dev/null po/messages.pot + + - name: Expand includes without translation + run: mdbook build -d expanded + env: + MDBOOK_OUTPUT: '{"markdown": {}}' + + - name: Expand includes with no-op translation + run: mdbook build -d no-op + env: + MDBOOK_OUTPUT: '{"markdown": {}}' + MDBOOK_PREPROCESSOR__GETTEXT__PO_FILE: po/messages.pot + + - name: Compare no translation to no-op translation + run: diff --color=always --unified --recursive expanded no-op + + find-translations: + runs-on: ubuntu-latest + outputs: + languages: ${{ steps.find-translations.outputs.languages }} + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Find translations + id: find-translations + shell: python + run: | + import os, json, pathlib + languages = [p.stem for p in pathlib.Path("po").iterdir() if p.suffix == ".po"] + github_output = open(os.environ["GITHUB_OUTPUT"], "a") + github_output.write("languages=") + json.dump(sorted(languages), github_output) + + translations: + runs-on: ubuntu-latest + needs: + - find-translations + strategy: + matrix: + language: ${{ fromJSON(needs.find-translations.outputs.languages) }} + env: + MDBOOK_BOOK__LANGUAGE: ${{ matrix.language }} + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Install Gettext + run: sudo apt install gettext + + - name: Setup Rust cache + uses: ./.github/workflows/setup-rust-cache + + - name: Install mdbook + uses: ./.github/workflows/install-mdbook + + - name: Test ${{ matrix.language }} translation + run: msgfmt --statistics -o /dev/null po/${{ matrix.language }}.po + + - name: Build book with ${{ matrix.language }} translation + run: mdbook build + + - name: Upload ${{ matrix.language }} translation + uses: actions/upload-artifact@v3 + with: + name: rust-design-patterns-${{ matrix.language }} + path: book/ + + - name: Test code snippets with ${{ matrix.language }} translation + run: mdbook test diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 2b04282..d8a9d89 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -2,7 +2,12 @@ name: Deploy mdBook sites to GH Pages on: push: - branches: ["main"] + # TODO: Change before merge into main + # branches: ["main"] + branches: + - main + - translation-de + workflow_dispatch: permissions: @@ -19,9 +24,12 @@ env: CARGO_TERM_COLOR: always # TODO: Update the language picker in index.hbs to link new languages. # TODO: As long as https://github.com/google/mdbook-i18n-helpers/issues/12 is not implemented, yet. - # TODO: Activate when first translation is available # These are the languages in addition to 'en', which is the main language - # LANGUAGES: xx + # de linked, due to being partly reviewed + # es not linked, due to being mostly unreviewed + # it not linked, due to being mostly unreviewed + # pt-BR not linked, due to being mostly unreviewed + LANGUAGES: de es it pt-BR jobs: publish: @@ -42,16 +50,15 @@ jobs: - name: Build course in English run: mdbook build -d book - # TODO: Activate when first translation is available - # - name: Build all translations - # run: | - # for po_lang in ${{ env.LANGUAGES }}; do - # echo "::group::Building $po_lang translation" - # MDBOOK_BOOK__LANGUAGE=$po_lang \ - # MDBOOK_OUTPUT__HTML__SITE_URL=/patterns/$po_lang/ \ - # mdbook build -d book/$po_lang - # echo "::endgroup::" - # done + - name: Build all translations + run: | + for po_lang in ${{ env.LANGUAGES }}; do + echo "::group::Building $po_lang translation" + MDBOOK_BOOK__LANGUAGE=$po_lang \ + MDBOOK_OUTPUT__HTML__SITE_URL=/patterns/$po_lang/ \ + mdbook build -d book/$po_lang + echo "::endgroup::" + done - name: Setup Pages id: pages diff --git a/.gitignore b/.gitignore index 29b71da..5fab570 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ # Generated output of mdbook /book .DS_Store +po/*.mo diff --git a/language-picker.css b/language-picker.css index 1f7d537..af7b539 100644 --- a/language-picker.css +++ b/language-picker.css @@ -1,6 +1,6 @@ #language-list { left: auto; - right: 10px; + right: 9em; } #language-list a { diff --git a/po/de.po b/po/de.po new file mode 100644 index 0000000..287e96b --- /dev/null +++ b/po/de.po @@ -0,0 +1,8331 @@ +msgid "" +msgstr "" +"Project-Id-Version: Rust Design Patterns\n" +"POT-Creation-Date: \n" +"PO-Revision-Date: 2023-04-09 07:12+0200\n" +"Last-Translator: EMAIL@ADDRESS\n" +"Language-Team: German\n" +"Language: de\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" +"X-Generator: Poedit 3.2.2\n" + +#: src\SUMMARY.md:3 +msgid "Introduction" +msgstr "Einführung" + +#: src\SUMMARY.md:4 +msgid "Translations" +msgstr "Übersetzungen" + +#: src\SUMMARY.md:5 +msgid "Idioms" +msgstr "Idiome" + +#: src\SUMMARY.md:6 +msgid "Use borrowed types for arguments" +msgstr "Verwenden Sie geliehene Typen für Argumente" + +#: src\SUMMARY.md:7 +msgid "Concatenating Strings with format!" +msgstr "Strings mit format! verketten" + +#: src\SUMMARY.md:8 +msgid "Constructor" +msgstr "Konstruktor" + +#: src\SUMMARY.md:9 +msgid "The Default Trait" +msgstr "Der Standard-Trait" + +#: src\SUMMARY.md:10 +msgid "Collections Are Smart Pointers" +msgstr "Sammlungen sind intelligente Zeiger" + +#: src\SUMMARY.md:11 +msgid "Finalisation in Destructors" +msgstr "Finalisierung in Destruktoren" + +#: src\SUMMARY.md:12 +msgid "mem::{take(_), replace(_)}" +msgstr "mem::{take(_), replace(_)}" + +#: src\SUMMARY.md:13 +#, fuzzy +msgid "On-Stack Dynamic Dispatch" +msgstr "Dynamischer On-Stack-Versand" + +#: src\SUMMARY.md:14 src\SUMMARY.md:40 +msgid "Foreign function interface (FFI)" +msgstr "Fremdfunktionsschnittstelle (FFI)" + +#: src\SUMMARY.md:15 +msgid "Idiomatic Errors" +msgstr "Idiomatische Fehlerbehandlung" + +#: src\SUMMARY.md:16 +msgid "Accepting Strings" +msgstr "Akzeptieren von Zeichenketten" + +#: src\SUMMARY.md:17 +msgid "Passing Strings" +msgstr "Übergeben von Zeichenketten" + +#: src\SUMMARY.md:18 +msgid "Iterating over an Option" +msgstr "Iteration über Option" + +#: src\SUMMARY.md:19 +#, fuzzy +msgid "Pass Variables to Closure" +msgstr "Übergeben Sie Variablen an den Abschluss" + +#: src\SUMMARY.md:20 +msgid "Privacy For Extensibility" +msgstr "Datenschutz für Erweiterbarkeit" + +#: src\SUMMARY.md:21 +msgid "Easy doc initialization" +msgstr "Einfache Dokumentationsinitialisierung" + +#: src\SUMMARY.md:22 +msgid "Temporary mutability" +msgstr "Vorübergehende Veränderlichkeit" + +#: src\SUMMARY.md:23 +msgid "Return consumed arg on error" +msgstr "Genutztes Argument bei Fehlern zurückgeben" + +#: src\SUMMARY.md:25 +msgid "Design Patterns" +msgstr "Entwurfsmuster" + +#: src\SUMMARY.md:26 +msgid "Behavioural" +msgstr "Verhalten" + +#: src\SUMMARY.md:27 +msgid "Command" +msgstr "Befehl" + +#: src\SUMMARY.md:28 +msgid "Interpreter" +msgstr "Dolmetscher" + +#: src\SUMMARY.md:29 +msgid "Newtype" +msgstr "Neuer Typ" + +#: src\SUMMARY.md:30 +msgid "RAII Guards" +msgstr "RAII-Wächter" + +#: src\SUMMARY.md:31 +msgid "Strategy" +msgstr "Strategie" + +#: src\SUMMARY.md:32 +msgid "Visitor" +msgstr "Besucher" + +#: src\SUMMARY.md:33 +msgid "Creational" +msgstr "Erzeugend" + +#: src\SUMMARY.md:34 +msgid "Builder" +msgstr "Erbauer" + +#: src\SUMMARY.md:35 +msgid "Fold" +msgstr "Falz" + +#: src\SUMMARY.md:36 +msgid "Structural" +msgstr "Strukturell" + +#: src\SUMMARY.md:37 +msgid "Compose Structs" +msgstr "Strukturen zusammensetzen" + +#: src\SUMMARY.md:38 +msgid "Prefer Small Crates" +msgstr "Bevorzugen Sie kleine Pakete" + +#: src\SUMMARY.md:39 +msgid "Contain unsafety in small modules" +msgstr "Unsicherheit in kleinen Modulen isolieren" + +#: src\SUMMARY.md:41 +msgid "Object-Based APIs" +msgstr "Objektbasierte APIs" + +#: src\SUMMARY.md:42 +#, fuzzy +msgid "Type Consolidation into Wrappers" +msgstr "Geben Sie Konsolidierung in Wrapper ein" + +#: src\SUMMARY.md:44 +msgid "Anti-patterns" +msgstr "Antimuster" + +#: src\SUMMARY.md:45 +msgid "Clone to satisfy the borrow checker" +msgstr "Klonen, um den Borrow-Checker zu befriedigen" + +#: src\SUMMARY.md:46 +msgid "#[deny(warnings)]" +msgstr "" + +#: src\SUMMARY.md:47 +msgid "Deref Polymorphism" +msgstr "Deref Polymorphismus" + +#: src\SUMMARY.md:49 +msgid "Functional Programming" +msgstr "Funktionale Programmierung" + +#: src\SUMMARY.md:50 +msgid "Programming paradigms" +msgstr "Programmierparadigmen" + +#: src\SUMMARY.md:51 +msgid "Generics as Type Classes" +msgstr "Generics als Typklassen" + +#: src\SUMMARY.md:52 +msgid "Lenses and Prisms" +msgstr "Linsen und Prismen" + +#: src\SUMMARY.md:54 +msgid "Additional Resources" +msgstr "Zusätzliche Ressourcen" + +#: src\SUMMARY.md:55 +msgid "Design principles" +msgstr "Design-Prinzipien" + +#: src\intro.md:1 +msgid "# Introduction" +msgstr "# Einführung" + +#: src\intro.md:3 +msgid "## Participation" +msgstr "## Beteiligung" + +#: src\intro.md:5 +msgid "" +"If you are interested in contributing to this book, check out the\n" +"[contribution guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +msgstr "" +"Wenn Sie daran interessiert sind, zu diesem Buch beizutragen, schauen Sie sich\n" +"die [Beitragsrichtlinien](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md) an." + +#: src\intro.md:8 +msgid "## Design patterns" +msgstr "## Entwurfsmuster" + +#: src\intro.md:10 +msgid "" +"In software development, we often come across problems that share\n" +"similarities regardless of the environment they appear in. Although the\n" +"implementation details are crucial to solve the task at hand, we may\n" +"abstract from these particularities to find the common practices that\n" +"are generically applicable." +msgstr "" +"In der Softwareentwicklung stoßen wir oft auf Probleme die \n" +"Ähnlichkeiten, unabhängig von der Umgebung, in der sie erscheinen, haben. Obwohl die\n" +"Implementierungsdetails entscheidend sind, um die anstehende Aufgabe zu lösen, können wir\n" +"sie von diesen Besonderheiten wegabstrahieren, um gängige Praktiken zu finden, die\n" +"allgemein anwendbar sind." + +#: src\intro.md:16 +msgid "" +"Design patterns are a collection of reusable and tested solutions to\n" +"recurring problems in engineering. They make our software more modular,\n" +"maintainable, and extensible. Moreover, these patterns provide a common\n" +"language for developers, making them an excellent tool for effective\n" +"communication when problem-solving in teams." +msgstr "" +"Entwurfsmuster sind eine Sammlung wiederverwendbarer und getesteter Lösungen für\n" +"wiederkehrende Probleme im Ingenieurwesen. Sie machen unsere Software modularer,\n" +"wartbar und erweiterbar. Darüber hinaus stellen diese Muster eine gemeinsame\n" +"Sprache für Entwickler bereit, welche sie zu einem hervorragenden Werkzeug für effektive\n" +"Kommunikation bei der Problemlösung im Team macht." + +#: src\intro.md:22 src\patterns/index.md:14 +msgid "## Design patterns in Rust" +msgstr "## Entwurfsmuster in Rust" + +#: src\intro.md:24 +msgid "" +"Rust is not object-oriented, and the combination of all its characteristics,\n" +"such as functional elements, a strong type system, and the borrow checker,\n" +"makes it unique.\n" +"Because of this, Rust design patterns vary with respect to other\n" +"traditional object-oriented programming languages.\n" +"That's why we decided to write this book. We hope you enjoy reading it!\n" +"The book is divided in three main chapters:" +msgstr "" +"Rust ist nicht objektorientiert, und die Kombination all seiner Eigenschaften,\n" +"wie funktionale Elemente, ein starkes Typsystem und der Borrow-Checker,\n" +"machen es einzigartig.\n" +"Aus diesem Grund variieren Rust-Entwurfsmuster in Bezug auf andere\n" +"traditionelle objektorientierte Programmiersprachen.\n" +"Deshalb haben wir uns entschlossen, dieses Buch zu schreiben. Wir wünschen Ihnen viel Spaß beim Lesen!\n" +"Das Buch ist in drei Hauptkapitel gegliedert:" + +#: src\intro.md:32 +msgid "" +"- [Idioms](./idioms/index.md): guidelines to follow when coding.\n" +" They are the social norms of the community.\n" +" You should break them only if you have a good reason for it.\n" +"- [Design patterns](./patterns/index.md): methods to solve common problems\n" +" when coding.\n" +"- [Anti-patterns](./anti_patterns/index.md): methods to solve common problems\n" +" when coding.\n" +" However, while design patterns give us benefits,\n" +" anti-patterns create more problems." +msgstr "" +"- [Idiome](./idioms/index.md): Richtlinien, die beim Programmieren befolgt werden sollten.\n" +" Sie sind die sozialen Normen der Gemeinschaft.\n" +" Sie sollten nur gebrochen werden, wenn Sie einen triftigen Grund dafür haben.\n" +"- [Entwurfsmuster](./patterns/index.md): Methoden zur Lösung häufig auftretender Probleme\n" +" beim Programmieren.\n" +"- [Antimuster](./anti_patterns/index.md): Methoden zur Lösung häufiger Probleme\n" +" beim Programmieren.\n" +" Entwurfsmuster bringen uns Vorteile,\n" +" wohingegen Antimuster uns mehr Probleme verursachen,\n" +" als sie uns Vorteile zu bringen scheinen." + +#: src\translations.md:1 +msgid "# Translations" +msgstr "# Übersetzungen" + +#: src\translations.md:3 +msgid "" +"We are utilizing [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Please read up on how to _add_ and _update_ translations in [their repository](https://github.com/google/mdbook-i18n-helpers#creating-and-" +"updating-translations)" +msgstr "" +"Wir verwenden [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Bitte lesen Sie in deren [Repository](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations) nach,\n" +"wie Sie Übersetzungen _hinzufügen_ und _aktualisieren_ können." + +#: src\translations.md:6 +msgid "## External translations" +msgstr "## Externe Übersetzungen" + +#: src\translations.md:8 +msgid "- [简体中文](https://fomalhauthmj.github.io/patterns/)" +msgstr "- [简体中文](https://fomalhauthmj.github.io/patterns/)" + +#: src\translations.md:10 +msgid "" +"If you want to add a translation, please open an issue in the\n" +"[main repository](https://github.com/rust-unofficial/patterns)." +msgstr "" +"Wenn Sie eine Übersetzung hinzufügen möchten, öffnen Sie bitte einen Fall im\n" +"[Haupt-Repository](https://github.com/rust-unofficial/patterns)." + +#: src\idioms/index.md:1 +msgid "# Idioms" +msgstr "# Idiome" + +#: src\idioms/index.md:3 +msgid "" +"[Idioms](https://en.wikipedia.org/wiki/Programming_idiom) are commonly used\n" +"styles, guidelines and patterns largely agreed upon by a community.\n" +"Writing idiomatic code allows other developers to understand better what is\n" +"happening." +msgstr "" +"[Idiome](https://en.wikipedia.org/wiki/Programming_idiom) sind häufig verwendete\n" +"Stile, Richtlinien und Muster, auf die sich eine Gemeinschaft weitgehend geeinigt hat.\n" +"Das Schreiben von idiomatischem Code ermöglicht es anderen Entwicklern, besser zu verstehen,\n" +"was vor sich geht." + +#: src\idioms/index.md:8 +msgid "" +"After all, the computer only cares about the machine code that is generated\n" +"by the compiler.\n" +"Instead, the source code is mainly beneficial to the developer.\n" +"So, since we have this abstraction layer, why not make it more readable?" +msgstr "" +"Der Computer kümmert sich schließlich nur um den generierten Maschinencode\n" +"vom Kompilierer.\n" +"Stattdessen ist der Quellcode hauptsächlich für den Entwickler von Vorteil.\n" +"Da wir also diese Abstraktionsebene haben, warum machen wir sie nicht besser lesbar?" + +#: src\idioms/index.md:13 +msgid "" +"Remember the [KISS principle](https://en.wikipedia.org/wiki/KISS_principle):\n" +"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they are\n" +"kept simple rather than made complicated; therefore, simplicity should be a key\n" +"goal in design, and unnecessary complexity should be avoided\"." +msgstr "" + +#: src\idioms/index.md:18 +msgid "> Code is there for humans, not computers, to understand." +msgstr "> Code ist nicht für Computer da, sondern für Menschen und um ihn zu verstehen." + +#: src\idioms/coercion-arguments.md:1 +#, fuzzy +msgid "# Use borrowed types for arguments" +msgstr "# Verwenden Sie geliehene Typen für Argumente" + +#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 src\idioms/default.md:3 src\idioms/deref.md:3 +#: src\idioms/dtor-finally.md:3 src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 src\idioms/ffi/errors.md:3 +#: src\idioms/ffi/accepting-strings.md:3 src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 src\idioms/pass-var-to-closure.md:3 +#: src\idioms/priv-extend.md:3 src\idioms/temporary-mutability.md:3 src\idioms/return-consumed-arg-on-error.md:3 +#: src\patterns/behavioural/command.md:3 src\patterns/behavioural/interpreter.md:3 src\patterns/behavioural/newtype.md:13 +#: src\patterns/behavioural/RAII.md:3 src\patterns/behavioural/strategy.md:3 src\patterns/behavioural/visitor.md:3 +#: src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 src\patterns/structural/compose-structs.md:5 +#: src\patterns/structural/small-crates.md:3 src\patterns/structural/unsafe-mods.md:3 src\patterns/ffi/export.md:3 +#: src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 src\anti_patterns/deny-warnings.md:3 src\anti_patterns/deref.md:3 +#: src\functional/generics-type-classes.md:3 +msgid "## Description" +msgstr "## Beschreibung" + +#: src\idioms/coercion-arguments.md:5 +#, fuzzy +msgid "" +"Using a target of a deref coercion can increase the flexibility of your code\n" +"when you are deciding which argument type to use for a function argument.\n" +"In this way, the function will accept more input types." +msgstr "" +"Die Verwendung eines Ziels einer Deref-Erzwingung kann die Flexibilität Ihres Codes erhöhen\n" +"wenn Sie entscheiden, welcher Argumenttyp für ein Funktionsargument verwendet werden soll.\n" +"Auf diese Weise akzeptiert die Funktion mehr Eingabetypen." + +#: src\idioms/coercion-arguments.md:9 +#, fuzzy +msgid "" +"This is not limited to slice-able or fat pointer types.\n" +"In fact, you should always prefer using the **borrowed type** over\n" +"**borrowing the owned type**.\n" +"Such as `&str` over `&String`, `&[T]` over `&Vec`, or `&T` over `&Box`." +msgstr "" +"Dies ist nicht auf Slice-fähige oder Fat-Pointer-Typen beschränkt.\n" +"Tatsächlich sollten Sie es immer vorziehen, den **geliehenen Typ** gegenüber zu verwenden\n" +"**Ausleihen des eigenen Typs**.\n" +"Zum Beispiel `&str` über `&String`, `&[T]` über `&Vec` oder `&T` über `&Box`." + +#: src\idioms/coercion-arguments.md:14 +#, fuzzy +msgid "" +"Using borrowed types you can avoid layers of indirection for those instances\n" +"where the owned type already provides a layer of indirection. For instance, a\n" +"`String` has a layer of indirection, so a `&String` will have two layers of\n" +"indirection. We can avoid this by using `&str` instead, and letting `&String`\n" +"coerce to a `&str` whenever the function is invoked." +msgstr "" +"Durch die Verwendung von geliehenen Typen können Sie indirekte Ebenen für diese Instanzen vermeiden\n" +"wobei der eigene Typ bereits eine indirekte Ebene bereitstellt. Zum Beispiel ein\n" +"`String` hat eine Indirektionsschicht, also hat ein `&String` zwei Ebenen\n" +"indirekt. Wir können dies vermeiden, indem wir stattdessen `&str` verwenden und `&String`\n" +"Erzwingen Sie ein `&str`, wann immer die Funktion aufgerufen wird." + +#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 src\idioms/default.md:20 src\idioms/deref.md:9 +#: src\idioms/dtor-finally.md:9 src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 src\idioms/pass-var-to-closure.md:12 +#: src\idioms/priv-extend.md:18 src\idioms/temporary-mutability.md:12 src\idioms/return-consumed-arg-on-error.md:8 +#: src\patterns/behavioural/command.md:18 src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 +#: src\patterns/behavioural/strategy.md:28 src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 +#: src\patterns/creational/fold.md:12 src\patterns/structural/compose-structs.md:17 src\anti_patterns/borrow_clone.md:11 +#: src\anti_patterns/deny-warnings.md:8 src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 +msgid "## Example" +msgstr "## Beispiel" + +#: src\idioms/coercion-arguments.md:22 +#, fuzzy +msgid "" +"For this example, we will illustrate some differences for using `&String` as a\n" +"function argument versus using a `&str`, but the ideas apply as well to using\n" +"`&Vec` versus using a `&[T]` or using a `&Box` versus a `&T`." +msgstr "" +"Für dieses Beispiel veranschaulichen wir einige Unterschiede bei der Verwendung von `&String` als\n" +"Funktionsargument gegenüber der Verwendung eines `&str`, aber die Ideen gelten auch für die Verwendung\n" +"`&Vec` im Vergleich zur Verwendung eines `&[T]` oder zur Verwendung eines `&Box` im Vergleich zu einem `&T`." + +#: src\idioms/coercion-arguments.md:26 +#, fuzzy +msgid "" +"Consider an example where we wish to determine if a word contains three\n" +"consecutive vowels. We don't need to own the string to determine this, so we\n" +"will take a reference." +msgstr "" +"Betrachten Sie ein Beispiel, bei dem wir feststellen möchten, ob ein Wort drei enthält\n" +"aufeinanderfolgende Vokale. Wir müssen die Zeichenfolge nicht besitzen, um dies festzustellen, also wir\n" +"wird eine Referenz nehmen." + +#: src\idioms/coercion-arguments.md:30 +msgid "The code might look something like this:" +msgstr "Der Code könnte etwa so aussehen:" + +#: src\idioms/coercion-arguments.md:32 +msgid "" +"```rust\n" +"fn three_vowels(word: &String) -> bool {\n" +" let mut vowel_count = 0;\n" +" for c in word.chars() {\n" +" match c {\n" +" 'a' | 'e' | 'i' | 'o' | 'u' => {\n" +" vowel_count += 1;\n" +" if vowel_count >= 3 {\n" +" return true\n" +" }\n" +" }\n" +" _ => vowel_count = 0\n" +" }\n" +" }\n" +" false\n" +"}\n" +"\n" +"fn main() {\n" +" let ferris = \"Ferris\".to_string();\n" +" let curious = \"Curious\".to_string();\n" +" println!(\"{}: {}\", ferris, three_vowels(&ferris));\n" +" println!(\"{}: {}\", curious, three_vowels(&curious));\n" +"\n" +" // This works fine, but the following two lines would fail:\n" +" // println!(\"Ferris: {}\", three_vowels(\"Ferris\"));\n" +" // println!(\"Curious: {}\", three_vowels(\"Curious\"));\n" +"\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/coercion-arguments.md:62 +msgid "" +"This works fine because we are passing a `&String` type as a parameter.\n" +"If we remove the comments on the last two lines, the example will fail. This\n" +"is because a `&str` type will not coerce to a `&String` type. We can fix this\n" +"by simply modifying the type for our argument." +msgstr "" +"Das funktioniert gut, weil wir einen `&String`-Typ als Parameter übergeben.\n" +"Wenn wir die Kommentare in den letzten beiden Zeilen entfernen, schlägt das Beispiel fehl. Das\n" +"liegt daran, dass ein `&str`-Typ nicht in einen `&String`-Typ umgewandelt wird. Wir können das beheben\n" +"indem wir einfach den Typ für unser Argument ändern." + +#: src\idioms/coercion-arguments.md:67 +msgid "For instance, if we change our function declaration to:" +msgstr "Wenn wir zum Beispiel unsere Funktionsdeklaration ändern in:" + +#: src\idioms/coercion-arguments.md:69 +msgid "" +"```rust, ignore\n" +"fn three_vowels(word: &str) -> bool {\n" +"```" +msgstr "" + +#: src\idioms/coercion-arguments.md:73 +msgid "then both versions will compile and print the same output." +msgstr "dann können beide Versionen kompiliert warden und geben dasselbe aus." + +#: src\idioms/coercion-arguments.md:75 +msgid "" +"```bash\n" +"Ferris: false\n" +"Curious: true\n" +"```" +msgstr "" + +#: src\idioms/coercion-arguments.md:80 +#, fuzzy +msgid "" +"But wait, that's not all! There is more to this story.\n" +"It's likely that you may say to yourself: that doesn't matter, I will never be\n" +"using a `&'static str` as an input anyways (as we did when we used `\"Ferris\"`).\n" +"Even ignoring this special example, you may still find that using `&str` will\n" +"give you more flexibility than using a `&String`." +msgstr "" +"Aber warte, das ist noch nicht alles! Zu dieser Geschichte gehört noch mehr.\n" +"Wahrscheinlich werden Sie sich sagen: Das ist egal, das werde ich nie sein\n" +"sowieso einen `&'statischen str` als Eingabe verwenden (wie wir es taten, als wir `\"Ferris\"` verwendeten).\n" +"Selbst wenn Sie dieses spezielle Beispiel ignorieren, werden Sie vielleicht immer noch feststellen, dass die Verwendung von `&str` will\n" +"geben Ihnen mehr Flexibilität als die Verwendung eines `&String`." + +#: src\idioms/coercion-arguments.md:86 +#, fuzzy +msgid "" +"Let's now take an example where someone gives us a sentence, and we want to\n" +"determine if any of the words in the sentence contain three consecutive vowels.\n" +"We probably should make use of the function we have already defined and simply\n" +"feed in each word from the sentence." +msgstr "" +"Nehmen wir jetzt ein Beispiel, wo uns jemand einen Satz gibt, und wir wollen\n" +"Bestimmen Sie, ob eines der Wörter im Satz drei aufeinanderfolgende Vokale enthält.\n" +"Wir sollten wahrscheinlich die Funktion verwenden, die wir bereits und einfach definiert haben\n" +"Füge jedes Wort aus dem Satz ein." + +#: src\idioms/coercion-arguments.md:91 +msgid "An example of this could look like this:" +msgstr "Ein Beispiel dafür könnte so aussehen:" + +#: src\idioms/coercion-arguments.md:93 +msgid "" +"```rust\n" +"fn three_vowels(word: &str) -> bool {\n" +" let mut vowel_count = 0;\n" +" for c in word.chars() {\n" +" match c {\n" +" 'a' | 'e' | 'i' | 'o' | 'u' => {\n" +" vowel_count += 1;\n" +" if vowel_count >= 3 {\n" +" return true\n" +" }\n" +" }\n" +" _ => vowel_count = 0\n" +" }\n" +" }\n" +" false\n" +"}\n" +"\n" +"fn main() {\n" +" let sentence_string =\n" +" \"Once upon a time, there was a friendly curious crab named Ferris\".to_string();\n" +" for word in sentence_string.split(' ') {\n" +" if three_vowels(word) {\n" +" println!(\"{} has three consecutive vowels!\", word);\n" +" }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/coercion-arguments.md:121 +#, fuzzy +msgid "" +"Running this example using our function declared with an argument type `&str`\n" +"will yield" +msgstr "" +"Ausführen dieses Beispiels mit unserer Funktion, die mit einem Argumenttyp `&str` deklariert ist\n" +"wird nachgeben" + +#: src\idioms/coercion-arguments.md:124 +msgid "" +"```bash\n" +"curious has three consecutive vowels!\n" +"```" +msgstr "" + +#: src\idioms/coercion-arguments.md:128 +#, fuzzy +msgid "" +"However, this example will not run when our function is declared with an\n" +"argument type `&String`. This is because string slices are a `&str` and not a\n" +"`&String` which would require an allocation to be converted to `&String` which\n" +"is not implicit, whereas converting from `String` to `&str` is cheap and implicit." +msgstr "" +"Dieses Beispiel wird jedoch nicht ausgeführt, wenn unsere Funktion mit einem deklariert wird\n" +"Argumenttyp `&String`. Das liegt daran, dass String-Slices ein `&str` und kein a sind\n" +"„&String“, wofür eine Zuweisung erforderlich wäre, die in „&String“ konvertiert werden müsste\n" +"ist nicht implizit, wohingegen die Konvertierung von `String` nach `&str` billig und implizit ist." + +#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 +#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 +#: src\patterns/behavioural/command.md:218 src\patterns/behavioural/interpreter.md:142 src\patterns/behavioural/newtype.md:104 +#: src\patterns/behavioural/RAII.md:111 src\patterns/behavioural/strategy.md:174 src\patterns/behavioural/visitor.md:106 +#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 src\patterns/structural/small-crates.md:45 +#: src\patterns/structural/unsafe-mods.md:32 src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 +#: src\anti_patterns/deref.md:123 src\functional/generics-type-classes.md:237 +msgid "## See also" +msgstr "## Siehe auch" + +#: src\idioms/coercion-arguments.md:135 +#, fuzzy +msgid "" +"- [Rust Language Reference on Type Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- For more discussion on how to handle `String` and `&str` see\n" +" [this blog series (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions." +"html)\n" +" by Herman J. Radtke III" +msgstr "" +"- [Rust Language Reference on Type Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- Für weitere Diskussionen zum Umgang mit `String` und `&str` siehe\n" +" [diese Blogserie (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions." +"html )\n" +" von Hermann J. Radtke III" + +#: src\idioms/concat-format.md:1 +msgid "# Concatenating strings with `format!`" +msgstr "# Strings mit `format!` verketten" + +#: src\idioms/concat-format.md:5 +#, fuzzy +msgid "" +"It is possible to build up strings using the `push` and `push_str` methods on a\n" +"mutable `String`, or using its `+` operator. However, it is often more\n" +"convenient to use `format!`, especially where there is a mix of literal and\n" +"non-literal strings." +msgstr "" +"Es ist möglich, Strings mit den Methoden `push` und `push_str` auf a aufzubauen\n" +"veränderlicher `String`, oder mit seinem `+`-Operator. Oft sind es jedoch mehr\n" +"bequem zu verwendendes `format!`, besonders wenn es eine Mischung aus wörtlichem und gibt\n" +"nicht wörtliche Zeichenfolgen." + +#: src\idioms/concat-format.md:12 +msgid "" +"```rust\n" +"fn say_hello(name: &str) -> String {\n" +" // We could construct the result string manually.\n" +" // let mut result = \"Hello \".to_owned();\n" +" // result.push_str(name);\n" +" // result.push('!');\n" +" // result\n" +"\n" +" // But using format! is better.\n" +" format!(\"Hello {}!\", name)\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 +#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 src\idioms/ffi/accepting-strings.md:68 +#: src\idioms/ffi/passing-strings.md:68 src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 +#: src\idioms/return-consumed-arg-on-error.md:55 src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 +#: src\patterns/behavioural/strategy.md:96 src\patterns/creational/builder.md:68 src\patterns/structural/compose-structs.md:75 +#: src\patterns/structural/small-crates.md:12 src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 +#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 src\anti_patterns/deref.md:69 +#: src\functional/generics-type-classes.md:210 +msgid "## Advantages" +msgstr "## Vorteile" + +#: src\idioms/concat-format.md:27 +#, fuzzy +msgid "Using `format!` is usually the most succinct and readable way to combine strings." +msgstr "Die Verwendung von `format!` ist normalerweise die prägnanteste und lesbarste Art, Zeichenfolgen zu kombinieren." + +#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 +#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 src\idioms/ffi/accepting-strings.md:141 +#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 src\idioms/temporary-mutability.md:42 +#: src\idioms/return-consumed-arg-on-error.md:59 src\patterns/behavioural/newtype.md:77 src\patterns/behavioural/strategy.md:104 +#: src\patterns/creational/builder.md:76 src\patterns/structural/compose-structs.md:81 src\patterns/structural/small-crates.md:22 +#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 +#: src\functional/generics-type-classes.md:221 +msgid "## Disadvantages" +msgstr "## Nachteile" + +#: src\idioms/concat-format.md:31 +#, fuzzy +msgid "" +"It is usually not the most efficient way to combine strings - a series of `push`\n" +"operations on a mutable string is usually the most efficient (especially if the\n" +"string has been pre-allocated to the expected size)." +msgstr "" +"Es ist normalerweise nicht der effizienteste Weg, Zeichenfolgen zu kombinieren - eine Reihe von \"Push\".\n" +"Operationen auf einer änderbaren Zeichenfolge sind normalerweise am effizientesten (insbesondere wenn die\n" +"String wurde auf die erwartete Größe vorbelegt)." + +#: src\idioms/ctor.md:1 +msgid "# Constructors\r" +msgstr "# Konstruktoren\r" + +#: src\idioms/ctor.md:3 src\idioms/rustdoc-init.md:3 +msgid "## Description\r" +msgstr "## Beschreibung\r" + +#: src\idioms/ctor.md:5 +msgid "" +"Rust does not have constructors as a language construct. Instead, the\r\n" +"convention is to use an [associated function][associated function] `new` to create an object:" +msgstr "" +"Rust hat keine Konstruktoren als Sprachkonstrukt. Stattdessen besteht die\r\n" +"Konvention darin, die [zugehörige Funktion][associated function] `new` zu verwenden, um ein Objekt zu erstellen:" + +#: src\idioms/ctor.md:8 +msgid "" +"````rust\r\n" +"/// Time in seconds.\r\n" +"///\r\n" +"/// # Example\r\n" +"///\r\n" +"/// ```\r\n" +"/// let s = Second::new(42);\r\n" +"/// assert_eq!(42, s.value());\r\n" +"/// ```\r\n" +"pub struct Second {\r\n" +" value: u64\r\n" +"}\r\n" +"\r\n" +"impl Second {\r\n" +" // Constructs a new instance of [`Second`].\r\n" +" // Note this is an associated function - no self.\r\n" +" pub fn new(value: u64) -> Self {\r\n" +" Self { value }\r\n" +" }\r\n" +"\r\n" +" /// Returns the value in seconds.\r\n" +" pub fn value(&self) -> u64 {\r\n" +" self.value\r\n" +" }\r\n" +"}\r\n" +"````" +msgstr "" + +#: src\idioms/ctor.md:35 +msgid "## Default Constructors\r" +msgstr "## Standardkonstruktoren\r" + +#: src\idioms/ctor.md:37 +msgid "Rust supports default constructors with the [`Default`][std-default] trait:" +msgstr "Rust unterstützt Standardkonstruktoren mit dem [`Default`][std-default]-Trait:" + +#: src\idioms/ctor.md:39 +msgid "" +"````rust\r\n" +"/// Time in seconds.\r\n" +"///\r\n" +"/// # Example\r\n" +"///\r\n" +"/// ```\r\n" +"/// let s = Second::default();\r\n" +"/// assert_eq!(0, s.value());\r\n" +"/// ```\r\n" +"pub struct Second {\r\n" +" value: u64\r\n" +"}\r\n" +"\r\n" +"impl Second {\r\n" +" /// Returns the value in seconds.\r\n" +" pub fn value(&self) -> u64 {\r\n" +" self.value\r\n" +" }\r\n" +"}\r\n" +"\r\n" +"impl Default for Second {\r\n" +" fn default() -> Self {\r\n" +" Self { value: 0 }\r\n" +" }\r\n" +"}\r\n" +"````" +msgstr "" + +#: src\idioms/ctor.md:66 +msgid "" +"`Default` can also be derived if all types of all fields implement `Default`,\r\n" +"like they do with `Second`:" +msgstr "" +"`Default` kann auch abgeleitet werden, wenn alle Typen aller Felder `Default` implementieren,\r\n" +"wie hier bei `Second`:" + +#: src\idioms/ctor.md:69 +msgid "" +"````rust\r\n" +"/// Time in seconds.\r\n" +"///\r\n" +"/// # Example\r\n" +"///\r\n" +"/// ```\r\n" +"/// let s = Second::default();\r\n" +"/// assert_eq!(0, s.value());\r\n" +"/// ```\r\n" +"#[derive(Default)]\r\n" +"pub struct Second {\r\n" +" value: u64\r\n" +"}\r\n" +"\r\n" +"impl Second {\r\n" +" /// Returns the value in seconds.\r\n" +" pub fn value(&self) -> u64 {\r\n" +" self.value\r\n" +" }\r\n" +"}\r\n" +"````" +msgstr "" + +#: src\idioms/ctor.md:91 +#, fuzzy +msgid "" +"**Note:** It is common and expected for types to implement both\r\n" +"`Default` and an empty `new` constructor. `new` is the constructor\r\n" +"convention in Rust, and users expect it to exist, so if it is\r\n" +"reasonable for the basic constructor to take no arguments, then it\r\n" +"should, even if it is functionally identical to default." +msgstr "" +"**Hinweis:** Es ist üblich und wird erwartet, dass Typen beide implementieren\r\n" +"`Default` und ein leerer `new`-Konstruktor. `new` ist der Konstruktor\r\n" +"Konvention in Rust, und Benutzer erwarten, dass es existiert, also wenn es so ist\r\n" +"sinnvoll für den Basiskonstruktor, keine Argumente zu nehmen, dann ist es\r\n" +"sollte, auch wenn es funktional identisch mit default ist." + +#: src\idioms/ctor.md:97 +#, fuzzy +msgid "" +"**Hint:** The advantage of implementing or deriving `Default` is that your type\r\n" +"can now be used where a `Default` implementation is required, most prominently,\r\n" +"any of the [`*or_default` functions in the standard library][std-or-default]." +msgstr "" +"**Hinweis:** Der Vorteil der Implementierung oder Ableitung von `Default` besteht darin, dass Ihr Typ\r\n" +"kann jetzt dort verwendet werden, wo eine \"Default\"-Implementierung erforderlich ist, vor allem,\r\n" +"eine der [`*or_default`-Funktionen in der Standardbibliothek][std-or-default]." + +#: src\idioms/ctor.md:101 +msgid "## See also\r" +msgstr "## Siehe auch\r" + +#: src\idioms/ctor.md:103 +msgid "" +"- The [default idiom](default.md) for a more in-depth description of the\r\n" +" `Default` trait.\r\n" +"\r\n" +"- The [builder pattern](../patterns/creational/builder.md) for constructing\r\n" +" objects where there are multiple configurations.\r\n" +"\r\n" +"- [API Guidelines/C-COMMON-TRAITS][API Guidelines/C-COMMON-TRAITS] for\r\n" +" implementing both, `Default` and `new`.\r\n" +"\r" +msgstr "" +"- Das [Standard-Idiom] (default.md) für eine ausführlichere Beschreibung des\r\n" +" `Standard`-Traits.\r\n" +"\r\n" +"- Das [Builder-Muster](../patterns/creational/builder.md) zum Konstruieren von\r\n" +" Objekten mit mehreren Konfigurationen.\r\n" +"\r\n" +"- [API-Richtlinien/C-COMMON-TRAITS][API-Richtlinien/C-COMMON-TRAITS] für\r\n" +" Implementierungen von sowohl `Default` als auch `new`.\r\n" +"\r" + +#: src\idioms/default.md:1 +msgid "# The `Default` Trait" +msgstr "# Der `Standard`-Trait" + +#: src\idioms/default.md:5 +msgid "" +"Many types in Rust have a [constructor]. However, this is _specific_ to the\n" +"type; Rust cannot abstract over \"everything that has a `new()` method\". To\n" +"allow this, the [`Default`] trait was conceived, which can be used with\n" +"containers and other generic types (e.g. see [`Option::unwrap_or_default()`]).\n" +"Notably, some containers already implement it where applicable." +msgstr "" + +#: src\idioms/default.md:11 +#, fuzzy +msgid "" +"Not only do one-element containers like `Cow`, `Box` or `Arc` implement\n" +"`Default` for contained `Default` types, one can automatically\n" +"`#[derive(Default)]` for structs whose fields all implement it, so the more\n" +"types implement `Default`, the more useful it becomes." +msgstr "" +"Nicht nur Ein-Element-Container wie `Cow`, `Box` oder `Arc` implementieren\n" +"`Default` für enthaltene `Default`-Typen kann man automatisch\n" +"`#[derive(Default)]` für Strukturen, deren Felder alle implementieren, also umso mehr\n" +"Typen implementieren `Default`, desto nützlicher wird es." + +#: src\idioms/default.md:16 +#, fuzzy +msgid "" +"On the other hand, constructors can take multiple arguments, while the\n" +"`default()` method does not. There can even be multiple constructors with\n" +"different names, but there can only be one `Default` implementation per type." +msgstr "" +"Andererseits können Konstruktoren mehrere Argumente annehmen, während die\n" +"`default()`-Methode nicht. Es können sogar mehrere Konstruktoren mit vorhanden sein\n" +"unterschiedliche Namen, aber es kann nur eine `Default`-Implementierung pro Typ geben." + +#: src\idioms/default.md:22 +msgid "" +"```rust\n" +"use std::{path::PathBuf, time::Duration};\n" +"\n" +"// note that we can simply auto-derive Default here.\n" +"#[derive(Default, Debug, PartialEq)]\n" +"struct MyConfiguration {\n" +" // Option defaults to None\n" +" output: Option,\n" +" // Vecs default to empty vector\n" +" search_path: Vec,\n" +" // Duration defaults to zero time\n" +" timeout: Duration,\n" +" // bool defaults to false\n" +" check: bool,\n" +"}\n" +"\n" +"impl MyConfiguration {\n" +" // add setters here\n" +"}\n" +"\n" +"fn main() {\n" +" // construct a new instance with default values\n" +" let mut conf = MyConfiguration::default();\n" +" // do something with conf here\n" +" conf.check = true;\n" +" println!(\"conf = {:#?}\", conf);\n" +" \n" +" // partial initialization with default values, creates the same instance\n" +" let conf1 = MyConfiguration {\n" +" check: true,\n" +" ..Default::default()\n" +" };\n" +" assert_eq!(conf, conf1);\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/default.md:60 +#, fuzzy +msgid "" +"- The [constructor] idiom is another way to generate instances that may or may\n" +" not be \"default\"\n" +"- The [`Default`] documentation (scroll down for the list of implementors)\n" +"- [`Option::unwrap_or_default()`]\n" +"- [`derive(new)`]" +msgstr "" +"- Das [constructor]-Idiom ist eine weitere Möglichkeit, Instanzen zu generieren, die können oder dürfen\n" +" nicht \"Standard\" sein\n" +"- Die [`Default`]-Dokumentation (scrollen Sie nach unten für die Liste der Implementierer)\n" +"- [`Option::unwrap_or_default()`]\n" +"- [`ableiten(neu)`]" + +#: src\idioms/deref.md:1 +msgid "# Collections are smart pointers" +msgstr "# Sammlungen sind intelligente Zeiger" + +#: src\idioms/deref.md:5 +#, fuzzy +msgid "" +"Use the [`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)\n" +"trait to treat collections like smart pointers, offering owning\n" +"and borrowed views of data." +msgstr "" +"Verwenden Sie den [`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)-Trait\n" +"um Sammlungen wie intelligente Zeiger zu behandeln und Besitz anzubieten\n" +"und geborgte Ansichten von Daten." + +#: src\idioms/deref.md:11 +msgid "" +"```rust,ignore\n" +"use std::ops::Deref;\n" +"\n" +"struct Vec {\n" +" data: RawVec,\n" +" //..\n" +"}\n" +"\n" +"impl Deref for Vec {\n" +" type Target = [T];\n" +"\n" +" fn deref(&self) -> &[T] {\n" +" //..\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/deref.md:28 +#, fuzzy +msgid "" +"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a borrowed\n" +"collection of `T`s. Implementing `Deref` for `Vec` allows implicit dereferencing\n" +"from `&Vec` to `&[T]` and includes the relationship in auto-derefencing\n" +"searches. Most methods you might expect to be implemented for `Vec`s are instead\n" +"implemented for slices." +msgstr "" +"Ein `Vec` ist eine besitzende Sammlung von `T`s, während ein Slice (`&[T]`) ein geborgtes ist\n" +"Sammlung von `T`s. Die Implementierung von `Deref` für `Vec` ermöglicht implizites Dereferenzieren\n" +"von `&Vec` bis `&[T]` und bezieht die Beziehung in die automatische Dereferenzierung ein\n" +"sucht. Die meisten Methoden, von denen Sie erwarten könnten, dass sie für `Vec`s implementiert werden, sind stattdessen\n" +"für Scheiben implementiert." + +#: src\idioms/deref.md:34 +#, fuzzy +msgid "Also `String` and `&str` have a similar relation." +msgstr "Auch `String` und `&str` haben eine ähnliche Beziehung." + +#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 +#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 src\idioms/return-consumed-arg-on-error.md:43 +#: src\patterns/behavioural/command.md:8 src\patterns/behavioural/interpreter.md:16 src\patterns/behavioural/newtype.md:56 +#: src\patterns/behavioural/RAII.md:72 src\patterns/behavioural/strategy.md:19 src\patterns/behavioural/visitor.md:72 +#: src\patterns/creational/builder.md:63 src\patterns/creational/fold.md:73 src\patterns/structural/compose-structs.md:71 +#: src\patterns/ffi/export.md:15 src\anti_patterns/borrow_clone.md:30 +msgid "## Motivation" +msgstr "## Motivation" + +#: src\idioms/deref.md:38 +#, fuzzy +msgid "" +"Ownership and borrowing are key aspects of the Rust language. Data structures\n" +"must account for these semantics properly to give a good user\n" +"experience. When implementing a data structure that owns its data, offering a\n" +"borrowed view of that data allows for more flexible APIs." +msgstr "" +"Eigentum und Ausleihen sind Schlüsselaspekte der Rust-Sprache. Datenstrukturen\n" +"muss diese Semantik richtig berücksichtigen, um einen guten Benutzer zu geben\n" +"Erfahrung. Beim Implementieren einer Datenstruktur, die ihre Daten besitzt, bietet das Anbieten von a\n" +"Die geliehene Ansicht dieser Daten ermöglicht flexiblere APIs." + +#: src\idioms/deref.md:45 +#, fuzzy +msgid "" +"Most methods can be implemented only for the borrowed view, they are then\n" +"implicitly available for the owning view." +msgstr "" +"Die meisten Methoden können nur für die geliehene Ansicht implementiert werden, das sind sie dann\n" +"für die besitzende Ansicht implizit verfügbar." + +#: src\idioms/deref.md:48 +#, fuzzy +msgid "Gives clients a choice between borrowing or taking ownership of data." +msgstr "Gibt Kunden die Wahl, ob sie Daten ausleihen oder in Besitz nehmen möchten." + +#: src\idioms/deref.md:52 +msgid "" +"Methods and traits only available via dereferencing are not taken into account\n" +"when bounds checking, so generic programming with data structures using this\n" +"pattern can get complex (see the `Borrow` and `AsRef` traits, etc.)." +msgstr "" +"Methoden und Traits, die nur über Dereferenzierung verfügbar sind, werden nicht beim\n" +"Prüfen von Grenzen berücksichtigt. Generisches Programmieren mit diesen Datenstrukturen\n" +"kann sehr komplex werden (siehe `Borrow`- und `AsRef`-Trait, usw.)." + +#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 +#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 src\patterns/behavioural/interpreter.md:103 +#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 src\patterns/behavioural/strategy.md:110 +#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 src\patterns/creational/fold.md:85 +#: src\patterns/structural/compose-structs.md:89 src\anti_patterns/deref.md:102 +msgid "## Discussion" +msgstr "## Diskussion" + +#: src\idioms/deref.md:58 +#, fuzzy +msgid "" +"Smart pointers and collections are analogous: a smart pointer points to a single\n" +"object, whereas a collection points to many objects. From the point of view of\n" +"the type system, there is little difference between the two. A collection owns\n" +"its data if the only way to access each datum is via the collection and the\n" +"collection is responsible for deleting the data (even in cases of shared\n" +"ownership, some kind of borrowed view may be appropriate). If a collection owns\n" +"its data, it is usually useful to provide a view of the data as borrowed so that\n" +"it can be referenced multiple times." +msgstr "" +"Intelligente Zeiger und Sammlungen sind analog: Ein intelligenter Zeiger zeigt auf eine einzelne\n" +"Objekt, wohingegen eine Sammlung auf viele Objekte zeigt. Aus der Sicht von\n" +"das Typensystem, es gibt wenig Unterschied zwischen den beiden. Eine Sammlung besitzt\n" +"seine Daten, wenn der Zugriff auf jedes Datum nur über die Sammlung und die möglich ist\n" +"collection ist für die Löschung der Daten verantwortlich (auch bei Shared\n" +"Besitz, eine Art geliehene Ansicht kann angemessen sein). Besitzt eine Sammlung\n" +"seiner Daten, ist es in der Regel sinnvoll, eine Ansicht der entliehenen Daten damit bereitzustellen\n" +"es kann mehrfach referenziert werden." + +#: src\idioms/deref.md:67 +#, fuzzy +msgid "" +"Most smart pointers (e.g., `Foo`) implement `Deref`. However,\n" +"collections will usually dereference to a custom type. `[T]` and `str` have some\n" +"language support, but in the general case, this is not necessary. `Foo` can\n" +"implement `Deref>` where `Bar` is a dynamically sized type and\n" +"`&Bar` is a borrowed view of the data in `Foo`." +msgstr "" +"Die meisten intelligenten Zeiger (z. B. `Foo`) implementieren `Deref`. Jedoch,\n" +"Sammlungen dereferenzieren normalerweise auf einen benutzerdefinierten Typ. `[T]` und `str` haben einige\n" +"Sprachunterstützung, aber im Allgemeinen ist dies nicht erforderlich. `Foo` kann\n" +"Implementieren Sie „Deref>“, wobei „Bar“ ein Typ mit dynamischer Größe ist und\n" +"`&Bar` ist eine geliehene Ansicht der Daten in `Foo`." + +#: src\idioms/deref.md:73 +#, fuzzy +msgid "" +"Commonly, ordered collections will implement `Index` for `Range`s to provide\n" +"slicing syntax. The target will be the borrowed view." +msgstr "" +"Üblicherweise implementieren geordnete Sammlungen „Index“, um „Range“ bereitzustellen\n" +"Slicing-Syntax. Das Ziel ist die geliehene Ansicht." + +#: src\idioms/deref.md:78 +msgid "" +"- [Deref polymorphism anti-pattern](../anti_patterns/deref.md).\n" +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +msgstr "" +"- [Deref-Polymorphismus-Antimuster](../anti_patterns/deref.md).\n" +"- [Dokumentation für den `Deref`-Trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." + +#: src\idioms/dtor-finally.md:1 +msgid "# Finalisation in destructors" +msgstr "# Finalisierung in Destruktoren" + +#: src\idioms/dtor-finally.md:5 +#, fuzzy +msgid "" +"Rust does not provide the equivalent to `finally` blocks - code that will be\n" +"executed no matter how a function is exited. Instead, an object's destructor can\n" +"be used to run code that must be run before exit." +msgstr "" +"Rust bietet nicht das Äquivalent zu \"endlich\" Blöcken - Code, der es sein wird\n" +"ausgeführt, egal wie eine Funktion beendet wird. Stattdessen kann der Destruktor eines Objekts dies tun\n" +"verwendet werden, um Code auszuführen, der vor dem Beenden ausgeführt werden muss." + +#: src\idioms/dtor-finally.md:11 +msgid "" +"```rust,ignore\n" +"fn bar() -> Result<(), ()> {\n" +" // These don't need to be defined inside the function.\n" +" struct Foo;\n" +"\n" +" // Implement a destructor for Foo.\n" +" impl Drop for Foo {\n" +" fn drop(&mut self) {\n" +" println!(\"exit\");\n" +" }\n" +" }\n" +"\n" +" // The dtor of _exit will run however the function `bar` is exited.\n" +" let _exit = Foo;\n" +" // Implicit return with `?` operator.\n" +" baz()?;\n" +" // Normal return.\n" +" Ok(())\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/dtor-finally.md:34 +#, fuzzy +msgid "" +"If a function has multiple return points, then executing code on exit becomes\n" +"difficult and repetitive (and thus bug-prone). This is especially the case where\n" +"return is implicit due to a macro. A common case is the `?` operator which\n" +"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used as\n" +"an exception handling mechanism, but unlike Java (which has `finally`), there is\n" +"no way to schedule code to run in both the normal and exceptional cases.\n" +"Panicking will also exit a function early." +msgstr "" +"Wenn eine Funktion mehrere Rückkehrpunkte hat, wird der Code beim Beenden ausgeführt\n" +"schwierig und repetitiv (und daher fehleranfällig). Dies gilt insbesondere dort, wo\n" +"return ist aufgrund eines Makros implizit. Ein häufiger Fall ist der `?`-Operator which\n" +"gibt zurück, wenn das Ergebnis ein `Err` ist, fährt aber fort, wenn es `Ok` ist. `?` wird verwendet als\n" +"einen Ausnahmebehandlungsmechanismus, aber im Gegensatz zu Java (das `finally` hat) gibt es einen\n" +"keine Möglichkeit, Code so zu planen, dass er sowohl in normalen als auch in Ausnahmefällen ausgeführt wird.\n" +"Durch Panik wird eine Funktion auch vorzeitig beendet." + +#: src\idioms/dtor-finally.md:44 +msgid "" +"Code in destructors will (nearly) always be run - copes with panics, early\n" +"returns, etc." +msgstr "" +"Code in Destruktoren wird (fast) immer ausgeführt - bewältigt `panics`\n" +"und vorzeitige Rückgaben, usw." + +#: src\idioms/dtor-finally.md:49 +#, fuzzy +msgid "" +"It is not guaranteed that destructors will run. For example, if there is an\n" +"infinite loop in a function or if running a function crashes before exit.\n" +"Destructors are also not run in the case of a panic in an already panicking\n" +"thread. Therefore, destructors cannot be relied on as finalizers where it is\n" +"absolutely essential that finalisation happens." +msgstr "" +"Es ist nicht garantiert, dass Destruktoren ausgeführt werden. Wenn es zum Beispiel eine gibt\n" +"Endlosschleife in einer Funktion oder wenn das Ausführen einer Funktion vor dem Beenden abstürzt.\n" +"Destruktoren werden auch im Falle einer Panik in einem bereits in Panik geratenen Zustand nicht ausgeführt\n" +"Gewinde. Daher kann man sich nicht auf Destruktoren als Finalizer verlassen, wo sie sind\n" +"unbedingt erforderlich, dass die Finalisierung erfolgt." + +#: src\idioms/dtor-finally.md:55 +#, fuzzy +msgid "" +"This pattern introduces some hard to notice, implicit code. Reading a function\n" +"gives no clear indication of destructors to be run on exit. This can make\n" +"debugging tricky." +msgstr "" +"Dieses Muster führt schwer erkennbaren, impliziten Code ein. Lesen einer Funktion\n" +"gibt keinen klaren Hinweis auf Destruktoren, die beim Beenden ausgeführt werden sollen. Das kann machen\n" +"debuggen knifflig." + +#: src\idioms/dtor-finally.md:59 +#, fuzzy +msgid "Requiring an object and `Drop` impl just for finalisation is heavy on boilerplate." +msgstr "Das Erfordernis eines Objekts und eines 'Drop'-Impls nur für die Finalisierung ist schwer auf der Boilerplate." + +#: src\idioms/dtor-finally.md:63 +#, fuzzy +msgid "" +"There is some subtlety about how exactly to store the object used as a\n" +"finalizer. It must be kept alive until the end of the function and must then be\n" +"destroyed. The object must always be a value or uniquely owned pointer (e.g.,\n" +"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer can\n" +"be kept alive beyond the lifetime of the function. For similar reasons, the\n" +"finalizer should not be moved or returned." +msgstr "" +"Es gibt einige Feinheiten, wie genau das Objekt gespeichert werden soll, das als verwendet wird\n" +"Finalisierer. Es muss bis zum Ende der Funktion am Leben erhalten werden und muss dann sein\n" +"zerstört. Das Objekt muss immer ein Wert oder ein eindeutiger Zeiger sein (z. B.\n" +"`Box`). Wenn ein gemeinsam genutzter Zeiger (wie „Rc“) verwendet wird, dann kann der Finalizer\n" +"über die Lebensdauer der Funktion hinaus am Leben erhalten werden. Aus ähnlichen Gründen ist die\n" +"Finalizer sollte nicht bewegt oder zurückgegeben werden." + +#: src\idioms/dtor-finally.md:70 +#, fuzzy +msgid "" +"The finalizer must be assigned into a variable, otherwise it will be destroyed\n" +"immediately, rather than when it goes out of scope. The variable name must start\n" +"with `_` if the variable is only used as a finalizer, otherwise the compiler\n" +"will warn that the finalizer is never used. However, do not call the variable\n" +"`_` with no suffix - in that case it will be destroyed immediately." +msgstr "" +"Der Finalizer muss einer Variablen zugewiesen werden, sonst wird er zerstört\n" +"sofort, anstatt wenn es den Geltungsbereich verlässt. Der Variablenname muss beginnen\n" +"mit `_` wenn die Variable nur als Finalizer verwendet wird, sonst der Compiler\n" +"wird warnen, dass der Finalizer nie verwendet wird. Rufen Sie die Variable jedoch nicht auf\n" +"`_` ohne Suffix - in diesem Fall wird es sofort zerstört." + +#: src\idioms/dtor-finally.md:76 +#, fuzzy +msgid "" +"In Rust, destructors are run when an object goes out of scope. This happens\n" +"whether we reach the end of block, there is an early return, or the program\n" +"panics. When panicking, Rust unwinds the stack running destructors for each\n" +"object in each stack frame. So, destructors get called even if the panic happens\n" +"in a function being called." +msgstr "" +"In Rust werden Destruktoren ausgeführt, wenn ein Objekt den Gültigkeitsbereich verlässt. Das passiert\n" +"ob wir das Ende des Blocks erreichen, gibt es eine vorzeitige Rückkehr oder das Programm\n" +"Panik. Wenn es in Panik gerät, wickelt Rust den Stack ab und führt Destruktoren für jeden aus\n" +"Objekt in jedem Stapelrahmen. Destruktoren werden also auch dann aufgerufen, wenn die Panik auftritt\n" +"in einer aufgerufenen Funktion." + +#: src\idioms/dtor-finally.md:82 +#, fuzzy +msgid "" +"If a destructor panics while unwinding, there is no good action to take, so Rust\n" +"aborts the thread immediately, without running further destructors. This means\n" +"that destructors are not absolutely guaranteed to run. It also means that you\n" +"must take extra care in your destructors not to panic, since it could leave\n" +"resources in an unexpected state." +msgstr "" +"Wenn ein Destruktor beim Abwickeln in Panik gerät, gibt es keine gute Maßnahme, so Rust\n" +"bricht den Thread sofort ab, ohne weitere Destruktoren auszuführen. Das heisst\n" +"dass Destruktoren nicht absolut garantiert laufen. Es bedeutet auch, dass Sie\n" +"müssen Sie bei Ihren Destruktoren besonders darauf achten, nicht in Panik zu geraten, da dies passieren könnte\n" +"Ressourcen in einem unerwarteten Zustand." + +#: src\idioms/dtor-finally.md:90 +msgid "[RAII guards](../patterns/behavioural/RAII.md)." +msgstr "[RAII-Wächter](../patterns/behavioral/RAII.md)." + +#: src\idioms/mem-replace.md:1 +#, fuzzy +msgid "# `mem::{take(_), replace(_)}` to keep owned values in changed enums" +msgstr "# `mem::{take(_), replace(_)}` um eigene Werte in geänderten Aufzählungen zu behalten" + +#: src\idioms/mem-replace.md:5 +#, fuzzy +msgid "" +"Say we have a `&mut MyEnum` which has (at least) two variants,\n" +"`A { name: String, x: u8 }` and `B { name: String }`. Now we want to change\n" +"`MyEnum::A` to a `B` if `x` is zero, while keeping `MyEnum::B` intact." +msgstr "" +"Angenommen, wir haben ein `&mut MyEnum`, das (mindestens) zwei Varianten hat,\n" +"`A { Name: String, x: u8 }` und `B { Name: String }`. Jetzt wollen wir uns ändern\n" +"`MyEnum::A` zu einem `B` wenn `x` Null ist, während `MyEnum::B` intakt bleibt." + +#: src\idioms/mem-replace.md:9 +msgid "We can do this without cloning the `name`." +msgstr "Wir können dies tun, ohne `name` zu klonen." + +#: src\idioms/mem-replace.md:13 +msgid "" +"```rust\n" +"use std::mem;\n" +"\n" +"enum MyEnum {\n" +" A { name: String, x: u8 },\n" +" B { name: String }\n" +"}\n" +"\n" +"fn a_to_b(e: &mut MyEnum) {\n" +" if let MyEnum::A { name, x: 0 } = e {\n" +" // this takes out our `name` and put in an empty String instead\n" +" // (note that empty strings don't allocate).\n" +" // Then, construct the new enum variant (which will\n" +" // be assigned to `*e`).\n" +" *e = MyEnum::B { name: mem::take(name) }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/mem-replace.md:32 +msgid "This also works with more variants:" +msgstr "Das funktioniert auch mit mehr Varianten:" + +#: src\idioms/mem-replace.md:34 +msgid "" +"```rust\n" +"use std::mem;\n" +"\n" +"enum MultiVariateEnum {\n" +" A { name: String },\n" +" B { name: String },\n" +" C,\n" +" D\n" +"}\n" +"\n" +"fn swizzle(e: &mut MultiVariateEnum) {\n" +" use MultiVariateEnum::*;\n" +" *e = match e {\n" +" // Ownership rules do not allow taking `name` by value, but we cannot\n" +" // take the value out of a mutable reference, unless we replace it:\n" +" A { name } => B { name: mem::take(name) },\n" +" B { name } => A { name: mem::take(name) },\n" +" C => D,\n" +" D => C\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/mem-replace.md:59 +#, fuzzy +msgid "" +"When working with enums, we may want to change an enum value in place, perhaps\n" +"to another variant. This is usually done in two phases to keep the borrow\n" +"checker happy. In the first phase, we observe the existing value and look at\n" +"its parts to decide what to do next. In the second phase we may conditionally\n" +"change the value (as in the example above)." +msgstr "" +"Wenn wir mit Aufzählungen arbeiten, möchten wir vielleicht einen Aufzählungswert an Ort und Stelle ändern\n" +"zu einer anderen Variante. Dies geschieht in der Regel in zwei Phasen, um den Kredit zu behalten\n" +"Prüfer glücklich. In der ersten Phase beobachten wir den bestehenden Wert und schauen uns an\n" +"seine Teile, um zu entscheiden, was als nächstes zu tun ist. In der zweiten Phase dürfen wir bedingt\n" +"ändern Sie den Wert (wie im obigen Beispiel)." + +#: src\idioms/mem-replace.md:65 +#, fuzzy +msgid "" +"The borrow checker won't allow us to take out `name` of the enum (because\n" +"_something_ must be there.) We could of course `.clone()` name and put the clone\n" +"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md) anti-" +"pattern. Anyway, we\n" +"can avoid the extra allocation by changing `e` with only a mutable borrow." +msgstr "" +"Der Borrow-Checker erlaubt uns nicht, `name` aus der Aufzählung herauszunehmen (weil\n" +"_irgendwas_ muss da sein.) Wir könnten natürlich `.clone()` benennen und den Klon setzen\n" +"in unser `MyEnum::B`, aber das wäre eine Instanz des Antimuster [Klonen, um den Borrow-Checker zu erfüllen](../anti_patterns/borrow_clone." +"md). Jedenfalls wir\n" +"kann die zusätzliche Zuweisung vermeiden, indem `e` nur mit einem veränderlichen Borgen geändert wird." + +#: src\idioms/mem-replace.md:70 +#, fuzzy +msgid "" +"`mem::take` lets us swap out the value, replacing it with it's default value,\n" +"and returning the previous value. For `String`, the default value is an empty\n" +"`String`, which does not need to allocate. As a result, we get the original\n" +"`name` _as an owned value_. We can then wrap this in another enum." +msgstr "" +"`mem::take` lässt uns den Wert austauschen und durch seinen Standardwert ersetzen,\n" +"und Rückgabe des vorherigen Werts. Für „String“ ist der Standardwert leer\n" +"`String`, der nicht zugewiesen werden muss. Als Ergebnis erhalten wir das Original\n" +"`name` _als eigener Wert_. Wir können dies dann in eine andere Aufzählung packen." + +#: src\idioms/mem-replace.md:75 +#, fuzzy +msgid "" +"**NOTE:** `mem::replace` is very similar, but allows us to specify what to\n" +"replace the value with. An equivalent to our `mem::take` line would be\n" +"`mem::replace(name, String::new())`." +msgstr "" +"**HINWEIS:** `mem::replace` ist sehr ähnlich, erlaubt uns aber anzugeben, was zu tun ist\n" +"Ersetzen Sie den Wert durch. Ein Äquivalent zu unserer `mem::take`-Zeile wäre\n" +"`mem::replace(name, String::new())`." + +#: src\idioms/mem-replace.md:79 +#, fuzzy +msgid "" +"Note, however, that if we are using an `Option` and want to replace its\n" +"value with a `None`, `Option`’s `take()` method provides a shorter and\n" +"more idiomatic alternative." +msgstr "" +"Beachten Sie jedoch, dass, wenn wir eine `Option` verwenden und diese ersetzen möchten\n" +"Wert mit einem `None`, die `take()`-Methode von `Option` liefert ein kürzeres and\n" +"idiomatischere Alternative." + +#: src\idioms/mem-replace.md:85 +msgid "Look ma, no allocation! Also you may feel like Indiana Jones while doing it." +msgstr "Guck ma, keine Zuordnung! Wir können uns dabei wie Indiana Jones fühlen." + +#: src\idioms/mem-replace.md:89 +#, fuzzy +msgid "" +"This gets a bit wordy. Getting it wrong repeatedly will make you hate the\n" +"borrow checker. The compiler may fail to optimize away the double store,\n" +"resulting in reduced performance as opposed to what you'd do in unsafe\n" +"languages." +msgstr "" +"Das wird etwas wortreich. Wenn Sie es wiederholt falsch machen, werden Sie das hassen\n" +"Prüfer ausleihen. Der Compiler kann den doppelten Speicher möglicherweise nicht wegoptimieren,\n" +"was zu einer verringerten Leistung im Gegensatz zu dem führt, was Sie in unsicherem Zustand tun würden\n" +"Sprachen." + +#: src\idioms/mem-replace.md:94 +msgid "" +"Furthermore, the type you are taking needs to implement the [`Default` trait](./default.md). However, if the type you're working with " +"doesn't\n" +"implement this, you can instead use `mem::replace`." +msgstr "" +"Darüber hinaus muss der von Ihnen gewählte Typ den [`Default` Trait](./default.md) implementieren. Wenn der Typ, mit dem Sie arbeiten,\n" +"dies jedoch nicht tut, können Sie stattdessen `mem::replace` verwenden." + +#: src\idioms/mem-replace.md:99 +#, fuzzy +msgid "" +"This pattern is only of interest in Rust. In GC'd languages, you'd take the\n" +"reference to the value by default (and the GC would keep track of refs), and in\n" +"other low-level languages like C you'd simply alias the pointer and fix things\n" +"later." +msgstr "" +"Dieses Muster ist nur für Rust interessant. In GC-Sprachen würden Sie die nehmen\n" +"Verweis auf den Wert standardmäßig (und der GC würde die Verweise verfolgen) und in\n" +"In anderen Low-Level-Sprachen wie C würden Sie einfach den Zeiger aliasieren und die Dinge reparieren\n" +"später." + +#: src\idioms/mem-replace.md:104 +#, fuzzy +msgid "" +"However, in Rust, we have to do a little more work to do this. An owned value\n" +"may only have one owner, so to take it out, we need to put something back in –\n" +"like Indiana Jones, replacing the artifact with a bag of sand." +msgstr "" +"Dafür müssen wir in Rust allerdings noch etwas mehr Arbeit leisten. Ein eigener Wert\n" +"kann nur einen Besitzer haben, also müssen wir etwas wieder hineinstecken, um es herauszunehmen -\n" +"wie Indiana Jones das Artefakt durch einen Sandsack ersetzen." + +#: src\idioms/mem-replace.md:110 +#, fuzzy +msgid "" +"This gets rid of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md)\n" +"anti-pattern in a specific case." +msgstr "" +"Dadurch wird [Klonen, um die Leihprüfung zu erfüllen](../anti_patterns/borrow_clone.md) entfernt.\n" +"Antimuster in einem bestimmten Fall." + +#: src\idioms/on-stack-dyn-dispatch.md:1 +#, fuzzy +msgid "# On-Stack Dynamic Dispatch" +msgstr "# Dynamischer On-Stack-Versand" + +#: src\idioms/on-stack-dyn-dispatch.md:5 +#, fuzzy +msgid "" +"We can dynamically dispatch over multiple values, however, to do so, we need\n" +"to declare multiple variables to bind differently-typed objects. To extend the\n" +"lifetime as necessary, we can use deferred conditional initialization, as seen\n" +"below:" +msgstr "" +"Wir können dynamisch mehrere Werte versenden, aber dazu brauchen wir\n" +"um mehrere Variablen zu deklarieren, um unterschiedlich typisierte Objekte zu binden. Zur Verlängerung der\n" +"wie erforderlich, können wir, wie gesehen, eine verzögerte bedingte Initialisierung verwenden\n" +"unter:" + +#: src\idioms/on-stack-dyn-dispatch.md:12 +msgid "" +"```rust\n" +"use std::io;\n" +"use std::fs;\n" +"\n" +"# fn main() -> Result<(), Box> {\n" +"# let arg = \"-\";\n" +"\n" +"// These must live longer than `readable`, and thus are declared first:\n" +"let (mut stdin_read, mut file_read);\n" +"\n" +"// We need to ascribe the type to get dynamic dispatch.\n" +"let readable: &mut dyn io::Read = if arg == \"-\" {\n" +" stdin_read = io::stdin();\n" +" &mut stdin_read\n" +"} else {\n" +" file_read = fs::File::open(arg)?;\n" +" &mut file_read\n" +"};\n" +"\n" +"// Read from `readable` here.\n" +"\n" +"# Ok(())\n" +"# }\n" +"```" +msgstr "" + +#: src\idioms/on-stack-dyn-dispatch.md:39 +#, fuzzy +msgid "" +"Rust monomorphises code by default. This means a copy of the code will be\n" +"generated for each type it is used with and optimized independently. While this\n" +"allows for very fast code on the hot path, it also bloats the code in places\n" +"where performance is not of the essence, thus costing compile time and cache\n" +"usage." +msgstr "" +"Rust monomorphisiert Code standardmäßig. Dies bedeutet, dass eine Kopie des Codes sein wird\n" +"für jeden Typ, mit dem es verwendet wird, generiert und unabhängig optimiert. Während dies\n" +"ermöglicht sehr schnellen Code auf dem heißen Pfad, es bläht den Code auch stellenweise auf\n" +"wo die Leistung nicht von entscheidender Bedeutung ist, wodurch Kompilierzeit und Cache gekostet werden\n" +"Verwendung." + +#: src\idioms/on-stack-dyn-dispatch.md:45 +#, fuzzy +msgid "" +"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly ask\n" +"for it." +msgstr "" +"Glücklicherweise erlaubt uns Rust, den dynamischen Versand zu verwenden, aber wir müssen ausdrücklich darum bitten\n" +"dafür." + +#: src\idioms/on-stack-dyn-dispatch.md:50 +#, fuzzy +msgid "" +"We do not need to allocate anything on the heap. Neither do we need to\n" +"initialize something we won't use later, nor do we need to monomorphize the\n" +"whole code that follows to work with both `File` or `Stdin`." +msgstr "" +"Wir müssen dem Heap nichts zuweisen. Brauchen wir auch nicht\n" +"etwas initialisieren, das wir später nicht verwenden werden, noch müssen wir das monomorphisieren\n" +"gesamten folgenden Code, um sowohl mit `File` als auch mit `Stdin` zu arbeiten." + +#: src\idioms/on-stack-dyn-dispatch.md:56 +#, fuzzy +msgid "The code needs more moving parts than the `Box`-based version:" +msgstr "Der Code benötigt mehr bewegliche Teile als die `Box`-basierte Version:" + +#: src\idioms/on-stack-dyn-dispatch.md:58 +msgid "" +"```rust,ignore\n" +"// We still need to ascribe the type for dynamic dispatch.\n" +"let readable: Box = if arg == \"-\" {\n" +" Box::new(io::stdin())\n" +"} else {\n" +" Box::new(fs::File::open(arg)?)\n" +"};\n" +"// Read from `readable` here.\n" +"```" +msgstr "" + +#: src\idioms/on-stack-dyn-dispatch.md:70 +#, fuzzy +msgid "" +"Rust newcomers will usually learn that Rust requires all variables to be\n" +"initialized _before use_, so it's easy to overlook the fact that _unused_\n" +"variables may well be uninitialized. Rust works quite hard to ensure that this\n" +"works out fine and only the initialized values are dropped at the end of their\n" +"scope." +msgstr "" +"Rust-Neulinge werden normalerweise lernen, dass Rust alle Variablen voraussetzt\n" +"initialisiert _vor der Verwendung_, daher kann man leicht übersehen, dass _unused_\n" +"Variablen können durchaus nicht initialisiert sein. Rust arbeitet ziemlich hart daran, dies sicherzustellen\n" +"funktioniert gut und nur die initialisierten Werte werden am Ende ihrer gelöscht\n" +"Umfang." + +#: src\idioms/on-stack-dyn-dispatch.md:76 +msgid "The example meets all the constraints Rust places on us:" +msgstr "Das Beispiel erfüllt alle Einschränkungen, die Rust uns auferlegt:" + +#: src\idioms/on-stack-dyn-dispatch.md:78 +#, fuzzy +msgid "" +"- All variables are initialized before using (in this case borrowing) them\n" +"- Each variable only holds values of a single type. In our example, `stdin` is\n" +" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut dyn Read`\n" +"- Each borrowed value outlives all the references borrowed from it" +msgstr "" +"- Alle Variablen werden vor der Verwendung (in diesem Fall dem Ausleihen) initialisiert\n" +"- Jede Variable enthält nur Werte eines einzigen Typs. In unserem Beispiel ist `stdin`\n" +" vom Typ `Stdin`, `file` ist vom Typ `File` und `readable` ist vom Typ `&mut dyn Read`\n" +"- Jeder geliehene Wert überdauert alle von ihm geliehenen Referenzen" + +#: src\idioms/on-stack-dyn-dispatch.md:85 +#, fuzzy +msgid "" +"- [Finalisation in destructors](dtor-finally.md) and\n" +" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight control over\n" +" lifetimes.\n" +"- For conditionally filled `Option<&T>`s of (mutable) references, one can\n" +" initialize an `Option` directly and use its [`.as_ref()`] method to get an\n" +" optional reference." +msgstr "" +"- [Finalisierung in Destruktoren](dtor-finally.md) und\n" +" [RAII-Wächter](../patterns/behavioural/RAII.md) können von einer strengen Kontrolle profitieren\n" +" Lebenszeiten.\n" +"- Für bedingt gefüllte `Option<&T>`s von (veränderlichen) Referenzen kann man\n" +" Initialisieren Sie eine `Option` direkt und verwenden Sie ihre [`.as_ref()`]-Methode, um eine zu erhalten\n" +" optionale Referenz." + +#: src\idioms/ffi/intro.md:1 +msgid "# FFI Idioms" +msgstr "# FFI-Idiome" + +#: src\idioms/ffi/intro.md:3 +#, fuzzy +msgid "" +"Writing FFI code is an entire course in itself.\n" +"However, there are several idioms here that can act as pointers, and avoid\n" +"traps for inexperienced users of `unsafe` Rust." +msgstr "" +"Das Schreiben von FFI-Code ist ein ganzer Kurs für sich.\n" +"Allerdings gibt es hier mehrere Redewendungen, die als Hinweise dienen und vermeiden können\n" +"Fallen für unerfahrene Benutzer von „unsicherem“ Rust." + +#: src\idioms/ffi/intro.md:7 +#, fuzzy +msgid "This section contains idioms that may be useful when doing FFI." +msgstr "Dieser Abschnitt enthält Redewendungen, die bei der Durchführung von FFI nützlich sein können." + +#: src\idioms/ffi/intro.md:9 +#, fuzzy +msgid "" +"1. [Idiomatic Errors](./errors.md) - Error handling with integer codes and\n" +" sentinel return values (such as `NULL` pointers)\n" +"\n" +"2. [Accepting Strings](./accepting-strings.md) with minimal unsafe code\n" +"\n" +"3. [Passing Strings](./passing-strings.md) to FFI functions" +msgstr "" +"1. [Idiomatische Fehler](./errors.md) - Fehlerbehandlung mit Integer-Codes und\n" +" Sentinel-Rückgabewerte (z. B. `NULL`-Zeiger)\n" +"\n" +"2. [Accepting Strings](./accepting-strings.md) mit minimalem unsicherem Code\n" +"\n" +"3. [Passing Strings](./passing-strings.md) an FFI-Funktionen" + +#: src\idioms/ffi/errors.md:1 +msgid "# Error Handling in FFI" +msgstr "# Fehlerbehandlung in FFI" + +#: src\idioms/ffi/errors.md:5 +#, fuzzy +msgid "" +"In foreign languages like C, errors are represented by return codes.\n" +"However, Rust's type system allows much more rich error information to be\n" +"captured and propogated through a full type." +msgstr "" +"In Fremdsprachen wie C werden Fehler durch Rückgabecodes dargestellt.\n" +"Das Typsystem von Rust erlaubt jedoch viel reichhaltigere Fehlerinformationen\n" +"eingefangen und durch einen vollständigen Typ verbreitet." + +#: src\idioms/ffi/errors.md:9 +#, fuzzy +msgid "" +"This best practice shows different kinds of error codes, and how to expose them\n" +"in a usable way:" +msgstr "" +"Diese bewährte Methode zeigt verschiedene Arten von Fehlercodes und wie sie angezeigt werden\n" +"auf brauchbare Weise:" + +#: src\idioms/ffi/errors.md:12 +#, fuzzy +msgid "" +"1. Flat Enums should be converted to integers and returned as codes.\n" +"2. Structured Enums should be converted to an integer code with a string error\n" +" message for detail.\n" +"3. Custom Error Types should become \"transparent\", with a C representation." +msgstr "" +"1. Flat Enums sollten in Ganzzahlen konvertiert und als Codes zurückgegeben werden.\n" +"2. Strukturierte Enums sollten mit einem String-Fehler in einen Integer-Code konvertiert werden\n" +" Nachricht für Details.\n" +"3. Benutzerdefinierte Fehlertypen sollten \"transparent\" werden, mit einer C-Darstellung." + +#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 +#: src\patterns/ffi/wrappers.md:23 +msgid "## Code Example" +msgstr "## Codebeispiel" + +#: src\idioms/ffi/errors.md:19 +msgid "### Flat Enums" +msgstr "### Flache Aufzählungen" + +#: src\idioms/ffi/errors.md:21 +msgid "" +"```rust,ignore\n" +"enum DatabaseError {\n" +" IsReadOnly = 1, // user attempted a write operation\n" +" IOError = 2, // user should read the C errno() for what it was\n" +" FileCorrupted = 3, // user should run a repair tool to recover it\n" +"}\n" +"\n" +"impl From for libc::c_int {\n" +" fn from(e: DatabaseError) -> libc::c_int {\n" +" (e as i8).into()\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/errors.md:35 +msgid "### Structured Enums" +msgstr "### Strukturierte Aufzählungen" + +#: src\idioms/ffi/errors.md:37 +msgid "" +"```rust,ignore\n" +"pub mod errors {\n" +" enum DatabaseError {\n" +" IsReadOnly,\n" +" IOError(std::io::Error),\n" +" FileCorrupted(String), // message describing the issue\n" +" }\n" +"\n" +" impl From for libc::c_int {\n" +" fn from(e: DatabaseError) -> libc::c_int {\n" +" match e {\n" +" DatabaseError::IsReadOnly => 1,\n" +" DatabaseError::IOError(_) => 2,\n" +" DatabaseError::FileCorrupted(_) => 3,\n" +" }\n" +" }\n" +" }\n" +"}\n" +"\n" +"pub mod c_api {\n" +" use super::errors::DatabaseError;\n" +"\n" +" #[no_mangle]\n" +" pub extern \"C\" fn db_error_description(\n" +" e: *const DatabaseError\n" +" ) -> *mut libc::c_char {\n" +"\n" +" let error: &DatabaseError = unsafe {\n" +" // SAFETY: pointer lifetime is greater than the current stack frame\n" +" &*e\n" +" };\n" +"\n" +" let error_str: String = match error {\n" +" DatabaseError::IsReadOnly => {\n" +" format!(\"cannot write to read-only database\");\n" +" }\n" +" DatabaseError::IOError(e) => {\n" +" format!(\"I/O Error: {}\", e);\n" +" }\n" +" DatabaseError::FileCorrupted(s) => {\n" +" format!(\"File corrupted, run repair: {}\", &s);\n" +" }\n" +" };\n" +"\n" +" let c_error = unsafe {\n" +" // SAFETY: copying error_str to an allocated buffer with a NUL\n" +" // character at the end\n" +" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as *mut _;\n" +"\n" +" if malloc.is_null() {\n" +" return std::ptr::null_mut();\n" +" }\n" +"\n" +" let src = error_str.as_bytes().as_ptr();\n" +"\n" +" std::ptr::copy_nonoverlapping(src, malloc, error_str.len());\n" +"\n" +" std::ptr::write(malloc.add(error_str.len()), 0);\n" +"\n" +" malloc as *mut libc::c_char\n" +" };\n" +"\n" +" c_error\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/errors.md:104 +msgid "### Custom Error Types" +msgstr "### Benutzerdefinierte Fehlertypen" + +#: src\idioms/ffi/errors.md:106 +msgid "" +"```rust,ignore\n" +"struct ParseError {\n" +" expected: char,\n" +" line: u32,\n" +" ch: u16\n" +"}\n" +"\n" +"impl ParseError { /* ... */ }\n" +"\n" +"/* Create a second version which is exposed as a C structure */\n" +"#[repr(C)]\n" +"pub struct parse_error {\n" +" pub expected: libc::c_char,\n" +" pub line: u32,\n" +" pub ch: u16\n" +"}\n" +"\n" +"impl From for parse_error {\n" +" fn from(e: ParseError) -> parse_error {\n" +" let ParseError { expected, line, ch } = e;\n" +" parse_error { expected, line, ch }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/errors.md:133 +#, fuzzy +msgid "" +"This ensures that the foreign language has clear access to error information\n" +"while not compromising the Rust code's API at all." +msgstr "" +"Dadurch wird sichergestellt, dass die Fremdsprache einen eindeutigen Zugriff auf Fehlerinformationen hat\n" +"ohne die API des Rust-Codes zu gefährden." + +#: src\idioms/ffi/errors.md:138 +msgid "" +"It's a lot of typing, and some types may not be able to be converted easily\n" +"to C." +msgstr "" +"Es ist eine Menge Tipparbeit und einige Typen können möglicherweise nicht einfach nach C\n" +"konvertiert werden." + +#: src\idioms/ffi/accepting-strings.md:1 +msgid "# Accepting Strings" +msgstr "# Akzeptieren von Zeichenketten" + +#: src\idioms/ffi/accepting-strings.md:5 +msgid "" +"When accepting strings via FFI through pointers, there are two principles that\n" +"should be followed:" +msgstr "" +"Beim Akzeptieren von Zeichenfolgen über FFI durch Zeiger gibt es zwei Prinzipien\n" +"befolgt werden sollten:" + +#: src\idioms/ffi/accepting-strings.md:8 +#, fuzzy +msgid "" +"1. Keep foreign strings \"borrowed\", rather than copying them directly.\n" +"2. Minimize the amount of complexity and `unsafe` code involved in converting\n" +" from a C-style string to native Rust strings." +msgstr "" +"1. Fremde Strings „ausgeliehen“ halten, anstatt sie direkt zu kopieren.\n" +"2. Minimieren Sie die Komplexität und den \"unsicheren\" Code, der mit der Konvertierung verbunden ist\n" +" von einer C-Style-Saite zu nativen Rust-Saiten." + +#: src\idioms/ffi/accepting-strings.md:14 +#, fuzzy +msgid "The strings used in C have different behaviours to those used in Rust, namely:" +msgstr "Die in C verwendeten Strings haben ein anderes Verhalten als die in Rust verwendeten, nämlich:" + +#: src\idioms/ffi/accepting-strings.md:16 +#, fuzzy +msgid "" +"- C strings are null-terminated while Rust strings store their length\n" +"- C strings can contain any arbitrary non-zero byte while Rust strings must be\n" +" UTF-8\n" +"- C strings are accessed and manipulated using `unsafe` pointer operations\n" +" while interactions with Rust strings go through safe methods" +msgstr "" +"- C-Strings sind nullterminiert, während Rust-Strings ihre Länge speichern\n" +"- C-Strings können jedes beliebige Nicht-Null-Byte enthalten, während Rust-Strings dies sein müssen\n" +" UTF-8\n" +"- Auf C-Strings wird mit \"unsicheren\" Zeigeroperationen zugegriffen und sie manipuliert\n" +" während Interaktionen mit Rust-Strings sichere Methoden durchlaufen" + +#: src\idioms/ffi/accepting-strings.md:22 +#, fuzzy +msgid "" +"The Rust standard library comes with C equivalents of Rust's `String` and `&str`\n" +"called `CString` and `&CStr`, that allow us to avoid a lot of the complexity\n" +"and `unsafe` code involved in converting between C strings and Rust strings." +msgstr "" +"Die Rust-Standardbibliothek enthält C-Äquivalente von Rusts `String` und `&str`\n" +"namens `CString` und `&CStr`, die es uns ermöglichen, einen Großteil der Komplexität zu vermeiden\n" +"und „unsicherer“ Code, der an der Konvertierung zwischen C-Strings und Rust-Strings beteiligt ist." + +#: src\idioms/ffi/accepting-strings.md:26 +#, fuzzy +msgid "" +"The `&CStr` type also allows us to work with borrowed data, meaning passing\n" +"strings between Rust and C is a zero-cost operation." +msgstr "" +"Der Typ `&CStr` ermöglicht es uns auch, mit geborgten Daten zu arbeiten, also zu übergeben\n" +"Strings zwischen Rust und C ist ein Null-Kosten-Vorgang." + +#: src\idioms/ffi/accepting-strings.md:31 +msgid "" +"```rust,ignore\n" +"pub mod unsafe_module {\n" +"\n" +" // other module content\n" +"\n" +" /// Log a message at the specified level.\n" +" ///\n" +" /// # Safety\n" +" ///\n" +" /// It is the caller's guarantee to ensure `msg`:\n" +" ///\n" +" /// - is not a null pointer\n" +" /// - points to valid, initialized data\n" +" /// - points to memory ending in a null byte\n" +" /// - won't be mutated for the duration of this function call\n" +" #[no_mangle]\n" +" pub unsafe extern \"C\" fn mylib_log(\n" +" msg: *const libc::c_char,\n" +" level: libc::c_int\n" +" ) {\n" +" let level: crate::LogLevel = match level { /* ... */ };\n" +"\n" +" // SAFETY: The caller has already guaranteed this is okay (see the\n" +" // `# Safety` section of the doc-comment).\n" +" let msg_str: &str = match std::ffi::CStr::from_ptr(msg).to_str() {\n" +" Ok(s) => s,\n" +" Err(e) => {\n" +" crate::log_error(\"FFI string conversion failed\");\n" +" return;\n" +" }\n" +" };\n" +"\n" +" crate::log(msg_str, level);\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/accepting-strings.md:70 +msgid "The example is is written to ensure that:" +msgstr "Das Beispiel wurde geschrieben, um sicherzustellen, dass:" + +#: src\idioms/ffi/accepting-strings.md:72 +#, fuzzy +msgid "" +"1. The `unsafe` block is as small as possible.\n" +"2. The pointer with an \"untracked\" lifetime becomes a \"tracked\" shared\n" +" reference" +msgstr "" +"1. Der \"unsichere\" Block ist so klein wie möglich.\n" +"2. Der Pointer mit einer \"nicht nachverfolgten\" Lebensdauer wird zu einem \"nachverfolgten\" Shared\n" +" Referenz" + +#: src\idioms/ffi/accepting-strings.md:76 +msgid "Consider an alternative, where the string is actually copied:" +msgstr "Schauen wir uns nun eine Alternative an, bei der die Zeichenfolge tatsächlich kopiert wird:" + +#: src\idioms/ffi/accepting-strings.md:78 +msgid "" +"```rust,ignore\n" +"pub mod unsafe_module {\n" +"\n" +" // other module content\n" +"\n" +" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: libc::c_int) {\n" +" // DO NOT USE THIS CODE.\n" +" // IT IS UGLY, VERBOSE, AND CONTAINS A SUBTLE BUG.\n" +"\n" +" let level: crate::LogLevel = match level { /* ... */ };\n" +"\n" +" let msg_len = unsafe { /* SAFETY: strlen is what it is, I guess? */\n" +" libc::strlen(msg)\n" +" };\n" +"\n" +" let mut msg_data = Vec::with_capacity(msg_len + 1);\n" +"\n" +" let msg_cstr: std::ffi::CString = unsafe {\n" +" // SAFETY: copying from a foreign pointer expected to live\n" +" // for the entire stack frame into owned memory\n" +" std::ptr::copy_nonoverlapping(msg, msg_data.as_mut(), msg_len);\n" +"\n" +" msg_data.set_len(msg_len + 1);\n" +"\n" +" std::ffi::CString::from_vec_with_nul(msg_data).unwrap()\n" +" }\n" +"\n" +" let msg_str: String = unsafe {\n" +" match msg_cstr.into_string() {\n" +" Ok(s) => s,\n" +" Err(e) => {\n" +" crate::log_error(\"FFI string conversion failed\");\n" +" return;\n" +" }\n" +" }\n" +" };\n" +"\n" +" crate::log(&msg_str, level);\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/accepting-strings.md:120 +msgid "This code in inferior to the original in two respects:" +msgstr "Dieser Code ist dem Original in zweierlei Hinsicht unterlegen:" + +#: src\idioms/ffi/accepting-strings.md:122 +#, fuzzy +msgid "" +"1. There is much more `unsafe` code, and more importantly, more invariants it\n" +" must uphold.\n" +"2. Due to the extensive arithmetic required, there is a bug in this version\n" +" that cases Rust `undefined behaviour`." +msgstr "" +"1. Es gibt viel mehr \"unsicheren\" Code und, was noch wichtiger ist, mehr Invarianten\n" +" aufrechterhalten muss.\n" +"2. Aufgrund der erforderlichen umfangreichen Arithmetik enthält diese Version einen Fehler\n" +" in diesem Fall ist Rust 'undefiniertes Verhalten'." + +#: src\idioms/ffi/accepting-strings.md:127 +#, fuzzy +msgid "" +"The bug here is a simple mistake in pointer arithmetic: the string was copied,\n" +"all `msg_len` bytes of it. However, the `NUL` terminator at the end was not." +msgstr "" +"Der Fehler hier ist ein einfacher Fehler in der Zeigerarithmetik: Die Zeichenfolge wurde kopiert,\n" +"alle `msg_len` Bytes davon. Das `NUL`-Terminator am Ende war es jedoch nicht." + +#: src\idioms/ffi/accepting-strings.md:130 +#, fuzzy +msgid "" +"The Vector then had its size _set_ to the length of the _zero padded string_ --\n" +"rather than _resized_ to it, which could have added a zero at the end.\n" +"As a result, the last byte in the Vector is uninitialized memory.\n" +"When the `CString` is created at the bottom of the block, its read of the\n" +"Vector will cause `undefined behaviour`!" +msgstr "" +"Die Größe des Vektors wurde dann auf die Länge der _Null-aufgefüllten Zeichenfolge_ eingestellt --\n" +"anstatt es zu verkleinern, was am Ende eine Null hätte hinzufügen können.\n" +"Als Ergebnis ist das letzte Byte im Vektor ein nicht initialisierter Speicher.\n" +"Wenn der `CString` am Ende des Blocks erstellt wird, liest er die\n" +"Vektor verursacht `undefiniertes Verhalten`!" + +#: src\idioms/ffi/accepting-strings.md:136 +#, fuzzy +msgid "" +"Like many such issues, this would be difficult issue to track down.\n" +"Sometimes it would panic because the string was not `UTF-8`, sometimes it would\n" +"put a weird character at the end of the string, sometimes it would just\n" +"completely crash." +msgstr "" +"Wie viele solcher Probleme wäre es schwierig, dieses Problem aufzuspüren.\n" +"Manchmal kam es zu Panik, weil die Zeichenfolge nicht `UTF-8` war, manchmal jedoch\n" +"Setzen Sie ein seltsames Zeichen an das Ende der Zeichenfolge, manchmal würde es einfach\n" +"komplett abstürzen." + +#: src\idioms/ffi/accepting-strings.md:143 src\idioms/ffi/passing-strings.md:105 +msgid "None?" +msgstr "Keiner?" + +#: src\idioms/ffi/passing-strings.md:1 +msgid "# Passing Strings" +msgstr "# Übergeben von Zeichenketten" + +#: src\idioms/ffi/passing-strings.md:5 +msgid "" +"When passing strings to FFI functions, there are four principles that should be\n" +"followed:" +msgstr "Beim Übergeben von Zeichenfolgen an FFI-Funktionen sollten vier Prinzipien befolgt werden:" + +#: src\idioms/ffi/passing-strings.md:8 +#, fuzzy +msgid "" +"1. Make the lifetime of owned strings as long as possible.\n" +"2. Minimize `unsafe` code during the conversion.\n" +"3. If the C code can modify the string data, use `Vec` instead of `CString`.\n" +"4. Unless the Foreign Function API requires it, the ownership of the string\n" +" should not transfer to the callee." +msgstr "" +"1. Machen Sie die Lebensdauer der eigenen Saiten so lang wie möglich.\n" +"2. Minimieren Sie „unsicheren“ Code während der Konvertierung.\n" +"3. Wenn der C-Code die Zeichenfolgendaten ändern kann, verwenden Sie „Vec“ anstelle von „CString“.\n" +"4. Das Eigentum an der Zeichenfolge, es sei denn, die Fremdfunktions-API erfordert dies\n" +" sollte nicht an den Angerufenen übertragen werden." + +#: src\idioms/ffi/passing-strings.md:16 +#, fuzzy +msgid "" +"Rust has built-in support for C-style strings with its `CString` and `CStr`\n" +"types. However, there are different approaches one can take with strings that\n" +"are being sent to a foreign function call from a Rust function." +msgstr "" +"Rust hat mit `CString` und `CStr` eingebaute Unterstützung für Strings im C-Stil\n" +"Typen. Es gibt jedoch verschiedene Ansätze, die man mit Saiten verfolgen kann\n" +"von einer Rust-Funktion an einen fremden Funktionsaufruf gesendet werden." + +#: src\idioms/ffi/passing-strings.md:20 +#, fuzzy +msgid "" +"The best practice is simple: use `CString` in such a way as to minimize\n" +"`unsafe` code. However, a secondary caveat is that\n" +"_the object must live long enough_, meaning the lifetime should be maximized.\n" +"In addition, the documentation explains that \"round-tripping\" a `CString` after\n" +"modification is UB, so additional work is necessary in that case." +msgstr "" +"Die beste Vorgehensweise ist einfach: Verwenden Sie \"CString\" so, dass es minimiert wird\n" +"„unsicherer“ Code. Eine sekundäre Einschränkung ist jedoch die\n" +"_das Objekt muss lange genug leben_, dh die Lebensdauer sollte maximiert werden.\n" +"Darüber hinaus erklärt die Dokumentation das \"Round-Tripping\" eines `CString` nach\n" +"Änderung ist UB, daher ist in diesem Fall zusätzliche Arbeit erforderlich." + +#: src\idioms/ffi/passing-strings.md:28 +msgid "" +"```rust,ignore\n" +"pub mod unsafe_module {\n" +"\n" +" // other module content\n" +"\n" +" extern \"C\" {\n" +" fn seterr(message: *const libc::c_char);\n" +" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> libc::c_int;\n" +" }\n" +"\n" +" fn report_error_to_ffi>(\n" +" err: S\n" +" ) -> Result<(), std::ffi::NulError>{\n" +" let c_err = std::ffi::CString::new(err.into())?;\n" +"\n" +" unsafe {\n" +" // SAFETY: calling an FFI whose documentation says the pointer is\n" +" // const, so no modification should occur\n" +" seterr(c_err.as_ptr());\n" +" }\n" +"\n" +" Ok(())\n" +" // The lifetime of c_err continues until here\n" +" }\n" +"\n" +" fn get_error_from_ffi() -> Result {\n" +" let mut buffer = vec![0u8; 1024];\n" +" unsafe {\n" +" // SAFETY: calling an FFI whose documentation implies\n" +" // that the input need only live as long as the call\n" +" let written: usize = geterr(buffer.as_mut_ptr(), 1023).into();\n" +"\n" +" buffer.truncate(written + 1);\n" +" }\n" +"\n" +" std::ffi::CString::new(buffer).unwrap().into_string()\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/passing-strings.md:70 +msgid "The example is written in a way to ensure that:" +msgstr "Das Beispiel ist so geschrieben, dass Folgendes sichergestellt ist:" + +#: src\idioms/ffi/passing-strings.md:72 +#, fuzzy +msgid "" +"1. The `unsafe` block is as small as possible.\n" +"2. The `CString` lives long enough.\n" +"3. Errors with typecasts are always propagated when possible." +msgstr "" +"1. Der \"unsichere\" Block ist so klein wie möglich.\n" +"2. Der `CString` lebt lange genug.\n" +"3. Fehler bei Typumwandlungen werden nach Möglichkeit immer weitergegeben." + +#: src\idioms/ffi/passing-strings.md:76 +#, fuzzy +msgid "" +"A common mistake (so common it's in the documentation) is to not use the\n" +"variable in the first block:" +msgstr "" +"Ein häufiger Fehler (der in der Dokumentation so häufig vorkommt) besteht darin, die nicht zu verwenden\n" +"Variable im ersten Block:" + +#: src\idioms/ffi/passing-strings.md:79 +msgid "" +"```rust,ignore\n" +"pub mod unsafe_module {\n" +"\n" +" // other module content\n" +"\n" +" fn report_error>(err: S) -> Result<(), std::ffi::NulError> {\n" +" unsafe {\n" +" // SAFETY: whoops, this contains a dangling pointer!\n" +" seterr(std::ffi::CString::new(err.into())?.as_ptr());\n" +" }\n" +" Ok(())\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/ffi/passing-strings.md:94 +#, fuzzy +msgid "" +"This code will result in a dangling pointer, because the lifetime of the\n" +"`CString` is not extended by the pointer creation, unlike if a reference were\n" +"created." +msgstr "" +"Dieser Code führt zu einem hängenden Zeiger, da die Lebensdauer der\n" +"`CString` wird durch die Zeigerbildung nicht erweitert, anders als wenn es eine Referenz wäre\n" +"erstellt." + +#: src\idioms/ffi/passing-strings.md:98 +#, fuzzy +msgid "" +"Another issue frequently raised is that the initialization of a 1k vector of\n" +"zeroes is \"slow\". However, recent versions of Rust actually optimize that\n" +"particular macro to a call to `zmalloc`, meaning it is as fast as the operating\n" +"system's ability to return zeroed memory (which is quite fast)." +msgstr "" +"Ein weiteres häufig angesprochenes Problem ist, dass die Initialisierung eines 1k-Vektors von\n" +"Nullen ist \"langsam\". Neuere Versionen von Rust optimieren dies jedoch tatsächlich\n" +"bestimmtes Makro für einen Aufruf von `zmalloc`, was bedeutet, dass es so schnell wie die Operation ist\n" +"die Fähigkeit des Systems, genullten Speicher zurückzugeben (was ziemlich schnell ist)." + +#: src\idioms/option-iter.md:1 +#, fuzzy +msgid "# Iterating over an `Option`" +msgstr "# Iteration über eine `Option`" + +#: src\idioms/option-iter.md:5 +msgid "" +"`Option` can be viewed as a container that contains either zero or one\n" +"element. In particular, it implements the `IntoIterator` trait, and as such\n" +"can be used with generic code that needs such a type." +msgstr "" +"„Option“ kann als Container angesehen werden, der entweder Null oder ein Element\n" +"enthält.\n" +"Insbesondere implementiert dieser den `IntoIterator`-Trait und kann als solches\n" +"mit generischem Code verwendet werden, wenn ein solcher Typ benötigt wird." + +#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 src\patterns/structural/unsafe-mods.md:22 +msgid "## Examples" +msgstr "## Beispiele" + +#: src\idioms/option-iter.md:11 +msgid "" +"Since `Option` implements `IntoIterator`, it can be used as an argument to\n" +"[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" +msgstr "" +"Da `Option` `IntoIterator` implementiert, kann es als Argument für\n" +"[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend) verwendet werden:" + +#: src\idioms/option-iter.md:14 +msgid "" +"```rust\n" +"let turing = Some(\"Turing\");\n" +"let mut logicians = vec![\"Curry\", \"Kleene\", \"Markov\"];\n" +"\n" +"logicians.extend(turing);\n" +"\n" +"// equivalent to\n" +"if let Some(turing_inner) = turing {\n" +" logicians.push(turing_inner);\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/option-iter.md:26 +#, fuzzy +msgid "" +"If you need to tack an `Option` to the end of an existing iterator, you can\n" +"pass it to [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +msgstr "" +"Wenn Sie eine „Option“ an das Ende eines vorhandenen Iterators anhängen müssen, können Sie das tun\n" +"Übergeben Sie es an [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" + +#: src\idioms/option-iter.md:29 +msgid "" +"```rust\n" +"let turing = Some(\"Turing\");\n" +"let logicians = vec![\"Curry\", \"Kleene\", \"Markov\"];\n" +"\n" +"for logician in logicians.iter().chain(turing.iter()) {\n" +" println!(\"{} is a logician\", logician);\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/option-iter.md:38 +#, fuzzy +msgid "" +"Note that if the `Option` is always `Some`, then it is more idiomatic to use\n" +"[`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) on the\n" +"element instead." +msgstr "" +"Beachten Sie, dass wenn die `Option` immer `Some` ist, es idiomatischer zu verwenden ist\n" +"[`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) auf der\n" +"Element statt." + +#: src\idioms/option-iter.md:42 +#, fuzzy +msgid "" +"Also, since `Option` implements `IntoIterator`, it's possible to iterate over\n" +"it using a `for` loop. This is equivalent to matching it with `if let Some(..)`,\n" +"and in most cases you should prefer the latter." +msgstr "" +"Da `Option` `IntoIterator` implementiert, ist es außerdem möglich, darüber zu iterieren\n" +"es mit einer `for`-Schleife. Dies ist gleichbedeutend mit dem Abgleich mit `if let Some(..)`,\n" +"und in den meisten Fällen sollten Sie letzteres bevorzugen." + +#: src\idioms/option-iter.md:48 +#, fuzzy +msgid "" +"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is an\n" +" iterator which yields exactly one element. It's a more readable alternative to\n" +" `Some(foo).into_iter()`.\n" +"\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" is a version of [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +" specialized to mapping functions which return `Option`.\n" +"\n" +"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" +" for converting an `Option` to a zero- or one-element slice.\n" +"\n" +"- [Documentation for `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +msgstr "" +"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) ist ein\n" +" Iterator, der genau ein Element liefert. Es ist eine besser lesbare Alternative zu\n" +" `Some(foo).into_iter()`.\n" +"\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" ist eine Version von [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +" spezialisiert auf Mapping-Funktionen, die `Option` zurückgeben.\n" +"\n" +"- Die Kiste [`ref_slice`](https://crates.io/crates/ref_slice) stellt Funktionen bereit\n" +" zum Konvertieren einer `Option` in einen Slice mit null oder einem Element.\n" +"\n" +"- [Dokumentation für `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" + +#: src\idioms/pass-var-to-closure.md:1 +#, fuzzy +msgid "# Pass variables to closure" +msgstr "# Variablen an den Abschluss übergeben" + +#: src\idioms/pass-var-to-closure.md:5 +#, fuzzy +msgid "" +"By default, closures capture their environment by borrowing. Or you can use\n" +"`move`-closure to move whole environment. However, often you want to move just\n" +"some variables to closure, give it copy of some data, pass it by reference, or\n" +"perform some other transformation." +msgstr "" +"Standardmäßig erfassen Closures ihre Umgebung durch Ausleihen. Oder Sie können verwenden\n" +"`move`-closure um die ganze Umgebung zu verschieben. Oft möchte man sich aber einfach bewegen\n" +"einige Variablen zum Abschluss, geben Sie ihm eine Kopie einiger Daten, übergeben Sie sie als Referenz oder\n" +"führen Sie eine andere Transformation durch." + +#: src\idioms/pass-var-to-closure.md:10 +msgid "Use variable rebinding in separate scope for that." +msgstr "Verwenden Sie dafür Variablen-Rebinding in einem separaten Bereich." + +#: src\idioms/pass-var-to-closure.md:14 +msgid "Use" +msgstr "Verwenden Sie" + +#: src\idioms/pass-var-to-closure.md:16 +msgid "" +"```rust\n" +"use std::rc::Rc;\n" +"\n" +"let num1 = Rc::new(1);\n" +"let num2 = Rc::new(2);\n" +"let num3 = Rc::new(3);\n" +"let closure = {\n" +" // `num1` is moved\n" +" let num2 = num2.clone(); // `num2` is cloned\n" +" let num3 = num3.as_ref(); // `num3` is borrowed\n" +" move || {\n" +" *num1 + *num2 + *num3;\n" +" }\n" +"};\n" +"```" +msgstr "" + +#: src\idioms/pass-var-to-closure.md:32 +msgid "instead of" +msgstr "anstatt" + +#: src\idioms/pass-var-to-closure.md:34 +msgid "" +"```rust\n" +"use std::rc::Rc;\n" +"\n" +"let num1 = Rc::new(1);\n" +"let num2 = Rc::new(2);\n" +"let num3 = Rc::new(3);\n" +"\n" +"let num2_cloned = num2.clone();\n" +"let num3_borrowed = num3.as_ref();\n" +"let closure = move || {\n" +" *num1 + *num2_cloned + *num3_borrowed;\n" +"};\n" +"```" +msgstr "" + +#: src\idioms/pass-var-to-closure.md:50 +#, fuzzy +msgid "" +"Copied data are grouped together with closure definition, so their purpose is\n" +"more clear, and they will be dropped immediately even if they are not consumed\n" +"by closure." +msgstr "" +"Kopierte Daten werden zusammen mit Abschlussdefinition gruppiert, so dass ihr Zweck ist\n" +"klarer, und sie werden sofort fallen gelassen, auch wenn sie nicht verbraucht werden\n" +"durch Schließung." + +#: src\idioms/pass-var-to-closure.md:54 +#, fuzzy +msgid "" +"Closure uses same variable names as surrounding code whether data are copied or\n" +"moved." +msgstr "" +"Die Schließung verwendet dieselben Variablennamen wie der umgebende Code, unabhängig davon, ob Daten kopiert werden oder\n" +"gerührt." + +#: src\idioms/pass-var-to-closure.md:59 +#, fuzzy +msgid "Additional indentation of closure body." +msgstr "Zusätzliche Einkerbung des Verschlusskörpers." + +#: src\idioms/priv-extend.md:1 +msgid "# `#[non_exhaustive]` and private fields for extensibility" +msgstr "# `#[non_exhaustive]` und private Felder zur Erweiterung" + +#: src\idioms/priv-extend.md:5 +#, fuzzy +msgid "" +"A small set of scenarios exist where a library author may want to add public\n" +"fields to a public struct or new variants to an enum without breaking backwards\n" +"compatibility." +msgstr "" +"Es gibt eine kleine Gruppe von Szenarien, in denen ein Bibliotheksautor möglicherweise öffentlich hinzufügen möchte\n" +"Felder zu einer öffentlichen Struktur oder neue Varianten zu einer Aufzählung, ohne rückwärts zu brechen\n" +"Kompatibilität." + +#: src\idioms/priv-extend.md:9 +msgid "Rust offers two solutions to this problem:" +msgstr "Rust bietet zwei Lösungen für dieses Problem:" + +#: src\idioms/priv-extend.md:11 +#, fuzzy +msgid "" +"- Use `#[non_exhaustive]` on `struct`s, `enum`s, and `enum` variants.\n" +" For extensive documentation on all the places where `#[non_exhaustive]` can be\n" +" used, see [the docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +"\n" +"- You may add a private field to a struct to prevent it from being directly\n" +" instantiated or matched against (see Alternative)" +msgstr "" +"- Verwenden Sie `#[non_exhaustive]` für `struct`s, `enum`s und `enum`-Varianten.\n" +" Für eine ausführliche Dokumentation aller Stellen, an denen `#[non_exhaustive]` stehen kann\n" +" verwendet, siehe [die Dokumentation](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +"\n" +"- Sie können einer Struktur ein privates Feld hinzufügen, um zu verhindern, dass es direkt ist\n" +" instanziiert oder abgeglichen (siehe Alternative)" + +#: src\idioms/priv-extend.md:20 +msgid "" +"```rust\n" +"mod a {\n" +" // Public struct.\n" +" #[non_exhaustive]\n" +" pub struct S {\n" +" pub foo: i32,\n" +" }\n" +" \n" +" #[non_exhaustive]\n" +" pub enum AdmitMoreVariants {\n" +" VariantA,\n" +" VariantB,\n" +" #[non_exhaustive]\n" +" VariantC { a: String }\n" +" }\n" +"}\n" +"\n" +"fn print_matched_variants(s: a::S) {\n" +" // Because S is `#[non_exhaustive]`, it cannot be named here and\n" +" // we must use `..` in the pattern.\n" +" let a::S { foo: _, ..} = s;\n" +" \n" +" let some_enum = a::AdmitMoreVariants::VariantA;\n" +" match some_enum {\n" +" a::AdmitMoreVariants::VariantA => println!(\"it's an A\"),\n" +" a::AdmitMoreVariants::VariantB => println!(\"it's a b\"),\n" +"\n" +" // .. required because this variant is non-exhaustive as well\n" +" a::AdmitMoreVariants::VariantC { a, .. } => println!(\"it's a c\"),\n" +"\n" +" // The wildcard match is required because more variants may be\n" +" // added in the future\n" +" _ => println!(\"it's a new variant\")\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/priv-extend.md:57 +msgid "## Alternative: `Private fields` for structs" +msgstr "## Alternative: `Private Felder` für Strukturen" + +#: src\idioms/priv-extend.md:59 +#, fuzzy +msgid "" +"`#[non_exhaustive]` only works across crate boundaries.\n" +"Within a crate, the private field method may be used." +msgstr "" +"`#[non_exhaustive]` funktioniert nur über Kistengrenzen hinweg.\n" +"Innerhalb einer Kiste kann die Privatfeldmethode verwendet werden." + +#: src\idioms/priv-extend.md:62 +#, fuzzy +msgid "" +"Adding a field to a struct is a mostly backwards compatible change.\n" +"However, if a client uses a pattern to deconstruct a struct instance, they\n" +"might name all the fields in the struct and adding a new one would break that\n" +"pattern.\n" +"The client could name some fields and use `..` in the pattern, in which case adding\n" +"another field is backwards compatible.\n" +"Making at least one of the struct's fields private forces clients to use the latter\n" +"form of patterns, ensuring that the struct is future-proof." +msgstr "" +"Das Hinzufügen eines Felds zu einer Struktur ist eine größtenteils abwärtskompatible Änderung.\n" +"Wenn ein Client jedoch ein Muster verwendet, um eine Strukturinstanz zu dekonstruieren, werden sie\n" +"könnte alle Felder in der Struktur benennen und das Hinzufügen eines neuen würde das brechen\n" +"Muster.\n" +"Der Client könnte einige Felder benennen und `..` im Muster verwenden, in diesem Fall Hinzufügen\n" +"ein anderes Feld ist abwärtskompatibel.\n" +"Wenn Sie mindestens eines der Felder der Struktur privat machen, werden Clients gezwungen, letzteres zu verwenden\n" +"Form von Mustern, um sicherzustellen, dass die Struktur zukunftssicher ist." + +#: src\idioms/priv-extend.md:71 +#, fuzzy +msgid "" +"The downside of this approach is that you might need to add an otherwise unneeded\n" +"field to the struct.\n" +"You can use the `()` type so that there is no runtime overhead and prepend `_` to\n" +"the field name to avoid the unused field warning." +msgstr "" +"Der Nachteil dieses Ansatzes besteht darin, dass Sie möglicherweise eine ansonsten nicht benötigte hinzufügen müssen\n" +"Feld zur Struktur.\n" +"Sie können den Typ „()“ verwenden, damit es keinen Laufzeit-Overhead gibt, und „_“ voranstellen\n" +"den Feldnamen, um die Warnung vor unbenutzten Feldern zu vermeiden." + +#: src\idioms/priv-extend.md:76 +msgid "" +"```rust\n" +"pub struct S {\n" +" pub a: i32,\n" +" // Because `b` is private, you cannot match on `S` without using `..` and `S`\n" +" // cannot be directly instantiated or matched against\n" +" _b: ()\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/priv-extend.md:87 +#, fuzzy +msgid "" +"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a backwards\n" +"compatible way.\n" +"It will also prevent clients from using the struct constructor, even if all the\n" +"fields are public.\n" +"This may be helpful, but it's worth considering if you _want_ an additional field\n" +"to be found by clients as a compiler error rather than something that may be silently\n" +"undiscovered." +msgstr "" +"Bei `struct`s erlaubt `#[non_exhaustive]` das Hinzufügen zusätzlicher Felder rückwärts\n" +"kompatible Weise.\n" +"Es wird auch verhindern, dass Clients den Struct-Konstruktor verwenden, selbst wenn alle\n" +"Felder sind öffentlich.\n" +"Dies kann hilfreich sein, aber es ist eine Überlegung wert, wenn Sie ein zusätzliches Feld _wollen_\n" +"von Clients als Compilerfehler und nicht als etwas, das möglicherweise stillschweigend gefunden wird\n" +"unentdeckt." + +#: src\idioms/priv-extend.md:95 +#, fuzzy +msgid "" +"`#[non_exhaustive]` can be applied to enum variants as well.\n" +"A `#[non_exhaustive]` variant behaves in the same way as a `#[non_exhaustive]` struct." +msgstr "" +"`#[non_exhaustive]` kann auch auf Enum-Varianten angewendet werden.\n" +"Eine `#[non_exhaustive]`-Variante verhält sich genauso wie eine `#[non_exhaustive]`-Struktur." + +#: src\idioms/priv-extend.md:98 +msgid "" +"Use this deliberately and with caution: incrementing the major version when adding\n" +"fields or variants is often a better option.\n" +"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an external\n" +"resource that may change out-of-sync with your library, but is not a general purpose\n" +"tool." +msgstr "" +"Verwenden Sie dies bewusst und mit Vorsicht: Das Erhöhen der Hauptversion beim Hinzufügen\n" +"von Feldern oder Varianten ist oft die bessere Option.\n" +"`#[non_exhaustive]` kann in Szenarien angemessen sein, in denen Sie eine externe Ressource\n" +"modellieren, die sich möglicherweise nicht synchron der Entwicklung Ihrer Bibliothek ändert.\n" +"Es ist aber kein Allzweckwerkzeug." + +#: src\idioms/priv-extend.md:104 +msgid "### Disadvantages" +msgstr "### Nachteile" + +#: src\idioms/priv-extend.md:106 +msgid "" +"`#[non_exhaustive]` can make your code much less ergonomic to use, especially when\n" +"forced to handle unknown enum variants.\n" +"It should only be used when these sorts of evolutions are required **without**\n" +"incrementing the major version." +msgstr "" +"`#[non_exhaustive]` kann Ihren Code viel weniger ergonomisch machen, besonders wenn\n" +"Entwickler dadurch gezwungen werden, mit unbekannten Enum-Varianten umzugehen.\n" +"Es sollte nur verwendet werden, wenn diese Art von Entwicklungen **ohne** Erhöhen der\n" +"Hauptversion erforderlich sind." + +#: src\idioms/priv-extend.md:111 +msgid "" +"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle a\n" +"wildcard variant.\n" +"If there is no sensible action to take in this case, this may lead to awkward\n" +"code and code paths that are only executed in extremely rare circumstances.\n" +"If a client decides to `panic!()` in this scenario, it may have been better to\n" +"expose this error at compile time.\n" +"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" case;\n" +"there is rarely a sensible action to take in this scenario." +msgstr "" + +#: src\idioms/priv-extend.md:122 +#, fuzzy +msgid "" +"- [RFC introducing #[non_exhaustive] attribute for enums and structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" +msgstr "" +"- [RFC führt #[non_exhaustive]-Attribut für Aufzählungen und Strukturen ein](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" + +#: src\idioms/rustdoc-init.md:1 +msgid "# Easy doc initialization\r" +msgstr "# Einfache Dokumenteninitialisierung\r" + +#: src\idioms/rustdoc-init.md:5 +#, fuzzy +msgid "" +"If a struct takes significant effort to initialize when writing docs, it can be\r\n" +"quicker to wrap your example with a helper function which takes the struct as an\r\n" +"argument." +msgstr "" +"Wenn die Initialisierung einer Struktur beim Schreiben von Dokumenten erheblichen Aufwand erfordert, kann dies der Fall sein\r\n" +"Sie können Ihr Beispiel schneller mit einer Hilfsfunktion umschließen, die die Struktur als annimmt\r\n" +"Streit." + +#: src\idioms/rustdoc-init.md:9 +msgid "## Motivation\r" +msgstr "## Motivation\r" + +#: src\idioms/rustdoc-init.md:11 +msgid "" +"Sometimes there is a struct with multiple or complicated parameters and several\r\n" +"methods. Each of these methods should have examples." +msgstr "" +"Manchmal gibt es eine Struktur mit mehreren oder komplizierten Parametern und mehreren\r\n" +"Methoden. Für jede dieser Methoden sollten Beispiele vorhanden sein." + +#: src\idioms/rustdoc-init.md:14 +msgid "For example:" +msgstr "Zum Beispiel:" + +#: src\idioms/rustdoc-init.md:16 +msgid "" +"````rust,ignore\r\n" +"struct Connection {\r\n" +" name: String,\r\n" +" stream: TcpStream,\r\n" +"}\r\n" +"\r\n" +"impl Connection {\r\n" +" /// Sends a request over the connection.\r\n" +" ///\r\n" +" /// # Example\r\n" +" /// ```no_run\r\n" +" /// # // Boilerplate are required to get an example working.\r\n" +" /// # let stream = TcpStream::connect(\"127.0.0.1:34254\");\r\n" +" /// # let connection = Connection { name: \"foo\".to_owned(), stream };\r\n" +" /// # let request = Request::new(\"RequestId\", RequestType::Get, \"payload\");\r\n" +" /// let response = connection.send_request(request);\r\n" +" /// assert!(response.is_ok());\r\n" +" /// ```\r\n" +" fn send_request(&self, request: Request) -> Result {\r\n" +" // ...\r\n" +" }\r\n" +"\r\n" +" /// Oh no, all that boilerplate needs to be repeated here!\r\n" +" fn check_status(&self) -> Status {\r\n" +" // ...\r\n" +" }\r\n" +"}\r\n" +"````" +msgstr "" + +#: src\idioms/rustdoc-init.md:45 +msgid "## Example\r" +msgstr "## Beispiel\r" + +#: src\idioms/rustdoc-init.md:47 +#, fuzzy +msgid "" +"Instead of typing all of this boilerplate to create a `Connection` and\r\n" +"`Request`, it is easier to just create a wrapping helper function which takes\r\n" +"them as arguments:" +msgstr "" +"Anstatt all diese Textbausteine einzugeben, um eine „Verbindung“ zu erstellen und\r\n" +"`Request`, es ist einfacher, einfach eine Wrapping-Hilfsfunktion zu erstellen, die dauert\r\n" +"sie als Argumente:" + +#: src\idioms/rustdoc-init.md:51 +msgid "" +"````rust,ignore\r\n" +"struct Connection {\r\n" +" name: String,\r\n" +" stream: TcpStream,\r\n" +"}\r\n" +"\r\n" +"impl Connection {\r\n" +" /// Sends a request over the connection.\r\n" +" ///\r\n" +" /// # Example\r\n" +" /// ```\r\n" +" /// # fn call_send(connection: Connection, request: Request) {\r\n" +" /// let response = connection.send_request(request);\r\n" +" /// assert!(response.is_ok());\r\n" +" /// # }\r\n" +" /// ```\r\n" +" fn send_request(&self, request: Request) {\r\n" +" // ...\r\n" +" }\r\n" +"}\r\n" +"````" +msgstr "" + +#: src\idioms/rustdoc-init.md:73 +msgid "" +"**Note** in the above example the line `assert!(response.is_ok());` will not\r\n" +"actually run while testing because it is inside a function which is never\r\n" +"invoked." +msgstr "" + +#: src\idioms/rustdoc-init.md:77 +msgid "## Advantages\r" +msgstr "## Vorteile\r" + +#: src\idioms/rustdoc-init.md:79 +msgid "This is much more concise and avoids repetitive code in examples." +msgstr "Dies ist viel prägnanter und vermeidet sich wiederholenden Code in Beispielen." + +#: src\idioms/rustdoc-init.md:81 +msgid "## Disadvantages\r" +msgstr "## Nachteile\r" + +#: src\idioms/rustdoc-init.md:83 +msgid "" +"As example is in a function, the code will not be tested. Though it will still be\r\n" +"checked to make sure it compiles when running a `cargo test`. So this pattern is\r\n" +"most useful when you need `no_run`. With this, you do not need to add `no_run`." +msgstr "" +"Da sich das Beispiel in einer Funktion befindet, wird der Code nicht getestet. Obwohl es trotzdem überprüft wird,\r\n" +"um sicherzustellen, dass es kompiliert werden kann, wenn `cargo test` ausgeführt wird. Also dieses Muster ist\r\n" +"am nützlichsten, wenn Sie `no_run` brauchen. Damit brauchen Sie `no_run` nicht extra hinzuzufügen." + +#: src\idioms/rustdoc-init.md:87 +msgid "## Discussion\r" +msgstr "## Diskussion\r" + +#: src\idioms/rustdoc-init.md:89 +msgid "If assertions are not required this pattern works well." +msgstr "Wenn `assertions` nicht erforderlich sind, funktioniert dieses Muster gut." + +#: src\idioms/rustdoc-init.md:91 +#, fuzzy +msgid "" +"If they are, an alternative can be to create a public method to create a helper\r\n" +"instance which is annotated with `#[doc(hidden)]` (so that users won't see it).\r\n" +"Then this method can be called inside of rustdoc because it is part of the\r\n" +"crate's public API." +msgstr "" +"Wenn dies der Fall ist, kann eine Alternative darin bestehen, eine öffentliche Methode zum Erstellen eines Hilfsprogramms zu erstellen\r\n" +"Instanz, die mit `#[doc(hidden)]` annotiert ist (damit Benutzer sie nicht sehen).\r\n" +"Dann kann diese Methode innerhalb von rustdoc aufgerufen werden, da sie Teil von ist\r\n" +"die öffentliche API von Crate." + +#: src\idioms/temporary-mutability.md:1 +msgid "# Temporary mutability" +msgstr "# Vorübergehende Veränderlichkeit" + +#: src\idioms/temporary-mutability.md:5 +#, fuzzy +msgid "" +"Often it is necessary to prepare and process some data, but after that data are\n" +"only inspected and never modified. The intention can be made explicit by redefining\n" +"the mutable variable as immutable." +msgstr "" +"Oft ist es notwendig, einige Daten vorzubereiten und zu verarbeiten, aber danach sind Daten\n" +"nur geprüft und nie verändert. Die Absicht kann durch Umdefinieren explizit gemacht werden\n" +"die veränderliche Variable als unveränderlich." + +#: src\idioms/temporary-mutability.md:9 +#, fuzzy +msgid "" +"It can be done either by processing data within a nested block or by redefining\n" +"the variable." +msgstr "" +"Dies kann entweder durch Verarbeitung von Daten innerhalb eines verschachtelten Blocks oder durch Neudefinition erfolgen\n" +"Die Variable." + +#: src\idioms/temporary-mutability.md:14 +msgid "Say, vector must be sorted before usage." +msgstr "Angenommen, der Vektor muss vor der Verwendung sortiert werden." + +#: src\idioms/temporary-mutability.md:16 +msgid "Using nested block:" +msgstr "Verschachtelten Block verwenden:" + +#: src\idioms/temporary-mutability.md:18 +msgid "" +"```rust,ignore\n" +"let data = {\n" +" let mut data = get_vec();\n" +" data.sort();\n" +" data\n" +"};\n" +"\n" +"// Here `data` is immutable.\n" +"```" +msgstr "" + +#: src\idioms/temporary-mutability.md:28 +msgid "Using variable rebinding:" +msgstr "Variables Rebinding verwenden:" + +#: src\idioms/temporary-mutability.md:30 +msgid "" +"```rust,ignore\n" +"let mut data = get_vec();\n" +"data.sort();\n" +"let data = data;\n" +"\n" +"// Here `data` is immutable.\n" +"```" +msgstr "" + +#: src\idioms/temporary-mutability.md:40 +msgid "Compiler ensures that you don't accidentally mutate data after some point." +msgstr "Der Compiler stellt sicher, dass Sie nach einem bestimmten Punkt nicht versehentlich Daten ändern." + +#: src\idioms/temporary-mutability.md:44 +#, fuzzy +msgid "" +"Nested block requires additional indentation of block body.\n" +"One more line to return data from block or redefine variable." +msgstr "" +"Ein verschachtelter Block erfordert eine zusätzliche Einrückung des Blockkörpers.\n" +"Eine weitere Zeile, um Daten vom Block zurückzugeben oder die Variable neu zu definieren." + +#: src\idioms/return-consumed-arg-on-error.md:1 +#, fuzzy +msgid "# Return consumed argument on error" +msgstr "# Bei Fehler verbrauchtes Argument zurückgeben" + +#: src\idioms/return-consumed-arg-on-error.md:5 +#, fuzzy +msgid "" +"If a fallible function consumes (moves) an argument, return that argument back inside\n" +"an error." +msgstr "" +"Wenn eine fehlbare Funktion ein Argument verbraucht (bewegt), geben Sie dieses Argument wieder nach innen zurück\n" +"ein Fehler." + +#: src\idioms/return-consumed-arg-on-error.md:10 +msgid "" +"```rust\n" +"pub fn send(value: String) -> Result<(), SendError> {\n" +" println!(\"using {value} in a meaningful way\");\n" +" // Simulate non-deterministic fallible action.\n" +" use std::time::SystemTime;\n" +" let period = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" +" if period.subsec_nanos() % 2 == 1 {\n" +" Ok(())\n" +" } else {\n" +" Err(SendError(value))\n" +" }\n" +"}\n" +"\n" +"pub struct SendError(String);\n" +"\n" +"fn main() {\n" +" let mut value = \"imagine this is very long string\".to_string();\n" +"\n" +" let success = 's: {\n" +" // Try to send value two times.\n" +" for _ in 0..2 {\n" +" value = match send(value) {\n" +" Ok(()) => break 's true,\n" +" Err(SendError(value)) => value,\n" +" }\n" +" }\n" +" false\n" +" };\n" +"\n" +" println!(\"success: {}\", success);\n" +"}\n" +"```" +msgstr "" + +#: src\idioms/return-consumed-arg-on-error.md:45 +#, fuzzy +msgid "" +"In case of error you may want to try some alternative way or to\n" +"retry action in case of non-deterministic function. But if the argument\n" +"is always consumed, you are forced to clone it on every call, which\n" +"is not very efficient." +msgstr "" +"Im Falle eines Fehlers können Sie einen alternativen Weg versuchen oder versuchen\n" +"Wiederholen Sie die Aktion im Falle einer nicht deterministischen Funktion. Aber wenn das Argument\n" +"immer verbraucht wird, sind Sie gezwungen, es bei jedem Anruf zu klonen, was\n" +"ist nicht sehr effizient." + +#: src\idioms/return-consumed-arg-on-error.md:50 +msgid "" +"The standard library uses this approach in e.g. `String::from_utf8` method.\n" +"When given a vector that doesn't contain valid UTF-8, a `FromUtf8Error`\n" +"is returned.\n" +"You can get original vector back using `FromUtf8Error::into_bytes` method." +msgstr "" +"Die Standardbibliothek verwendet diesen Ansatz z.B. in der `String::from_utf8`-Methode.\n" +"Wenn ein Vektor übergeben wird, der kein gültiges UTF-8 enthält, wird ein `FromUtf8Error` zurückgegeben.\n" +"Sie können den ursprünglichen Vektor mit der Methode `FromUtf8Error::into_bytes` zurückerhalten." + +#: src\idioms/return-consumed-arg-on-error.md:57 +#, fuzzy +msgid "Better performance because of moving arguments whenever possible." +msgstr "Bessere Leistung durch bewegliche Argumente, wann immer möglich." + +#: src\idioms/return-consumed-arg-on-error.md:61 +msgid "Slightly more complex error types." +msgstr "Etwas komplexere Fehlertypen." + +#: src\patterns/index.md:1 +msgid "# Design Patterns" +msgstr "# Entwurfsmuster" + +#: src\patterns/index.md:3 +msgid "" +"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) are\n" +"\"general reusable solutions to a commonly occurring problem within a given\n" +"context in software design\". Design patterns are a great way to describe the\n" +"culture of a programming language. Design patterns are very language-specific -\n" +"what is a pattern in one language may be unnecessary in another due to a\n" +"language feature, or impossible to express due to a missing feature." +msgstr "" +"[Entwurfsmuster](https://en.wikipedia.org/wiki/Software_design_pattern) sind\n" +"\"allgemeine wiederverwendbare Lösungen für ein häufig auftretendes Problem innerhalb eines bestimmten Bereichs\n" +"im Softwaredesign\". Entwurfsmuster sind eine großartige Möglichkeit, die\n" +"Kultur einer Programmiersprache zu beschreiben. Entwurfsmuster sind sehr sprachspezifisch -\n" +"Was in einer Sprache ein Muster ist, kann in einer anderen unnötig oder durch ein\n" +"fehlendes Sprachmerkmal nicht ausdrückbar sein." + +#: src\patterns/index.md:10 +msgid "" +"If overused, design patterns can add unnecessary complexity to programs.\n" +"However, they are a great way to share intermediate and advanced level knowledge\n" +"about a programming language." +msgstr "" +"Bei übermäßiger Verwendung können Entwurfsmuster Programme unnötig komplex machen.\n" +"Sie sind jedoch eine großartige Möglichkeit, Wissen über eine Programmiersprache auf mittlerem\n" +"und fortgeschrittenem Niveau zu teilen." + +#: src\patterns/index.md:16 +msgid "" +"Rust has many unique features. These features give us great benefit by removing\n" +"whole classes of problems. Some of them are also patterns that are _unique_ to Rust." +msgstr "" +"Rust hat viele Besonderheiten, welche uns große Vorteile durch das weglassen\n" +"ganzer Problemklassen bringen. Einige von ihnen sind auch Muster, die für Rust _einzigartig_ sind." + +#: src\patterns/index.md:19 +msgid "## YAGNI" +msgstr "## YAGNI" + +#: src\patterns/index.md:21 +msgid "" +"YAGNI is an acronym that stands for `You Aren't Going to Need It`.\n" +"It's a vital software design principle to apply as you write code." +msgstr "" +"YAGNI ist ein Akronym, das für \"You Aren't Going to Need It\" steht.\n" +"Was soviel heist wie: \"Du wirst es nicht brauchen\".\n" +"Es ist ein wichtiges Software-Designprinzip, das Sie beim Schreiben von Code anwenden müssen." + +#: src\patterns/index.md:24 +msgid "> The best code I ever wrote was code I never wrote." +msgstr "> Der beste Code, den ich je geschrieben habe, war Code, den ich nie geschrieben habe." + +#: src\patterns/index.md:26 +msgid "" +"If we apply YAGNI to design patterns, we see that the features of Rust allow us to\n" +"throw out many patterns. For instance, there is no need for the [strategy pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"in Rust because we can just use [traits](https://doc.rust-lang.org/book/traits.html)." +msgstr "" +"Wenn wir YAGNI auf Entwurfsmuster anwenden, sehen wir, dass die Eigenschaften von Rust es uns erlauben\n" +"viele Muster auszurangieren. Beispielsweise ist das [Strategiemuster](https://en.wikipedia.org/wiki/Strategy_pattern) nicht erforderlich\n" +"in Rust, weil wir [Traits](https://doc.rust-lang.org/book/traits.html) verwenden können." + +#: src\patterns/behavioural/intro.md:1 +msgid "# Behavioural Patterns" +msgstr "# Verhaltensmuster" + +#: src\patterns/behavioural/intro.md:3 +msgid "From [Wikipedia](https://en.wikipedia.org/wiki/Behavioral_pattern):" +msgstr "Aus [Wikipedia](https://en.wikipedia.org/wiki/Behavioral_pattern):" + +#: src\patterns/behavioural/intro.md:5 +msgid "" +"> Design patterns that identify common communication patterns among objects.\n" +"> By doing so, these patterns increase flexibility in carrying out communication." +msgstr "" +"> Entwurfsmuster, die gemeinsame Verhaltensweisen zwischen Objekten identifizieren.\n" +"> Dadurch erhöhen diese Muster die Flexibilität bei der Durchführung der Kommunikation." + +#: src\patterns/behavioural/command.md:1 +msgid "# Command" +msgstr "# Befehl" + +#: src\patterns/behavioural/command.md:5 +#, fuzzy +msgid "" +"The basic idea of the Command pattern is to separate out actions into its own\n" +"objects and pass them as parameters." +msgstr "" +"Die Grundidee des Befehlsmusters besteht darin, Aktionen in eigene aufzuteilen\n" +"Objekte und übergeben Sie sie als Parameter." + +#: src\patterns/behavioural/command.md:10 +#, fuzzy +msgid "" +"Suppose we have a sequence of actions or transactions encapsulated as objects.\n" +"We want these actions or commands to be executed or invoked in some order later\n" +"at different time. These commands may also be triggered as a result of some event.\n" +"For example, when a user pushes a button, or on arrival of a data packet.\n" +"In addition, these commands might be undoable. This may come in useful for\n" +"operations of an editor. We might want to store logs of executed commands so that\n" +"we could reapply the changes later if the system crashes." +msgstr "" +"Angenommen, wir haben eine Folge von Aktionen oder Transaktionen, die als Objekte gekapselt sind.\n" +"Wir möchten, dass diese Aktionen oder Befehle später in einer bestimmten Reihenfolge ausgeführt oder aufgerufen werden\n" +"zu unterschiedlichen Zeiten. Diese Befehle können auch als Ergebnis eines Ereignisses ausgelöst werden.\n" +"Zum Beispiel, wenn ein Benutzer eine Taste drückt oder ein Datenpaket eintrifft.\n" +"Außerdem können diese Befehle möglicherweise rückgängig gemacht werden. Dies kann nützlich sein für\n" +"Tätigkeiten eines Redakteurs. Möglicherweise möchten wir Protokolle ausgeführter Befehle speichern, damit\n" +"Wir könnten die Änderungen später erneut anwenden, wenn das System abstürzt." + +#: src\patterns/behavioural/command.md:20 +#, fuzzy +msgid "" +"Define two database operations `create table` and `add field`. Each of these\n" +"operations is a command which knows how to undo the command, e.g., `drop table`\n" +"and `remove field`. When a user invokes a database migration operation then each\n" +"command is executed in the defined order, and when the user invokes the rollback\n" +"operation then the whole set of commands is invoked in reverse order." +msgstr "" +"Definieren Sie zwei Datenbankoperationen „Tabelle erstellen“ und „Feld hinzufügen“. Jedes von diesen\n" +"operations ist ein Befehl, der weiß, wie der Befehl rückgängig gemacht werden kann, z. B. `drop table`\n" +"und `Feld entfernen`. Wenn ein Benutzer eine Datenbankmigrationsoperation aufruft, dann jede\n" +"Befehl in der definierten Reihenfolge ausgeführt wird und wenn der Benutzer das Rollback aufruft\n" +"Operation wird der gesamte Befehlssatz in umgekehrter Reihenfolge aufgerufen." + +#: src\patterns/behavioural/command.md:26 +#, fuzzy +msgid "## Approach: Using trait objects" +msgstr "## Ansatz: Verwendung von Eigenschaftsobjekten" + +#: src\patterns/behavioural/command.md:28 +#, fuzzy +msgid "" +"We define a common trait which encapsulates our command with two operations\n" +"`execute` and `rollback`. All command `structs` must implement this trait." +msgstr "" +"Wir definieren ein gemeinsames Merkmal, das unseren Befehl mit zwei Operationen kapselt\n" +"„Ausführen“ und „Zurücksetzen“. Alle Befehlsstrukturen müssen diese Eigenschaft implementieren." + +#: src\patterns/behavioural/command.md:31 +msgid "" +"```rust\n" +"pub trait Migration {\n" +" fn execute(&self) -> &str;\n" +" fn rollback(&self) -> &str;\n" +"}\n" +"\n" +"pub struct CreateTable;\n" +"impl Migration for CreateTable {\n" +" fn execute(&self) -> &str {\n" +" \"create table\"\n" +" }\n" +" fn rollback(&self) -> &str {\n" +" \"drop table\"\n" +" }\n" +"}\n" +"\n" +"pub struct AddField;\n" +"impl Migration for AddField {\n" +" fn execute(&self) -> &str {\n" +" \"add field\"\n" +" }\n" +" fn rollback(&self) -> &str {\n" +" \"remove field\"\n" +" }\n" +"}\n" +"\n" +"struct Schema {\n" +" commands: Vec>,\n" +"}\n" +"\n" +"impl Schema {\n" +" fn new() -> Self {\n" +" Self { commands: vec![] }\n" +" }\n" +"\n" +" fn add_migration(&mut self, cmd: Box) {\n" +" self.commands.push(cmd);\n" +" }\n" +"\n" +" fn execute(&self) -> Vec<&str> {\n" +" self.commands.iter().map(|cmd| cmd.execute()).collect()\n" +" }\n" +" fn rollback(&self) -> Vec<&str> {\n" +" self.commands\n" +" .iter()\n" +" .rev() // reverse iterator's direction\n" +" .map(|cmd| cmd.rollback())\n" +" .collect()\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" let mut schema = Schema::new();\n" +"\n" +" let cmd = Box::new(CreateTable);\n" +" schema.add_migration(cmd);\n" +" let cmd = Box::new(AddField);\n" +" schema.add_migration(cmd);\n" +"\n" +" assert_eq!(vec![\"create table\", \"add field\"], schema.execute());\n" +" assert_eq!(vec![\"remove field\", \"drop table\"], schema.rollback());\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/command.md:95 +#, fuzzy +msgid "## Approach: Using function pointers" +msgstr "## Ansatz: Verwenden von Funktionszeigern" + +#: src\patterns/behavioural/command.md:97 +#, fuzzy +msgid "" +"We could follow another approach by creating each individual command as\n" +"a different function and store function pointers to invoke these functions later\n" +"at a different time. Since function pointers implement all three traits `Fn`,\n" +"`FnMut`, and `FnOnce` we could as well pass and store closures instead of\n" +"function pointers." +msgstr "" +"Wir könnten einen anderen Ansatz verfolgen, indem wir jeden einzelnen Befehl als erstellen\n" +"eine andere Funktion und speichern Sie Funktionszeiger, um diese Funktionen später aufzurufen\n" +"zu einem anderen Zeitpunkt. Da Funktionszeiger alle drei Merkmale `Fn` implementieren,\n" +"`FnMut` und `FnOnce` könnten wir statt dessen auch Closures übergeben und speichern\n" +"Funktionszeiger." + +#: src\patterns/behavioural/command.md:103 +msgid "" +"```rust\n" +"type FnPtr = fn() -> String;\n" +"struct Command {\n" +" execute: FnPtr,\n" +" rollback: FnPtr,\n" +"}\n" +"\n" +"struct Schema {\n" +" commands: Vec,\n" +"}\n" +"\n" +"impl Schema {\n" +" fn new() -> Self {\n" +" Self { commands: vec![] }\n" +" }\n" +" fn add_migration(&mut self, execute: FnPtr, rollback: FnPtr) {\n" +" self.commands.push(Command { execute, rollback });\n" +" }\n" +" fn execute(&self) -> Vec {\n" +" self.commands.iter().map(|cmd| (cmd.execute)()).collect()\n" +" }\n" +" fn rollback(&self) -> Vec {\n" +" self.commands\n" +" .iter()\n" +" .rev()\n" +" .map(|cmd| (cmd.rollback)())\n" +" .collect()\n" +" }\n" +"}\n" +"\n" +"fn add_field() -> String {\n" +" \"add field\".to_string()\n" +"}\n" +"\n" +"fn remove_field() -> String {\n" +" \"remove field\".to_string()\n" +"}\n" +"\n" +"fn main() {\n" +" let mut schema = Schema::new();\n" +" schema.add_migration(|| \"create table\".to_string(), || \"drop table\".to_string());\n" +" schema.add_migration(add_field, remove_field);\n" +" assert_eq!(vec![\"create table\", \"add field\"], schema.execute());\n" +" assert_eq!(vec![\"remove field\", \"drop table\"], schema.rollback());\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/command.md:150 +#, fuzzy +msgid "## Approach: Using `Fn` trait objects" +msgstr "## Ansatz: Verwendung von `Fn`-Eigenschaftsobjekten" + +#: src\patterns/behavioural/command.md:152 +#, fuzzy +msgid "" +"Finally, instead of defining a common command trait we could store\n" +"each command implementing the `Fn` trait separately in vectors." +msgstr "" +"Schließlich könnten wir, anstatt eine gemeinsame Befehlseigenschaft zu definieren, speichern\n" +"jeder Befehl implementiert das `Fn`-Merkmal separat in Vektoren." + +#: src\patterns/behavioural/command.md:155 +msgid "" +"```rust\n" +"type Migration<'a> = Box &'a str>;\n" +"\n" +"struct Schema<'a> {\n" +" executes: Vec>,\n" +" rollbacks: Vec>,\n" +"}\n" +"\n" +"impl<'a> Schema<'a> {\n" +" fn new() -> Self {\n" +" Self {\n" +" executes: vec![],\n" +" rollbacks: vec![],\n" +" }\n" +" }\n" +" fn add_migration(&mut self, execute: E, rollback: R)\n" +" where\n" +" E: Fn() -> &'a str + 'static,\n" +" R: Fn() -> &'a str + 'static,\n" +" {\n" +" self.executes.push(Box::new(execute));\n" +" self.rollbacks.push(Box::new(rollback));\n" +" }\n" +" fn execute(&self) -> Vec<&str> {\n" +" self.executes.iter().map(|cmd| cmd()).collect()\n" +" }\n" +" fn rollback(&self) -> Vec<&str> {\n" +" self.rollbacks.iter().rev().map(|cmd| cmd()).collect()\n" +" }\n" +"}\n" +"\n" +"fn add_field() -> &'static str {\n" +" \"add field\"\n" +"}\n" +"\n" +"fn remove_field() -> &'static str {\n" +" \"remove field\"\n" +"}\n" +"\n" +"fn main() {\n" +" let mut schema = Schema::new();\n" +" schema.add_migration(|| \"create table\", || \"drop table\");\n" +" schema.add_migration(add_field, remove_field);\n" +" assert_eq!(vec![\"create table\", \"add field\"], schema.execute());\n" +" assert_eq!(vec![\"remove field\", \"drop table\"], schema.rollback());\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/command.md:205 +#, fuzzy +msgid "" +"If our commands are small and may be defined as functions or passed as a closure\n" +"then using function pointers might be preferable since it does not exploit\n" +"dynamic dispatch. But if our command is a whole struct with a bunch of functions\n" +"and variables defined as seperated module then using trait objects would be\n" +"more suitable. A case of application can be found in [`actix`](https://actix.rs/),\n" +"which uses trait objects when it registers a handler function for routes.\n" +"In case of using `Fn` trait objects we can create and use commands in the same\n" +"way as we used in case of function pointers." +msgstr "" +"Wenn unsere Befehle klein sind und als Funktionen definiert oder als Abschluss übergeben werden können\n" +"Dann ist die Verwendung von Funktionszeigern möglicherweise vorzuziehen, da sie nicht ausgenutzt werden\n" +"dynamischer Versand. Aber wenn unser Befehl eine ganze Struktur mit einer Reihe von Funktionen ist\n" +"und Variablen, die als separates Modul definiert sind und dann Trait-Objekte verwenden würden\n" +"passender. Einen Anwendungsfall finden Sie in [`actix`](https://actix.rs/),\n" +"die Trait-Objekte verwendet, wenn sie eine Handler-Funktion für Routen registriert.\n" +"Im Falle der Verwendung von 'Fn'-Eigenschaftsobjekten können wir Befehle darin erstellen und verwenden\n" +"Weise, wie wir es im Fall von Funktionszeigern verwendet haben." + +#: src\patterns/behavioural/command.md:214 +#, fuzzy +msgid "" +"As performance, there is always a trade-off between performance and code\n" +"simplicity and organisation. Static dispatch gives faster performance, while\n" +"dynamic dispatch provides flexibility when we structure our application." +msgstr "" +"Als Leistung gibt es immer einen Kompromiss zwischen Leistung und Code\n" +"Einfachheit und Organisation. Der statische Versand bietet eine schnellere Leistung, während\n" +"Der dynamische Versand bietet Flexibilität bei der Strukturierung unserer Anwendung." + +#: src\patterns/behavioural/command.md:220 +#, fuzzy +msgid "" +"- [Command pattern](https://en.wikipedia.org/wiki/Command_pattern)\n" +"\n" +"- [Another example for the `command` pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-" +"rust)" +msgstr "" +"- [Befehlsmuster](https://en.wikipedia.org/wiki/Command_pattern)\n" +"\n" +"- [Ein weiteres Beispiel für das Muster \"Befehl\"] (https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-" +"pattern-rust)" + +#: src\patterns/behavioural/interpreter.md:1 +#, fuzzy +msgid "# Interpreter" +msgstr "# Dolmetscher" + +#: src\patterns/behavioural/interpreter.md:5 +#, fuzzy +msgid "" +"If a problem occurs very often and requires long and repetitive steps to solve\n" +"it, then the problem instances might be expressed in a simple language and an\n" +"interpreter object could solve it by interpreting the sentences written in this\n" +"simple language." +msgstr "" +"Wenn ein Problem sehr häufig auftritt und lange und sich wiederholende Schritte zur Lösung erforderlich sind\n" +"es, dann könnten die Probleminstanzen in einer einfachen Sprache ausgedrückt werden und eine\n" +"interpreter-Objekt könnte es lösen, indem es die darin geschriebenen Sätze interpretiert\n" +"einfache Sprache." + +#: src\patterns/behavioural/interpreter.md:10 +#, fuzzy +msgid "Basically, for any kind of problems we define:" +msgstr "Grundsätzlich definieren wir für jede Art von Problemen:" + +#: src\patterns/behavioural/interpreter.md:12 +#, fuzzy +msgid "" +"- A [domain specific language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- A grammar for this language,\n" +"- An interpreter that solves the problem instances." +msgstr "" +"- Eine [domainspezifische Sprache](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- Eine Grammatik für diese Sprache,\n" +"- Ein Interpreter, der die Probleminstanzen löst." + +#: src\patterns/behavioural/interpreter.md:18 +#, fuzzy +msgid "" +"Our goal is to translate simple mathematical expressions into postfix expressions\n" +"(or [Reverse Polish notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"For simplicity, our expressions consist of ten digits `0`, ..., `9` and two\n" +"operations `+`, `-`. For example, the expression `2 + 4` is translated into\n" +"`2 4 +`." +msgstr "" +"Unser Ziel ist es, einfache mathematische Ausdrücke in Postfix-Ausdrücke zu übersetzen\n" +"(oder [Umgekehrte polnische Notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Der Einfachheit halber bestehen unsere Ausdrücke aus zehn Ziffern `0`, ..., `9` und zwei\n" +"Operationen `+`, `-`. Beispielsweise wird der Ausdruck „2 + 4“ übersetzt in\n" +"\"2 4 +\"." + +#: src\patterns/behavioural/interpreter.md:24 +#, fuzzy +msgid "## Context Free Grammar for our problem" +msgstr "## Kontextfreie Grammatik für unser Problem" + +#: src\patterns/behavioural/interpreter.md:26 +#, fuzzy +msgid "" +"Our task is translating infix expressions into postfix ones. Let's define a context\n" +"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and `-`,\n" +"where:" +msgstr "" +"Unsere Aufgabe besteht darin, Infix-Ausdrücke in Postfix-Ausdrücke zu übersetzen. Lassen Sie uns einen Kontext definieren\n" +"freie Grammatik für eine Reihe von Infix-Ausdrücken über `0`, ..., `9`, `+` und `-`,\n" +"Wo:" + +#: src\patterns/behavioural/interpreter.md:30 +#, fuzzy +msgid "" +"- Terminal symbols: `0`, `...`, `9`, `+`, `-`\n" +"- Non-terminal symbols: `exp`, `term`\n" +"- Start symbol is `exp`\n" +"- And the following are production rules" +msgstr "" +"- Terminalsymbole: `0`, `...`, `9`, `+`, `-`\n" +"- Nichtterminale Symbole: `exp`, `term`\n" +"- Startsymbol ist `exp`\n" +"- Und das Folgende sind Produktionsregeln" + +#: src\patterns/behavioural/interpreter.md:35 +msgid "" +"```ignore\n" +"exp -> exp + term\n" +"exp -> exp - term\n" +"exp -> term\n" +"term -> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9\n" +"```" +msgstr "" + +#: src\patterns/behavioural/interpreter.md:42 +#, fuzzy +msgid "" +"**NOTE:** This grammar should be further transformed depending on what we are going\n" +"to do with it. For example, we might need to remove left recursion. For more\n" +"details please see [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques," +"_and_Tools)\n" +"(aka Dragon Book)." +msgstr "" +"**HINWEIS:** Diese Grammatik sollte weiter transformiert werden, je nachdem, was wir tun\n" +"damit zu tun. Beispielsweise müssen wir möglicherweise die linke Rekursion entfernen. Für mehr\n" +"Einzelheiten finden Sie unter [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles," +"_Techniques,_and_Tools)\n" +"(auch bekannt als Drachenbuch)." + +#: src\patterns/behavioural/interpreter.md:47 +msgid "## Solution" +msgstr "## Lösung" + +#: src\patterns/behavioural/interpreter.md:49 +#, fuzzy +msgid "" +"We simply implement a recursive descent parser. For simplicity's sake, the code\n" +"panics when an expression is syntactically wrong (for example `2-34` or `2+5-`\n" +"are wrong according to the grammar definition)." +msgstr "" +"Wir implementieren einfach einen rekursiven Abstiegsparser. Der Einfachheit halber der Code\n" +"Panik, wenn ein Ausdruck syntaktisch falsch ist (zum Beispiel `2-34` oder `2+5-`\n" +"sind laut Grammatikdefinition falsch)." + +#: src\patterns/behavioural/interpreter.md:53 +msgid "" +"```rust\n" +"pub struct Interpreter<'a> {\n" +" it: std::str::Chars<'a>,\n" +"}\n" +"\n" +"impl<'a> Interpreter<'a> {\n" +"\n" +" pub fn new(infix: &'a str) -> Self {\n" +" Self { it: infix.chars() }\n" +" }\n" +"\n" +" fn next_char(&mut self) -> Option {\n" +" self.it.next()\n" +" }\n" +"\n" +" pub fn interpret(&mut self, out: &mut String) {\n" +" self.term(out);\n" +"\n" +" while let Some(op) = self.next_char() {\n" +" if op == '+' || op == '-' {\n" +" self.term(out);\n" +" out.push(op);\n" +" } else {\n" +" panic!(\"Unexpected symbol '{}'\", op);\n" +" }\n" +" }\n" +" }\n" +"\n" +" fn term(&mut self, out: &mut String) {\n" +" match self.next_char() {\n" +" Some(ch) if ch.is_digit(10) => out.push(ch),\n" +" Some(ch) => panic!(\"Unexpected symbol '{}'\", ch),\n" +" None => panic!(\"Unexpected end of string\"),\n" +" }\n" +" }\n" +"}\n" +"\n" +"pub fn main() {\n" +" let mut intr = Interpreter::new(\"2+3\");\n" +" let mut postfix = String::new();\n" +" intr.interpret(&mut postfix);\n" +" assert_eq!(postfix, \"23+\");\n" +"\n" +" intr = Interpreter::new(\"1-2+3-4\");\n" +" postfix.clear();\n" +" intr.interpret(&mut postfix);\n" +" assert_eq!(postfix, \"12-3+4-\");\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/interpreter.md:105 +msgid "" +"There may be a wrong perception that the Interpreter design pattern is about design\n" +"grammars for formal languages and implementation of parsers for these grammars.\n" +"In fact, this pattern is about expressing problem instances in a more specific\n" +"way and implementing functions/classes/structs that solve these problem instances.\n" +"Rust language has `macro_rules!` that allow us to define special syntax and rules\n" +"on how to expand this syntax into source code." +msgstr "" +"Möglicherweise besteht die falsche Wahrnehmung, dass es beim Interpreter-Entwurfsmuster um das Design von\n" +"Grammatiken für formale Sprachen und die Implementierung von Parsern für diese Grammatiken geht.\n" +"Tatsächlich geht es bei diesem Muster aber darum, Probleminstanzen in spezifischer Art und Weise\n" +"auszudrücken und Funktionen/Klassen/Strukturen zu implementieren, die diese Probleminstanzen lösen.\n" +"Rust hat `macro_rules!`, welches es uns ermöglicht,mit Hilfe spezieller Syntax Regeln zu definieren\n" +"wie man diese Syntax im Quellcode erweitert." + +#: src\patterns/behavioural/interpreter.md:112 +#, fuzzy +msgid "" +"In the following example we create a simple `macro_rules!` that computes\n" +"[Euclidean length](https://en.wikipedia.org/wiki/Euclidean_distance) of `n`\n" +"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and more\n" +"efficient than packing `x,1,2` into a `Vec` and calling a function computing\n" +"the length." +msgstr "" +"Im folgenden Beispiel erstellen wir eine einfache `macro_rules!`, die berechnet\n" +"[Euklidische Länge](https://en.wikipedia.org/wiki/Euclidean_distance) von `n`\n" +"dimensionale Vektoren. Das Schreiben von „Norm!(x,1,2)“ ist möglicherweise einfacher auszudrücken und mehr\n" +"effizienter als `x,1,2` in ein `Vec` zu packen und eine Funktionsberechnung aufzurufen\n" +"die Länge." + +#: src\patterns/behavioural/interpreter.md:118 +msgid "" +"```rust\n" +"macro_rules! norm {\n" +" ($($element:expr),*) => {\n" +" {\n" +" let mut n = 0.0;\n" +" $(\n" +" n += ($element as f64)*($element as f64);\n" +" )*\n" +" n.sqrt()\n" +" }\n" +" };\n" +"}\n" +"\n" +"fn main() {\n" +" let x = -3f64;\n" +" let y = 4f64;\n" +"\n" +" assert_eq!(3f64, norm!(x));\n" +" assert_eq!(5f64, norm!(x, y));\n" +" assert_eq!(0f64, norm!(0, 0, 0)); \n" +" assert_eq!(1f64, norm!(0.5, -0.5, 0.5, -0.5));\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/interpreter.md:144 +#, fuzzy +msgid "" +"- [Interpreter pattern](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" +"- [Context free grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" +msgstr "" +"- [Interpreter-Muster](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" +"- [Kontextfreie Grammatik](https://en.wikipedia.org/wiki/Kontextfreie_Grammatik)\n" +"- [Makroregeln!](https://doc.rust-lang.org/rust-by-example/macros.html)" + +#: src\patterns/behavioural/newtype.md:1 +#, fuzzy +msgid "# Newtype" +msgstr "# Neuer Typ" + +#: src\patterns/behavioural/newtype.md:3 +#, fuzzy +msgid "" +"What if in some cases we want a type to behave similar to another type or\n" +"enforce some behaviour at compile time when using only type aliases would\n" +"not be enough?" +msgstr "" +"Was ist, wenn wir in einigen Fällen möchten, dass sich ein Typ ähnlich wie ein anderer Typ verhält oder\n" +"einiges Verhalten zur Kompilierzeit erzwingen, wenn nur Typaliase verwendet würden\n" +"nicht genug sein?" + +#: src\patterns/behavioural/newtype.md:7 +#, fuzzy +msgid "" +"For example, if we want to create a custom `Display` implementation for `String`\n" +"due to security considerations (e.g. passwords)." +msgstr "" +"Zum Beispiel, wenn wir eine benutzerdefinierte „Display“-Implementierung für „String“ erstellen möchten\n" +"aufgrund von Sicherheitserwägungen (z. B. Passwörter)." + +#: src\patterns/behavioural/newtype.md:10 +#, fuzzy +msgid "" +"For such cases we could use the `Newtype` pattern to provide **type safety**\n" +"and **encapsulation**." +msgstr "" +"Für solche Fälle könnten wir das `Newtype`-Muster verwenden, um **Typensicherheit** zu bieten\n" +"und **Verkapselung**." + +#: src\patterns/behavioural/newtype.md:15 +#, fuzzy +msgid "" +"Use a tuple struct with a single field to make an opaque wrapper for a type.\n" +"This creates a new type, rather than an alias to a type (`type` items)." +msgstr "" +"Verwenden Sie eine Tupelstruktur mit einem einzelnen Feld, um einen undurchsichtigen Wrapper für einen Typ zu erstellen.\n" +"Dadurch wird ein neuer Typ erstellt und kein Alias für einen Typ (`Typ`-Elemente)." + +#: src\patterns/behavioural/newtype.md:20 +msgid "" +"```rust,ignore\n" +"// Some type, not necessarily in the same module or even crate.\n" +"struct Foo {\n" +" //..\n" +"}\n" +"\n" +"impl Foo {\n" +" // These functions are not present on Bar.\n" +" //..\n" +"}\n" +"\n" +"// The newtype.\n" +"pub struct Bar(Foo);\n" +"\n" +"impl Bar {\n" +" // Constructor.\n" +" pub fn new(\n" +" //..\n" +" ) -> Self {\n" +"\n" +" //..\n" +"\n" +" }\n" +"\n" +" //..\n" +"}\n" +"\n" +"fn main() {\n" +" let b = Bar::new(...);\n" +"\n" +" // Foo and Bar are type incompatible, the following do not type check.\n" +" // let f: Foo = b;\n" +" // let b: Bar = Foo { ... };\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/newtype.md:58 +#, fuzzy +msgid "" +"The primary motivation for newtypes is abstraction. It allows you to share\n" +"implementation details between types while precisely controlling the interface.\n" +"By using a newtype rather than exposing the implementation type as part of an\n" +"API, it allows you to change implementation backwards compatibly." +msgstr "" +"Die Hauptmotivation für neue Typen ist die Abstraktion. Es erlaubt Ihnen zu teilen\n" +"Implementierungsdetails zwischen den Typen, während die Schnittstelle präzise gesteuert wird.\n" +"Durch die Verwendung eines neuen Typs, anstatt den Implementierungstyp als Teil einer\n" +"API ermöglicht es Ihnen, die Implementierung rückwärtskompatibel zu ändern." + +#: src\patterns/behavioural/newtype.md:63 +#, fuzzy +msgid "" +"Newtypes can be used for distinguishing units, e.g., wrapping `f64` to give\n" +"distinguishable `Miles` and `Kilometres`." +msgstr "" +"Newtypes können zur Unterscheidung von Einheiten verwendet werden, um z. B. `f64` zu umhüllen\n" +"unterscheidbare „Meilen“ und „Kilometer“." + +#: src\patterns/behavioural/newtype.md:68 +#, fuzzy +msgid "" +"The wrapped and wrapper types are not type compatible (as opposed to using\n" +"`type`), so users of the newtype will never 'confuse' the wrapped and wrapper\n" +"types." +msgstr "" +"Die Wrapper- und Wrapper-Typen sind nicht typkompatibel (im Gegensatz zu using\n" +"`type`), so dass Benutzer des neuen Typs Wrapper und Wrapper niemals 'verwechseln' werden\n" +"Typen." + +#: src\patterns/behavioural/newtype.md:72 +#, fuzzy +msgid "Newtypes are a zero-cost abstraction - there is no runtime overhead." +msgstr "Newtypes sind eine Zero-Cost-Abstraktion – es gibt keinen Laufzeit-Overhead." + +#: src\patterns/behavioural/newtype.md:74 +#, fuzzy +msgid "" +"The privacy system ensures that users cannot access the wrapped type (if the\n" +"field is private, which it is by default)." +msgstr "" +"Das Datenschutzsystem stellt sicher, dass Benutzer nicht auf den umschlossenen Typ zugreifen können (falls die\n" +"Feld ist privat, was es standardmäßig ist)." + +#: src\patterns/behavioural/newtype.md:79 +#, fuzzy +msgid "" +"The downside of newtypes (especially compared with type aliases), is that there\n" +"is no special language support. This means there can be _a lot_ of boilerplate.\n" +"You need a 'pass through' method for every method you want to expose on the\n" +"wrapped type, and an impl for every trait you want to also be implemented for\n" +"the wrapper type." +msgstr "" +"Der Nachteil von newtypes (insbesondere im Vergleich zu Type-Aliases) ist, dass es sie gibt\n" +"ist keine spezielle Sprachunterstützung. Dies bedeutet, dass es _viele_ Boilerplates geben kann.\n" +"Sie benötigen eine 'Pass-Through'-Methode für jede Methode, die Sie auf dem verfügbar machen möchten\n" +"umschlossener Typ und ein Impl für jede Eigenschaft, für die Sie auch implementiert werden möchten\n" +"der Wrapper-Typ." + +#: src\patterns/behavioural/newtype.md:87 +#, fuzzy +msgid "" +"Newtypes are very common in Rust code. Abstraction or representing units are the\n" +"most common uses, but they can be used for other reasons:" +msgstr "" +"Newtypes sind im Rust-Code sehr verbreitet. Abstraktion oder darstellende Einheiten sind die\n" +"Die häufigsten Anwendungen, aber sie können auch aus anderen Gründen verwendet werden:" + +#: src\patterns/behavioural/newtype.md:90 +#, fuzzy +msgid "" +"- restricting functionality (reduce the functions exposed or traits implemented),\n" +"- making a type with copy semantics have move semantics,\n" +"- abstraction by providing a more concrete type and thus hiding internal types,\n" +" e.g.," +msgstr "" +"- Einschränkung der Funktionalität (Reduzierung der angezeigten Funktionen oder implementierten Eigenschaften),\n" +"- Erstellen eines Typs mit Kopiersemantik hat Bewegungssemantik,\n" +"- Abstraktion durch Bereitstellung eines konkreteren Typs und damit Ausblenden interner Typen,\n" +" z.B.," + +#: src\patterns/behavioural/newtype.md:95 +msgid "" +"```rust,ignore\n" +"pub struct Foo(Bar);\n" +"```" +msgstr "" + +#: src\patterns/behavioural/newtype.md:99 +#, fuzzy +msgid "" +"Here, `Bar` might be some public, generic type and `T1` and `T2` are some internal\n" +"types. Users of our module shouldn't know that we implement `Foo` by using a `Bar`,\n" +"but what we're really hiding here is the types `T1` and `T2`, and how they are used\n" +"with `Bar`." +msgstr "" +"Hier könnte „Bar“ ein öffentlicher, generischer Typ sein und „T1“ und „T2“ sind einige interne\n" +"Typen. Benutzer unseres Moduls sollten nicht wissen, dass wir `Foo` implementieren, indem wir eine `Bar` verwenden,\n" +"aber was wir hier wirklich verstecken, sind die Typen `T1` und `T2` und wie sie verwendet werden\n" +"mit \"Balken\"." + +#: src\patterns/behavioural/newtype.md:106 +#, fuzzy +msgid "" +"- [Advanced Types in the book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-" +"type-safety-and-abstraction)\n" +"- [Newtypes in Haskell](https://wiki.haskell.org/Newtype)\n" +"- [Type aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving many\n" +" builtin traits on newtypes.\n" +"- [The Newtype Pattern In Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +msgstr "" +"- [Erweiterte Typen im Buch](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-" +"type-safety -und-Abstraktion)\n" +"- [Neue Typen in Haskell] (https://wiki.haskell.org/Newtype)\n" +"- [Aliase eingeben](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), eine Kiste zum Ableiten vieler\n" +" eingebaute Merkmale auf neuen Typen.\n" +"- [Das Newtype-Muster in Rost](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" + +#: src\patterns/behavioural/RAII.md:1 +#, fuzzy +msgid "# RAII with guards" +msgstr "# RAII mit Wachen" + +#: src\patterns/behavioural/RAII.md:5 +#, fuzzy +msgid "" +"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" which is a\n" +"terrible name. The essence of the pattern is that resource initialisation is done\n" +"in the constructor of an object and finalisation in the destructor. This pattern\n" +"is extended in Rust by using a RAII object as a guard of some resource and relying\n" +"on the type system to ensure that access is always mediated by the guard object." +msgstr "" +"[RAII][wikipedia] steht für „Resource Acquisition is Initialisation“, was eine\n" +"schrecklicher Name. Die Essenz des Musters besteht darin, dass eine Ressourceninitialisierung durchgeführt wird\n" +"im Konstruktor eines Objekts und Finalisierung im Destruktor. Dieses Muster\n" +"wird in Rust erweitert, indem ein RAII-Objekt als Wächter für eine Ressource verwendet und darauf vertraut wird\n" +"auf dem Typsystem, um sicherzustellen, dass der Zugriff immer durch das Schutzobjekt vermittelt wird." + +#: src\patterns/behavioural/RAII.md:13 +#, fuzzy +msgid "" +"Mutex guards are the classic example of this pattern from the std library (this\n" +"is a simplified version of the real implementation):" +msgstr "" +"Mutex Guards sind das klassische Beispiel für dieses Muster aus der std-Bibliothek (this\n" +"ist eine vereinfachte Version der realen Implementierung):" + +#: src\patterns/behavioural/RAII.md:16 +msgid "" +"```rust,ignore\n" +"use std::ops::Deref;\n" +"\n" +"struct Foo {}\n" +"\n" +"struct Mutex {\n" +" // We keep a reference to our data: T here.\n" +" //..\n" +"}\n" +"\n" +"struct MutexGuard<'a, T: 'a> {\n" +" data: &'a T,\n" +" //..\n" +"}\n" +"\n" +"// Locking the mutex is explicit.\n" +"impl Mutex {\n" +" fn lock(&self) -> MutexGuard {\n" +" // Lock the underlying OS mutex.\n" +" //..\n" +"\n" +" // MutexGuard keeps a reference to self\n" +" MutexGuard {\n" +" data: self,\n" +" //..\n" +" }\n" +" }\n" +"}\n" +"\n" +"// Destructor for unlocking the mutex.\n" +"impl<'a, T> Drop for MutexGuard<'a, T> {\n" +" fn drop(&mut self) {\n" +" // Unlock the underlying OS mutex.\n" +" //..\n" +" }\n" +"}\n" +"\n" +"// Implementing Deref means we can treat MutexGuard like a pointer to T.\n" +"impl<'a, T> Deref for MutexGuard<'a, T> {\n" +" type Target = T;\n" +"\n" +" fn deref(&self) -> &T {\n" +" self.data\n" +" }\n" +"}\n" +"\n" +"fn baz(x: Mutex) {\n" +" let xx = x.lock();\n" +" xx.foo(); // foo is a method on Foo.\n" +" // The borrow checker ensures we can't store a reference to the underlying\n" +" // Foo which will outlive the guard xx.\n" +"\n" +" // x is unlocked when we exit this function and xx's destructor is executed.\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/RAII.md:74 +#, fuzzy +msgid "" +"Where a resource must be finalised after use, RAII can be used to do this\n" +"finalisation. If it is an error to access that resource after finalisation, then\n" +"this pattern can be used to prevent such errors." +msgstr "" +"Wenn eine Ressource nach der Verwendung fertiggestellt werden muss, kann RAII dazu verwendet werden\n" +"Abschluss. Wenn es ein Fehler ist, nach Abschluss auf diese Ressource zuzugreifen, dann\n" +"Dieses Muster kann verwendet werden, um solche Fehler zu verhindern." + +#: src\patterns/behavioural/RAII.md:80 +#, fuzzy +msgid "" +"Prevents errors where a resource is not finalised and where a resource is used\n" +"after finalisation." +msgstr "" +"Verhindert Fehler, wenn eine Ressource nicht abgeschlossen ist und wenn eine Ressource verwendet wird\n" +"nach Abschluss." + +#: src\patterns/behavioural/RAII.md:85 +#, fuzzy +msgid "" +"RAII is a useful pattern for ensuring resources are properly deallocated or\n" +"finalised. We can make use of the borrow checker in Rust to statically prevent\n" +"errors stemming from using resources after finalisation takes place." +msgstr "" +"RAII ist ein nützliches Muster, um sicherzustellen, dass Ressourcen ordnungsgemäß freigegeben oder freigegeben werden\n" +"abgeschlossen. Zur statischen Vorbeugung können wir auf den Borrow-Checker in Rust zurückgreifen\n" +"Fehler, die sich aus der Verwendung von Ressourcen ergeben, nachdem die Finalisierung stattgefunden hat." + +#: src\patterns/behavioural/RAII.md:89 +#, fuzzy +msgid "" +"The core aim of the borrow checker is to ensure that references to data do not\n" +"outlive that data. The RAII guard pattern works because the guard object\n" +"contains a reference to the underlying resource and only exposes such\n" +"references. Rust ensures that the guard cannot outlive the underlying resource\n" +"and that references to the resource mediated by the guard cannot outlive the\n" +"guard. To see how this works it is helpful to examine the signature of `deref`\n" +"without lifetime elision:" +msgstr "" +"Das Hauptziel des Borrow-Checkers ist sicherzustellen, dass Verweise auf Daten dies nicht tun\n" +"überleben diese Daten. Das RAII-Schutzmuster funktioniert, weil das Schutzobjekt\n" +"enthält einen Verweis auf die zugrunde liegende Ressource und macht nur diese verfügbar\n" +"Verweise. Rust stellt sicher, dass der Wächter die zugrunde liegende Ressource nicht überleben kann\n" +"und dass Verweise auf die Ressource, die durch den Wächter vermittelt werden, die nicht überleben können\n" +"bewachen. Um zu sehen, wie das funktioniert, ist es hilfreich, die Signatur von `deref` zu untersuchen\n" +"ohne lebenslange Elision:" + +#: src\patterns/behavioural/RAII.md:97 +msgid "" +"```rust,ignore\n" +"fn deref<'a>(&'a self) -> &'a T {\n" +" //..\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/RAII.md:103 +#, fuzzy +msgid "" +"The returned reference to the resource has the same lifetime as `self` (`'a`).\n" +"The borrow checker therefore ensures that the lifetime of the reference to `T`\n" +"is shorter than the lifetime of `self`." +msgstr "" +"Die zurückgegebene Referenz auf die Ressource hat die gleiche Lebensdauer wie `self` (`'a`).\n" +"Der Borrow-Checker stellt daher sicher, dass die Lebensdauer des Verweises auf 'T'\n" +"ist kürzer als die Lebenszeit von „self“." + +#: src\patterns/behavioural/RAII.md:107 +#, fuzzy +msgid "" +"Note that implementing `Deref` is not a core part of this pattern, it only makes\n" +"using the guard object more ergonomic. Implementing a `get` method on the guard\n" +"works just as well." +msgstr "" +"Beachten Sie, dass die Implementierung von `Deref` kein Kernbestandteil dieses Musters ist, es macht nur\n" +"Verwendung des Schutzobjekts ergonomischer. Implementieren einer `get`-Methode auf dem Wächter\n" +"funktioniert genauso gut." + +#: src\patterns/behavioural/RAII.md:113 +#, fuzzy +msgid "[Finalisation in destructors idiom](../../idioms/dtor-finally.md)" +msgstr "[Finalisierung im Destruktoren-Idiom](../../idioms/dtor-finally.md)" + +#: src\patterns/behavioural/RAII.md:115 +#, fuzzy +msgid "" +"RAII is a common pattern in C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"[wikipedia][wikipedia]." +msgstr "" +"RAII ist ein allgemeines Muster in C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"[wikipedia][wikipedia]." + +#: src\patterns/behavioural/RAII.md:120 +#, fuzzy +msgid "" +"[Style guide entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"(currently just a placeholder)." +msgstr "" +"[Styleguide-Eintrag](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"(derzeit nur ein Platzhalter)." + +#: src\patterns/behavioural/strategy.md:1 +msgid "# Strategy (aka Policy)" +msgstr "# Strategie (auch bekannt als Richtlinie)" + +#: src\patterns/behavioural/strategy.md:5 +msgid "" +"The [Strategy design pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"is a technique that enables separation of concerns.\n" +"It also allows to decouple software modules through [Dependency Inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +msgstr "" +"Das [Strategy Entwurfsmuster](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"ist eine Technik, die die Trennung von Belangen ermöglicht.\n" +"Es ermöglicht auch die Entkopplung von Softwaremodulen durch [Dependency Inversion](https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." + +#: src\patterns/behavioural/strategy.md:9 +#, fuzzy +msgid "" +"The basic idea behind the Strategy pattern is that, given an algorithm solving\n" +"a particular problem, we define only the skeleton of the algorithm at an abstract\n" +"level, and we separate the specific algorithm’s implementation into different parts." +msgstr "" +"Die Grundidee hinter dem Strategiemuster ist, dass bei gegebenem Algorithmus gelöst wird\n" +"Bei einem bestimmten Problem definieren wir nur das Skelett des Algorithmus in einer Zusammenfassung\n" +"Ebene, und wir trennen die Implementierung des spezifischen Algorithmus in verschiedene Teile." + +#: src\patterns/behavioural/strategy.md:13 +#, fuzzy +msgid "" +"In this way, a client using the algorithm may choose a specific implementation,\n" +"while the general algorithm workflow remains the same. In other words, the abstract\n" +"specification of the class does not depend on the specific implementation of the\n" +"derived class, but specific implementation must adhere to the abstract specification.\n" +"This is why we call it \"Dependency Inversion\"." +msgstr "" +"Auf diese Weise kann ein Client, der den Algorithmus verwendet, eine bestimmte Implementierung auswählen,\n" +"während der allgemeine Algorithmus-Workflow derselbe bleibt. Mit anderen Worten, das Abstrakte\n" +"Die Spezifikation der Klasse hängt nicht von der spezifischen Implementierung der ab\n" +"abgeleitete Klasse, aber die spezifische Implementierung muss der abstrakten Spezifikation entsprechen.\n" +"Deshalb nennen wir es \"Abhängigkeitsinversion\"." + +#: src\patterns/behavioural/strategy.md:21 +#, fuzzy +msgid "" +"Imagine we are working on a project that generates reports every month.\n" +"We need the reports to be generated in different formats (strategies), e.g.,\n" +"in `JSON` or `Plain Text` formats.\n" +"But things vary over time, and we don't know what kind of requirement we may get\n" +"in the future. For example, we may need to generate our report in a completely new\n" +"format, or just modify one of the existing formats." +msgstr "" +"Stellen Sie sich vor, wir arbeiten an einem Projekt, das jeden Monat Berichte generiert.\n" +"Wir benötigen die zu generierenden Berichte in unterschiedlichen Formaten (Strategien), z. B.\n" +"im `JSON`- oder `Plain Text`-Format.\n" +"Aber die Dinge ändern sich im Laufe der Zeit, und wir wissen nicht, welche Art von Anforderung wir erhalten werden\n" +"in der Zukunft. Zum Beispiel müssen wir unseren Bericht möglicherweise komplett neu erstellen\n" +"formatieren oder einfach eines der vorhandenen Formate ändern." + +#: src\patterns/behavioural/strategy.md:30 +#, fuzzy +msgid "" +"In this example our invariants (or abstractions) are `Context`, `Formatter`,\n" +"and `Report`, while `Text` and `Json` are our strategy structs. These strategies\n" +"have to implement the `Formatter` trait." +msgstr "" +"In diesem Beispiel sind unsere Invarianten (oder Abstraktionen) `Context`, `Formatter`,\n" +"und „Report“, während „Text“ und „Json“ unsere Strategiestrukturen sind. Diese Strategien\n" +"müssen die Eigenschaft \"Formatter\" implementieren." + +#: src\patterns/behavioural/strategy.md:34 +msgid "" +"```rust\n" +"use std::collections::HashMap;\n" +"\n" +"type Data = HashMap;\n" +"\n" +"trait Formatter {\n" +" fn format(&self, data: &Data, buf: &mut String);\n" +"}\n" +"\n" +"struct Report;\n" +"\n" +"impl Report {\n" +" // Write should be used but we kept it as String to ignore error handling\n" +" fn generate(g: T, s: &mut String) {\n" +" // backend operations...\n" +" let mut data = HashMap::new();\n" +" data.insert(\"one\".to_string(), 1);\n" +" data.insert(\"two\".to_string(), 2);\n" +" // generate report\n" +" g.format(&data, s);\n" +" }\n" +"}\n" +"\n" +"struct Text;\n" +"impl Formatter for Text {\n" +" fn format(&self, data: &Data, buf: &mut String) {\n" +" for (k, v) in data {\n" +" let entry = format!(\"{} {}\\n\", k, v);\n" +" buf.push_str(&entry);\n" +" }\n" +" }\n" +"}\n" +"\n" +"struct Json;\n" +"impl Formatter for Json {\n" +" fn format(&self, data: &Data, buf: &mut String) {\n" +" buf.push('[');\n" +" for (k, v) in data.into_iter() {\n" +" let entry = format!(r#\"{{\"{}\":\"{}\"}}\"#, k, v);\n" +" buf.push_str(&entry);\n" +" buf.push(',');\n" +" }\n" +" if !data.is_empty() {\n" +" buf.pop(); // remove extra , at the end\n" +" }\n" +" buf.push(']');\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" let mut s = String::from(\"\");\n" +" Report::generate(Text, &mut s);\n" +" assert!(s.contains(\"one 1\"));\n" +" assert!(s.contains(\"two 2\"));\n" +"\n" +" s.clear(); // reuse the same buffer\n" +" Report::generate(Json, &mut s);\n" +" assert!(s.contains(r#\"{\"one\":\"1\"}\"#));\n" +" assert!(s.contains(r#\"{\"two\":\"2\"}\"#));\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/strategy.md:98 +#, fuzzy +msgid "" +"The main advantage is separation of concerns. For example, in this case `Report`\n" +"does not know anything about specific implementations of `Json` and `Text`,\n" +"whereas the output implementations does not care about how data is preprocessed,\n" +"stored, and fetched. The only thing they have to know is context and a specific\n" +"trait and method to implement, i.e,`Formatter` and `run`." +msgstr "" +"Der Hauptvorteil ist die Trennung von Anliegen. Zum Beispiel in diesem Fall „Bericht“.\n" +"weiß nichts über spezifische Implementierungen von `Json` und `Text`,\n" +"während die Ausgabeimplementierungen sich nicht darum kümmern, wie Daten vorverarbeitet werden,\n" +"gespeichert und abgeholt. Das einzige, was sie wissen müssen, ist der Kontext und ein Spezifikum\n" +"Trait und zu implementierende Methode, d. h. „Formatter“ und „run“." + +#: src\patterns/behavioural/strategy.md:106 +#, fuzzy +msgid "" +"For each strategy there must be implemented at least one module, so number of modules\n" +"increases with number of strategies. If there are many strategies to choose from\n" +"then users have to know how strategies differ from one another." +msgstr "" +"Für jede Strategie muss mindestens ein Modul implementiert werden, also Anzahl Module\n" +"steigt mit der Anzahl der Strategien. Wenn es viele Strategien zur Auswahl gibt\n" +"dann müssen die Benutzer wissen, wie sich die Strategien voneinander unterscheiden." + +#: src\patterns/behavioural/strategy.md:112 +#, fuzzy +msgid "" +"In the previous example all strategies are implemented in a single file.\n" +"Ways of providing different strategies includes:" +msgstr "" +"Im vorherigen Beispiel sind alle Strategien in einer einzigen Datei implementiert.\n" +"Zu den Möglichkeiten, verschiedene Strategien bereitzustellen, gehören:" + +#: src\patterns/behavioural/strategy.md:115 +#, fuzzy +msgid "" +"- All in one file (as shown in this example, similar to being separated as modules)\n" +"- Separated as modules, E.g. `formatter::json` module, `formatter::text` module\n" +"- Use compiler feature flags, E.g. `json` feature, `text` feature\n" +"- Separated as crates, E.g. `json` crate, `text` crate" +msgstr "" +"- Alles in einer Datei (wie in diesem Beispiel gezeigt, ähnlich wie als Module getrennt)\n" +"- Als Module getrennt, z.B. `formatter::json`-Modul, `formatter::text`-Modul\n" +"- Verwenden Sie Compiler-Feature-Flags, z. „json“-Funktion, „text“-Funktion\n" +"- Getrennt als Kisten, z.B. „json“-Kiste, „text“-Kiste" + +#: src\patterns/behavioural/strategy.md:120 +#, fuzzy +msgid "" +"Serde crate is a good example of the `Strategy` pattern in action. Serde allows\n" +"[full customization](https://serde.rs/custom-serialization.html) of the serialization\n" +"behavior by manually implementing `Serialize` and `Deserialize` traits for our\n" +"type. For example, we could easily swap `serde_json` with `serde_cbor` since they\n" +"expose similar methods. Having this makes the helper crate `serde_transcode` much\n" +"more useful and ergonomic." +msgstr "" +"Die Serde-Kiste ist ein gutes Beispiel für das „Strategy“-Muster in Aktion. Serde erlaubt\n" +"[vollständige Anpassung](https://serde.rs/custom-serialization.html) der Serialisierung\n" +"Verhalten durch manuelles Implementieren der Traits „Serialize“ und „Deserialize“ für unsere\n" +"Typ. Zum Beispiel könnten wir `serde_json` leicht durch `serde_cbor` tauschen, da sie\n" +"ähnliche Methoden aufdecken. Dadurch wird die Hilfskiste `serde_transcode` sehr viel\n" +"nützlicher und ergonomischer." + +#: src\patterns/behavioural/strategy.md:127 +msgid "However, we don't need to use traits in order to design this pattern in Rust." +msgstr "Wir müssen jedoch keine Traits verwenden, um dieses Muster in Rust zu entwerfen." + +#: src\patterns/behavioural/strategy.md:129 +msgid "" +"The following toy example demonstrates the idea of the Strategy pattern using Rust\n" +"`closures`:" +msgstr "" +"Das folgende Beispiel demonstriert die Idee des Strategiemusters mit Hilfe von\n" +"Rust `closures`:" + +#: src\patterns/behavioural/strategy.md:132 +msgid "" +"```rust\n" +"struct Adder;\n" +"impl Adder {\n" +" pub fn add(x: u8, y: u8, f: F) -> u8\n" +" where\n" +" F: Fn(u8, u8) -> u8,\n" +" {\n" +" f(x, y)\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" let arith_adder = |x, y| x + y;\n" +" let bool_adder = |x, y| {\n" +" if x == 1 || y == 1 {\n" +" 1\n" +" } else {\n" +" 0\n" +" }\n" +" };\n" +" let custom_adder = |x, y| 2 * x + y;\n" +"\n" +" assert_eq!(9, Adder::add(4, 5, arith_adder));\n" +" assert_eq!(0, Adder::add(0, 0, bool_adder));\n" +" assert_eq!(5, Adder::add(1, 3, custom_adder));\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/strategy.md:160 +msgid "In fact, Rust already uses this idea for `Options`'s `map` method:" +msgstr "Tatsächlich verwendet Rust diese Idee bereits für die `map`-Methode von `Option`:" + +#: src\patterns/behavioural/strategy.md:162 +msgid "" +"```rust\n" +"fn main() {\n" +" let val = Some(\"Rust\");\n" +"\n" +" let len_strategy = |s: &str| s.len();\n" +" assert_eq!(4, val.map(len_strategy).unwrap());\n" +"\n" +" let first_byte_strategy = |s: &str| s.bytes().next().unwrap();\n" +" assert_eq!(82, val.map(first_byte_strategy).unwrap());\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/strategy.md:176 +#, fuzzy +msgid "" +"- [Strategy Pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"- [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Policy Based Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +msgstr "" +"- [Strategiemuster](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"- [Abhängigkeitsinjektion](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Richtlinienbasiertes Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" + +#: src\patterns/behavioural/visitor.md:1 +#, fuzzy +msgid "# Visitor" +msgstr "# Besucher" + +#: src\patterns/behavioural/visitor.md:5 +#, fuzzy +msgid "" +"A visitor encapsulates an algorithm that operates over a heterogeneous\n" +"collection of objects. It allows multiple different algorithms to be written\n" +"over the same data without having to modify the data (or their primary\n" +"behaviour)." +msgstr "" +"Ein Besucher kapselt einen Algorithmus ein, der über eine heterogene Struktur hinweg arbeitet\n" +"Sammlung von Objekten. Es ermöglicht das Schreiben mehrerer verschiedener Algorithmen\n" +"über dieselben Daten, ohne die Daten (oder ihre primäre\n" +"Verhalten)." + +#: src\patterns/behavioural/visitor.md:10 +#, fuzzy +msgid "" +"Furthermore, the visitor pattern allows separating the traversal of\n" +"a collection of objects from the operations performed on each object." +msgstr "" +"Darüber hinaus ermöglicht das Besuchermuster das Trennen der Durchquerung von\n" +"eine Sammlung von Objekten aus den Operationen, die an jedem Objekt durchgeführt werden." + +#: src\patterns/behavioural/visitor.md:15 +msgid "" +"```rust,ignore\n" +"// The data we will visit\n" +"mod ast {\n" +" pub enum Stmt {\n" +" Expr(Expr),\n" +" Let(Name, Expr),\n" +" }\n" +"\n" +" pub struct Name {\n" +" value: String,\n" +" }\n" +"\n" +" pub enum Expr {\n" +" IntLit(i64),\n" +" Add(Box, Box),\n" +" Sub(Box, Box),\n" +" }\n" +"}\n" +"\n" +"// The abstract visitor\n" +"mod visit {\n" +" use ast::*;\n" +"\n" +" pub trait Visitor {\n" +" fn visit_name(&mut self, n: &Name) -> T;\n" +" fn visit_stmt(&mut self, s: &Stmt) -> T;\n" +" fn visit_expr(&mut self, e: &Expr) -> T;\n" +" }\n" +"}\n" +"\n" +"use visit::*;\n" +"use ast::*;\n" +"\n" +"// An example concrete implementation - walks the AST interpreting it as code.\n" +"struct Interpreter;\n" +"impl Visitor for Interpreter {\n" +" fn visit_name(&mut self, n: &Name) -> i64 { panic!() }\n" +" fn visit_stmt(&mut self, s: &Stmt) -> i64 {\n" +" match *s {\n" +" Stmt::Expr(ref e) => self.visit_expr(e),\n" +" Stmt::Let(..) => unimplemented!(),\n" +" }\n" +" }\n" +"\n" +" fn visit_expr(&mut self, e: &Expr) -> i64 {\n" +" match *e {\n" +" Expr::IntLit(n) => n,\n" +" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + self.visit_expr(rhs),\n" +" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - self.visit_expr(rhs),\n" +" }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/visitor.md:69 +#, fuzzy +msgid "" +"One could implement further visitors, for example a type checker, without having\n" +"to modify the AST data." +msgstr "" +"Man könnte weitere Besucher implementieren, zum Beispiel einen Type Checker, ohne das man haben muss\n" +"um die AST-Daten zu ändern." + +#: src\patterns/behavioural/visitor.md:74 +#, fuzzy +msgid "" +"The visitor pattern is useful anywhere that you want to apply an algorithm to\n" +"heterogeneous data. If data is homogeneous, you can use an iterator-like pattern.\n" +"Using a visitor object (rather than a functional approach) allows the visitor to\n" +"be stateful and thus communicate information between nodes." +msgstr "" +"Das Besuchermuster ist überall dort nützlich, wo Sie einen Algorithmus anwenden möchten\n" +"heterogene Daten. Wenn die Daten homogen sind, können Sie ein Iterator-ähnliches Muster verwenden.\n" +"Die Verwendung eines Besucherobjekts (anstelle eines funktionalen Ansatzes) ermöglicht es dem Besucher\n" +"zustandsbehaftet sein und somit Informationen zwischen Knoten austauschen." + +#: src\patterns/behavioural/visitor.md:81 +#, fuzzy +msgid "" +"It is common for the `visit_*` methods to return void (as opposed to in the\n" +"example). In that case it is possible to factor out the traversal code and share\n" +"it between algorithms (and also to provide noop default methods). In Rust, the\n" +"common way to do this is to provide `walk_*` functions for each datum. For\n" +"example," +msgstr "" +"Es ist üblich, dass die `visit_*`-Methoden void zurückgeben (im Gegensatz zu in der\n" +"Beispiel). In diesem Fall ist es möglich, den Traversalcode auszuklammern und zu teilen\n" +"es zwischen Algorithmen (und auch um noop-Standardmethoden bereitzustellen). In Rust, der\n" +"Der übliche Weg, dies zu tun, besteht darin, `walk_*`-Funktionen für jedes Datum bereitzustellen. Für\n" +"Beispiel," + +#: src\patterns/behavioural/visitor.md:87 +msgid "" +"```rust,ignore\n" +"pub fn walk_expr(visitor: &mut Visitor, e: &Expr) {\n" +" match *e {\n" +" Expr::IntLit(_) => {},\n" +" Expr::Add(ref lhs, ref rhs) => {\n" +" visitor.visit_expr(lhs);\n" +" visitor.visit_expr(rhs);\n" +" }\n" +" Expr::Sub(ref lhs, ref rhs) => {\n" +" visitor.visit_expr(lhs);\n" +" visitor.visit_expr(rhs);\n" +" }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/behavioural/visitor.md:103 +#, fuzzy +msgid "" +"In other languages (e.g., Java) it is common for data to have an `accept` method\n" +"which performs the same duty." +msgstr "" +"In anderen Sprachen (z. B. Java) ist es üblich, dass Daten eine \"accept\"-Methode haben\n" +"der die gleiche Aufgabe erfüllt." + +#: src\patterns/behavioural/visitor.md:108 +msgid "The visitor pattern is a common pattern in most OO languages." +msgstr "Das Besuchermuster ist ein allgemeines Muster in den meisten OO-Sprachen." + +#: src\patterns/behavioural/visitor.md:110 +msgid "[Wikipedia article](https://en.wikipedia.org/wiki/Visitor_pattern)" +msgstr "[Wikipedia-Artikel](https://en.wikipedia.org/wiki/Visitor_pattern)" + +#: src\patterns/behavioural/visitor.md:112 +#, fuzzy +msgid "" +"The [fold](../creational/fold.md) pattern is similar to visitor but produces\n" +"a new version of the visited data structure." +msgstr "" +"Das Muster [fold](../creational/fold.md) ähnelt dem Muster „visitor“, produziert aber\n" +"eine neue Version der besuchten Datenstruktur." + +#: src\patterns/creational/intro.md:1 +msgid "# Creational Patterns" +msgstr "# Erzeugungsmuster" + +#: src\patterns/creational/intro.md:3 +msgid "From [Wikipedia](https://en.wikipedia.org/wiki/Creational_pattern):" +msgstr "Aus [Wikipedia](https://en.wikipedia.org/wiki/Creational_pattern):" + +#: src\patterns/creational/intro.md:5 +msgid "" +"> Design patterns that deal with object creation mechanisms, trying to create objects\n" +"> in a manner suitable to the situation. The basic form of object creation could\n" +"> result in design problems or in added complexity to the design. Creational design\n" +"> patterns solve this problem by somehow controlling this object creation." +msgstr "" +"> Entwurfsmuster, die sich mit Objekterstellungsmechanismen befassen und versuchen, Objekte\n" +"> der Situation angemessen zu erstellen. Die Grundform der Objekterstellung könnte\n" +"> zu Designproblemen oder zu zusätzlicher Komplexität des Designs führen. Erzeugungsmuster\n" +"> lösen dieses Problem, indem sie diese Objekterstellung steuern." + +#: src\patterns/creational/builder.md:1 +msgid "# Builder" +msgstr "# Erbauer" + +#: src\patterns/creational/builder.md:5 +#, fuzzy +msgid "Construct an object with calls to a builder helper." +msgstr "Konstruieren Sie ein Objekt mit Aufrufen eines Builder-Hilfsprogramms." + +#: src\patterns/creational/builder.md:9 +msgid "" +"```rust\n" +"#[derive(Debug, PartialEq)]\n" +"pub struct Foo {\n" +" // Lots of complicated fields.\n" +" bar: String,\n" +"}\n" +"\n" +"impl Foo {\n" +" // This method will help users to discover the builder\n" +" pub fn builder() -> FooBuilder {\n" +" FooBuilder::default()\n" +" }\n" +"}\n" +"\n" +"#[derive(Default)]\n" +"pub struct FooBuilder {\n" +" // Probably lots of optional fields.\n" +" bar: String,\n" +"}\n" +"\n" +"impl FooBuilder {\n" +" pub fn new(/* ... */) -> FooBuilder {\n" +" // Set the minimally required fields of Foo.\n" +" FooBuilder {\n" +" bar: String::from(\"X\"),\n" +" }\n" +" }\n" +"\n" +" pub fn name(mut self, bar: String) -> FooBuilder {\n" +" // Set the name on the builder itself, and return the builder by value.\n" +" self.bar = bar;\n" +" self\n" +" }\n" +"\n" +" // If we can get away with not consuming the Builder here, that is an\n" +" // advantage. It means we can use the FooBuilder as a template for constructing\n" +" // many Foos.\n" +" pub fn build(self) -> Foo {\n" +" // Create a Foo from the FooBuilder, applying all settings in FooBuilder\n" +" // to Foo.\n" +" Foo { bar: self.bar }\n" +" }\n" +"}\n" +"\n" +"#[test]\n" +"fn builder_test() {\n" +" let foo = Foo {\n" +" bar: String::from(\"Y\"),\n" +" };\n" +" let foo_from_builder: Foo = FooBuilder::new().name(String::from(\"Y\")).build();\n" +" assert_eq!(foo, foo_from_builder);\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/creational/builder.md:65 +#, fuzzy +msgid "" +"Useful when you would otherwise require many constructors or where\n" +"construction has side effects." +msgstr "" +"Nützlich, wenn Sie ansonsten viele Konstruktoren benötigen würden oder wo\n" +"Konstruktion hat Nebenwirkungen." + +#: src\patterns/creational/builder.md:70 +#, fuzzy +msgid "Separates methods for building from other methods." +msgstr "Trennt Methoden zum Erstellen von anderen Methoden." + +#: src\patterns/creational/builder.md:72 +#, fuzzy +msgid "Prevents proliferation of constructors." +msgstr "Verhindert die Verbreitung von Konstruktoren." + +#: src\patterns/creational/builder.md:74 +#, fuzzy +msgid "Can be used for one-liner initialisation as well as more complex construction." +msgstr "Kann sowohl für die einzeilige Initialisierung als auch für komplexere Konstruktionen verwendet werden." + +#: src\patterns/creational/builder.md:78 +#, fuzzy +msgid "" +"More complex than creating a struct object directly, or a simple constructor\n" +"function." +msgstr "" +"Komplexer als das direkte Erstellen eines Strukturobjekts oder eines einfachen Konstruktors\n" +"Funktion." + +#: src\patterns/creational/builder.md:83 +#, fuzzy +msgid "" +"This pattern is seen more frequently in Rust (and for simpler objects) than in\n" +"many other languages because Rust lacks overloading. Since you can only have a\n" +"single method with a given name, having multiple constructors is less nice in\n" +"Rust than in C++, Java, or others." +msgstr "" +"Dieses Muster ist häufiger in Rust (und bei einfacheren Objekten) zu sehen als in\n" +"viele andere Sprachen, weil Rust nicht überladen wird. Da Sie nur eine haben können\n" +"einzelne Methode mit einem bestimmten Namen, mehrere Konstruktoren zu haben, ist weniger schön\n" +"Rust als in C++, Java oder anderen." + +#: src\patterns/creational/builder.md:88 +#, fuzzy +msgid "" +"This pattern is often used where the builder object is useful in its own right,\n" +"rather than being just a builder. For example, see\n" +"[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" +"is a builder for [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(a process). In these cases, the `T` and `TBuilder` naming pattern is not used." +msgstr "" +"Dieses Muster wird häufig verwendet, wenn das Builder-Objekt selbst nützlich ist,\n" +"anstatt nur ein Baumeister zu sein. Siehe zum Beispiel\n" +"[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" +"ist ein Builder für [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(ein Prozess). In diesen Fällen wird das Benennungsmuster „T“ und „TBuilder“ nicht verwendet." + +#: src\patterns/creational/builder.md:94 +#, fuzzy +msgid "" +"The example takes and returns the builder by value. It is often more ergonomic\n" +"(and more efficient) to take and return the builder as a mutable reference. The\n" +"borrow checker makes this work naturally. This approach has the advantage that\n" +"one can write code like" +msgstr "" +"Das Beispiel nimmt den Builder nach Wert und gibt ihn zurück. Es ist oft ergonomischer\n" +"(und effizienter), um den Builder als veränderliche Referenz zu übernehmen und zurückzugeben. Der\n" +"Borrow Checker macht dies auf natürliche Weise möglich. Diese Vorgehensweise hat den Vorteil, dass\n" +"man kann Code schreiben wie" + +#: src\patterns/creational/builder.md:99 +msgid "" +"```rust,ignore\n" +"let mut fb = FooBuilder::new();\n" +"fb.a();\n" +"fb.b();\n" +"let f = fb.build();\n" +"```" +msgstr "" + +#: src\patterns/creational/builder.md:106 +#, fuzzy +msgid "as well as the `FooBuilder::new().a().b().build()` style." +msgstr "sowie den Stil `FooBuilder::new().a().b().build()`." + +#: src\patterns/creational/builder.md:110 +#, fuzzy +msgid "" +"- [Description in the style guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders." +"html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), a crate for automatically\n" +" implementing this pattern while avoiding the boilerplate.\n" +"- [Constructor pattern](../../idioms/ctor.md) for when construction is simpler.\n" +"- [Builder pattern (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Construction of complex values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety." +"html#c-builder)" +msgstr "" +"- [Beschreibung im Styleguide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), eine Kiste für automatisch\n" +" Implementieren dieses Musters unter Vermeidung der Boilerplate.\n" +"- [Konstruktormuster](../../idioms/ctor.md) für einfachere Konstruktionen.\n" +"- [Builder-Muster (Wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Konstruktion komplexer Werte](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-" +"builder)" + +#: src\patterns/creational/fold.md:1 +msgid "# Fold" +msgstr "# Falz" + +#: src\patterns/creational/fold.md:5 +#, fuzzy +msgid "" +"Run an algorithm over each item in a collection of data to create a new item,\n" +"thus creating a whole new collection." +msgstr "" +"Führen Sie einen Algorithmus über jedes Element in einer Datensammlung aus, um ein neues Element zu erstellen.\n" +"So entsteht eine ganz neue Kollektion." + +#: src\patterns/creational/fold.md:8 +#, fuzzy +msgid "" +"The etymology here is unclear to me. The terms 'fold' and 'folder' are used\n" +"in the Rust compiler, although it appears to me to be more like a map than a\n" +"fold in the usual sense. See the discussion below for more details." +msgstr "" +"Die Etymologie hier ist mir unklar. Es werden die Begriffe „Falte“ und „Ordner“ verwendet\n" +"im Rust-Compiler, obwohl es mir eher wie eine Karte als eine\n" +"im üblichen Sinne falten. Siehe die Diskussion unten für weitere Details." + +#: src\patterns/creational/fold.md:14 +msgid "" +"```rust,ignore\n" +"// The data we will fold, a simple AST.\n" +"mod ast {\n" +" pub enum Stmt {\n" +" Expr(Box),\n" +" Let(Box, Box),\n" +" }\n" +"\n" +" pub struct Name {\n" +" value: String,\n" +" }\n" +"\n" +" pub enum Expr {\n" +" IntLit(i64),\n" +" Add(Box, Box),\n" +" Sub(Box, Box),\n" +" }\n" +"}\n" +"\n" +"// The abstract folder\n" +"mod fold {\n" +" use ast::*;\n" +"\n" +" pub trait Folder {\n" +" // A leaf node just returns the node itself. In some cases, we can do this\n" +" // to inner nodes too.\n" +" fn fold_name(&mut self, n: Box) -> Box { n }\n" +" // Create a new inner node by folding its children.\n" +" fn fold_stmt(&mut self, s: Box) -> Box {\n" +" match *s {\n" +" Stmt::Expr(e) => Box::new(Stmt::Expr(self.fold_expr(e))),\n" +" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), self.fold_expr(e))),\n" +" }\n" +" }\n" +" fn fold_expr(&mut self, e: Box) -> Box { ... }\n" +" }\n" +"}\n" +"\n" +"use fold::*;\n" +"use ast::*;\n" +"\n" +"// An example concrete implementation - renames every name to 'foo'.\n" +"struct Renamer;\n" +"impl Folder for Renamer {\n" +" fn fold_name(&mut self, n: Box) -> Box {\n" +" Box::new(Name { value: \"foo\".to_owned() })\n" +" }\n" +" // Use the default methods for the other nodes.\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/creational/fold.md:65 +#, fuzzy +msgid "" +"The result of running the `Renamer` on an AST is a new AST identical to the old\n" +"one, but with every name changed to `foo`. A real life folder might have some\n" +"state preserved between nodes in the struct itself." +msgstr "" +"Das Ergebnis der Ausführung des \"Renamer\" auf einem AST ist ein neuer AST, der mit dem alten identisch ist\n" +"one, aber mit jedem Namen geändert zu `foo`. Ein echter Ordner könnte einige haben\n" +"Status, der zwischen Knoten in der Struktur selbst beibehalten wird." + +#: src\patterns/creational/fold.md:69 +#, fuzzy +msgid "" +"A folder can also be defined to map one data structure to a different (but\n" +"usually similar) data structure. For example, we could fold an AST into a HIR\n" +"tree (HIR stands for high-level intermediate representation)." +msgstr "" +"Ein Ordner kann auch definiert werden, um eine Datenstruktur einer anderen (but\n" +"normalerweise ähnliche) Datenstruktur. Zum Beispiel könnten wir einen AST in einen HIR falten\n" +"Baum (HIR steht für High-Level Intermediate Representation)." + +#: src\patterns/creational/fold.md:75 +#, fuzzy +msgid "" +"It is common to want to map a data structure by performing some operation on\n" +"each node in the structure. For simple operations on simple data structures,\n" +"this can be done using `Iterator::map`. For more complex operations, perhaps\n" +"where earlier nodes can affect the operation on later nodes, or where iteration\n" +"over the data structure is non-trivial, using the fold pattern is more\n" +"appropriate." +msgstr "" +"Es ist üblich, eine Datenstruktur abbilden zu wollen, indem man eine Operation an ihr ausführt\n" +"jeder Knoten in der Struktur. Für einfache Operationen auf einfachen Datenstrukturen,\n" +"Dies kann mit `Iterator::map` gemacht werden. Für komplexere Operationen vielleicht\n" +"wo frühere Knoten die Operation auf späteren Knoten beeinflussen können, oder wo Iteration\n" +"über die Datenstruktur ist nicht trivial, die Verwendung des Faltmusters ist mehr\n" +"geeignet." + +#: src\patterns/creational/fold.md:82 +#, fuzzy +msgid "" +"Like the visitor pattern, the fold pattern allows us to separate traversal of a\n" +"data structure from the operations performed to each node." +msgstr "" +"Wie das Besuchermuster erlaubt uns das Faltmuster, das Durchlaufen von a zu trennen\n" +"Datenstruktur aus den an jedem Knoten durchgeführten Operationen." + +#: src\patterns/creational/fold.md:87 +#, fuzzy +msgid "" +"Mapping data structures in this fashion is common in functional languages. In OO\n" +"languages, it would be more common to mutate the data structure in place. The\n" +"'functional' approach is common in Rust, mostly due to the preference for\n" +"immutability. Using fresh data structures, rather than mutating old ones, makes\n" +"reasoning about the code easier in most circumstances." +msgstr "" +"Das Abbilden von Datenstrukturen auf diese Weise ist in funktionalen Sprachen üblich. In O.O\n" +"Sprachen, wäre es üblicher, die vorhandene Datenstruktur zu verändern. Der\n" +"'funktionaler' Ansatz ist in Rust üblich, hauptsächlich aufgrund der Vorliebe für\n" +"Unveränderlichkeit. Die Verwendung neuer Datenstrukturen, anstatt alte zu mutieren, macht\n" +"In den meisten Fällen ist es einfacher, über den Code nachzudenken." + +#: src\patterns/creational/fold.md:93 +#, fuzzy +msgid "" +"The trade-off between efficiency and reusability can be tweaked by changing how\n" +"nodes are accepted by the `fold_*` methods." +msgstr "" +"Der Kompromiss zwischen Effizienz und Wiederverwendbarkeit kann optimiert werden, indem die Art und Weise geändert wird\n" +"Knoten werden von den `fold_*`-Methoden akzeptiert." + +#: src\patterns/creational/fold.md:96 +#, fuzzy +msgid "" +"In the above example we operate on `Box` pointers. Since these own their data\n" +"exclusively, the original copy of the data structure cannot be re-used. On the\n" +"other hand if a node is not changed, reusing it is very efficient." +msgstr "" +"Im obigen Beispiel arbeiten wir mit `Box`-Zeigern. Denn diese besitzen ihre Daten\n" +"ausschließlich kann die ursprüngliche Kopie der Datenstruktur nicht wiederverwendet werden. Auf der\n" +"Wenn andererseits ein Knoten nicht geändert wird, ist die Wiederverwendung sehr effizient." + +#: src\patterns/creational/fold.md:100 +msgid "" +"If we were to operate on borrowed references, the original data structure can be\n" +"reused; however, a node must be cloned even if unchanged, which can be\n" +"expensive." +msgstr "" + +#: src\patterns/creational/fold.md:104 +#, fuzzy +msgid "" +"Using a reference counted pointer gives the best of both worlds - we can reuse\n" +"the original data structure, and we don't need to clone unchanged nodes. However,\n" +"they are less ergonomic to use and mean that the data structures cannot be\n" +"mutable." +msgstr "" +"Die Verwendung eines referenzgezählten Zeigers bietet das Beste aus beiden Welten - wir können es wiederverwenden\n" +"die ursprüngliche Datenstruktur, und wir müssen keine unveränderten Knoten klonen. Jedoch,\n" +"sie sind weniger ergonomisch zu verwenden und bedeuten, dass die Datenstrukturen nicht sein können\n" +"veränderlich." + +#: src\patterns/creational/fold.md:111 +#, fuzzy +msgid "" +"Iterators have a `fold` method, however this folds a data structure into a\n" +"value, rather than into a new data structure. An iterator's `map` is more like\n" +"this fold pattern." +msgstr "" +"Iteratoren haben eine \"Fold\"-Methode, jedoch faltet diese eine Datenstruktur in eine\n" +"Wert, anstatt in eine neue Datenstruktur. Die `Karte` eines Iterators ist eher so\n" +"dieses Faltmuster." + +#: src\patterns/creational/fold.md:115 +#, fuzzy +msgid "" +"In other languages, fold is usually used in the sense of Rust's iterators,\n" +"rather than this pattern. Some functional languages have powerful constructs for\n" +"performing flexible maps over data structures." +msgstr "" +"In anderen Sprachen wird fold normalerweise im Sinne von Rusts Iteratoren verwendet,\n" +"eher als dieses Muster. Einige funktionale Sprachen haben mächtige Konstrukte für\n" +"Durchführen flexibler Abbildungen über Datenstrukturen." + +#: src\patterns/creational/fold.md:119 +#, fuzzy +msgid "" +"The [visitor](../behavioural/visitor.md) pattern is closely related to fold.\n" +"They share the concept of walking a data structure performing an operation on\n" +"each node. However, the visitor does not create a new data structure nor consume\n" +"the old one." +msgstr "" +"Das Muster [Besucher](../behavioural/visitor.md) ist eng verwandt mit fold.\n" +"Sie teilen das Konzept, eine Datenstruktur zu durchlaufen, an der eine Operation durchgeführt wird\n" +"jeder Knoten. Der Besucher erstellt jedoch keine neue Datenstruktur und verbraucht sie nicht\n" +"das Alte." + +#: src\patterns/structural/intro.md:1 +msgid "# Structural Patterns" +msgstr "# Strukturelle Muster" + +#: src\patterns/structural/intro.md:3 +msgid "From [Wikipedia](https://en.wikipedia.org/wiki/Structural_pattern):" +msgstr "Aus [Wikipedia] (https://en.wikipedia.org/wiki/Structural_pattern):" + +#: src\patterns/structural/intro.md:5 +msgid "" +"> Design patterns that ease the design by identifying a simple way to realize relationships\n" +"> among entities." +msgstr "" +"> Entwurfsmuster, die das Design vereinfachen, indem sie einen einfachen Weg zur Realisierung von Beziehungen\n" +"> zwischen Entitäten identifizieren." + +#: src\patterns/structural/compose-structs.md:1 +#, fuzzy +msgid "# Compose structs together for better borrowing" +msgstr "# Zusammenstellen von Strukturen zum besseren Ausleihen" + +#: src\patterns/structural/compose-structs.md:3 +msgid "TODO - this is not a very snappy name" +msgstr "" + +#: src\patterns/structural/compose-structs.md:7 +#, fuzzy +msgid "" +"Sometimes a large struct will cause issues with the borrow checker - although\n" +"fields can be borrowed independently, sometimes the whole struct ends up being\n" +"used at once, preventing other uses. A solution might be to decompose the struct\n" +"into several smaller structs. Then compose these together into the original\n" +"struct. Then each struct can be borrowed separately and have more flexible\n" +"behaviour." +msgstr "" +"Manchmal verursacht eine große Struktur Probleme mit dem Borrow-Checker - obwohl\n" +"Felder können unabhängig voneinander ausgeliehen werden, manchmal endet die gesamte Struktur\n" +"sofort verwendet werden, wodurch andere Verwendungen verhindert werden. Eine Lösung könnte darin bestehen, die Struktur zu zerlegen\n" +"in mehrere kleinere Strukturen. Setzen Sie diese dann zum Original zusammen\n" +"Struktur. Dann kann jede Struktur separat ausgeliehen werden und ist flexibler\n" +"Verhalten." + +#: src\patterns/structural/compose-structs.md:14 +#, fuzzy +msgid "" +"This will often lead to a better design in other ways: applying this design\n" +"pattern often reveals smaller units of functionality." +msgstr "" +"Dies führt oft auf andere Weise zu einem besseren Design: Anwendung dieses Designs\n" +"Muster zeigen oft kleinere Funktionseinheiten." + +#: src\patterns/structural/compose-structs.md:19 +#, fuzzy +msgid "" +"Here is a contrived example of where the borrow checker foils us in our plan to\n" +"use a struct:" +msgstr "" +"Hier ist ein erfundenes Beispiel dafür, wohin uns der Borrow-Checker in unserem Plan vereitelt\n" +"Verwenden Sie eine Struktur:" + +#: src\patterns/structural/compose-structs.md:22 +msgid "" +"```rust\n" +"struct A {\n" +" f1: u32,\n" +" f2: u32,\n" +" f3: u32,\n" +"}\n" +"\n" +"fn foo(a: &mut A) -> &u32 { &a.f2 }\n" +"fn bar(a: &mut A) -> u32 { a.f1 + a.f3 }\n" +"\n" +"fn baz(a: &mut A) {\n" +" // The later usage of x causes a to be borrowed for the rest of the function.\n" +" let x = foo(a);\n" +" // Borrow checker error:\n" +" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than once\n" +" // at a time\n" +" println!(\"{}\", x);\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/structural/compose-structs.md:42 +msgid "" +"We can apply this design pattern and refactor `A` into two smaller structs, thus\n" +"solving the borrow checking issue:" +msgstr "" +"Wir können dieses Entwurfsmuster anwenden und `A` in zwei kleinere Strukturen umarbeiten, um so das\n" +"Problem des Borrow-Checkers zu lösen:" + +#: src\patterns/structural/compose-structs.md:45 +msgid "" +"```rust\n" +"// A is now composed of two structs - B and C.\n" +"struct A {\n" +" b: B,\n" +" c: C,\n" +"}\n" +"struct B {\n" +" f2: u32,\n" +"}\n" +"struct C {\n" +" f1: u32,\n" +" f3: u32,\n" +"}\n" +"\n" +"// These functions take a B or C, rather than A.\n" +"fn foo(b: &mut B) -> &u32 { &b.f2 }\n" +"fn bar(c: &mut C) -> u32 { c.f1 + c.f3 }\n" +"\n" +"fn baz(a: &mut A) {\n" +" let x = foo(&mut a.b);\n" +" // Now it's OK!\n" +" let y = bar(&mut a.c);\n" +" println!(\"{}\", x);\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/structural/compose-structs.md:73 +msgid "TODO Why and where you should use the pattern" +msgstr "" + +#: src\patterns/structural/compose-structs.md:77 +msgid "Lets you work around limitations in the borrow checker." +msgstr "Ermöglicht das Umgehen von Einschränkungen durch den Borrow-Checker." + +#: src\patterns/structural/compose-structs.md:79 +msgid "Often produces a better design." +msgstr "Erzeugt oft ein besseres Design." + +#: src\patterns/structural/compose-structs.md:83 +msgid "Leads to more verbose code." +msgstr "Führt zu ausführlicherem Code." + +#: src\patterns/structural/compose-structs.md:85 +#, fuzzy +msgid "" +"Sometimes, the smaller structs are not good abstractions, and so we end up with\n" +"a worse design. That is probably a 'code smell', indicating that the program\n" +"should be refactored in some way." +msgstr "" +"Manchmal sind die kleineren Strukturen keine guten Abstraktionen, und so landen wir bei\n" +"ein schlechteres Design. Das ist wahrscheinlich ein 'Code Smell', der darauf hinweist, dass das Programm\n" +"sollte irgendwie umgestaltet werden." + +#: src\patterns/structural/compose-structs.md:91 +#, fuzzy +msgid "" +"This pattern is not required in languages that don't have a borrow checker, so\n" +"in that sense is unique to Rust. However, making smaller units of functionality\n" +"often leads to cleaner code: a widely acknowledged principle of software\n" +"engineering, independent of the language." +msgstr "" +"Dieses Muster ist in Sprachen, die keinen Borrow-Checker haben, also nicht erforderlich\n" +"in diesem Sinne ist Rust einzigartig. Es werden jedoch kleinere Funktionseinheiten erstellt\n" +"führt oft zu saubererem Code: ein weithin anerkanntes Prinzip von Software\n" +"Engineering, sprachunabhängig." + +#: src\patterns/structural/compose-structs.md:96 +#, fuzzy +msgid "" +"This pattern relies on Rust's borrow checker to be able to borrow fields\n" +"independently of each other. In the example, the borrow checker knows that `a.b`\n" +"and `a.c` are distinct and can be borrowed independently, it does not try to\n" +"borrow all of `a`, which would make this pattern useless." +msgstr "" +"Dieses Muster stützt sich auf den Borrow-Checker von Rust, um Felder ausleihen zu können\n" +"unabhängig voneinander. Im Beispiel weiß der Borrow-Checker, dass `a.b`\n" +"und `a.c` sind verschieden und können unabhängig voneinander ausgeliehen werden, es wird nicht versucht\n" +"leihen Sie das gesamte `a`, was dieses Muster unbrauchbar machen würde." + +#: src\patterns/structural/small-crates.md:1 +msgid "# Prefer small crates" +msgstr "# Bevorzugen Sie kleine Pakete" + +#: src\patterns/structural/small-crates.md:5 +msgid "Prefer small crates that do one thing well." +msgstr "Bevorzugen Sie kleine Pakete, die eine Sache und diese gut machen." + +#: src\patterns/structural/small-crates.md:7 +#, fuzzy +msgid "" +"Cargo and crates.io make it easy to add third-party libraries, much more so than\n" +"in say C or C++. Moreover, since packages on crates.io cannot be edited or removed\n" +"after publication, any build that works now should continue to work in the future.\n" +"We should take advantage of this tooling, and use smaller, more fine-grained dependencies." +msgstr "" +"Cargo und Crates.io machen es einfach, Bibliotheken von Drittanbietern hinzuzufügen, viel mehr als\n" +"in sagen wir C oder C++. Darüber hinaus können Pakete auf Crates.io nicht bearbeitet oder entfernt werden\n" +"Nach der Veröffentlichung sollte jeder Build, der jetzt funktioniert, auch in Zukunft funktionieren.\n" +"Wir sollten diese Tools nutzen und kleinere, feinkörnigere Abhängigkeiten verwenden." + +#: src\patterns/structural/small-crates.md:14 +#, fuzzy +msgid "" +"- Small crates are easier to understand, and encourage more modular code.\n" +"- Crates allow for re-using code between projects.\n" +" For example, the `url` crate was developed as part of the Servo browser engine,\n" +" but has since found wide use outside the project.\n" +"- Since the compilation unit\n" +" of Rust is the crate, splitting a project into multiple crates can allow more of\n" +" the code to be built in parallel." +msgstr "" +"- Kleine Crates sind einfacher zu verstehen und fördern mehr modularen Code.\n" +"- Crates ermöglichen die Wiederverwendung von Code zwischen Projekten.\n" +" Beispielsweise wurde die `url`-Kiste als Teil der Servo-Browser-Engine entwickelt,\n" +" hat aber seitdem breite Verwendung außerhalb des Projekts gefunden.\n" +"- Da die Kompilationseinheit\n" +" von Rust ist die Crate, das Aufteilen eines Projekts in mehrere Crates kann mehr davon ermöglichen\n" +" der parallel zu bauende Code." + +#: src\patterns/structural/small-crates.md:24 +#, fuzzy +msgid "" +"- This can lead to \"dependency hell\", when a project depends on multiple conflicting\n" +" versions of a crate at the same time. For example, the `url` crate has both versions\n" +" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` are\n" +" different types, an HTTP client that uses `url:0.5` would not accept `Url` values\n" +" from a web scraper that uses `url:1.0`.\n" +"- Packages on crates.io are not curated. A crate may be poorly written, have\n" +" unhelpful documentation, or be outright malicious.\n" +"- Two small crates may be less optimized than one large one, since the compiler\n" +" does not perform link-time optimization (LTO) by default." +msgstr "" +"- Dies kann zur \"Abhängigkeitshölle\" führen, wenn ein Projekt von mehreren Konflikten abhängt\n" +" Versionen einer Kiste gleichzeitig. Zum Beispiel enthält die Kiste „url“ beide Versionen\n" +" 1,0 und 0,5. Da die `Url` aus `url:1.0` und die `Url` aus `url:0.5` sind\n" +" verschiedenen Typen, würde ein HTTP-Client, der \"url:0.5\" verwendet, keine \"Url\"-Werte akzeptieren\n" +" von einem Web Scraper, der `url:1.0` verwendet.\n" +"- Pakete auf Crates.io werden nicht kuratiert. Eine Kiste kann schlecht geschrieben sein, haben\n" +" nicht hilfreiche Dokumentation oder geradezu böswillig sein.\n" +"- Zwei kleine Crates sind möglicherweise weniger optimiert als eine große, da der Compiler\n" +" führt standardmäßig keine Link-Time-Optimierung (LTO) durch." + +#: src\patterns/structural/small-crates.md:36 +msgid "" +"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" +"for converting `&T` to `&[T]`." +msgstr "" +"Das [`ref_slice`](https://crates.io/crates/ref_slice) Paket stellt Funktionen\n" +"zum Konvertieren von `&T` in `&[T]` bereit." + +#: src\patterns/structural/small-crates.md:39 +msgid "" +"The [`url`](https://crates.io/crates/url) crate provides tools for working with\n" +"URLs." +msgstr "" +"Das [`url`](https://crates.io/crates/url) Paket stellt Werkzeuge zum Arbeiten mit\n" +"URLs bereit." + +#: src\patterns/structural/small-crates.md:42 +msgid "" +"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a function to\n" +"query the number of CPUs on a machine." +msgstr "" +"Das [`num_cpus`](https://crates.io/crates/num_cpus) Paket stellt eine Funktion zur Verfügung,\n" +"die die Anzahl der CPUs auf einer Maschine abfragen und zurückgeben kann." + +#: src\patterns/structural/small-crates.md:47 +msgid "- [crates.io: The Rust community crate host](https://crates.io/)" +msgstr "- [crates.io: Der Crate-Host der Rust-Community](https://crates.io/)" + +#: src\patterns/structural/unsafe-mods.md:1 +msgid "# Contain unsafety in small modules" +msgstr "# Unsicherheit in kleinen Modulen isolieren" + +#: src\patterns/structural/unsafe-mods.md:5 +#, fuzzy +msgid "" +"If you have `unsafe` code, create the smallest possible module that can uphold\n" +"the needed invariants to build a minimal safe interface upon the unsafety. Embed\n" +"this into a larger module that contains only safe code and presents an ergonomic\n" +"interface. Note that the outer module can contain unsafe functions and methods\n" +"that call directly into the unsafe code. Users may use this to gain speed benefits." +msgstr "" +"Wenn Sie „unsicheren“ Code haben, erstellen Sie das kleinstmögliche Modul, das aufrechterhalten werden kann\n" +"die benötigten Invarianten, um eine minimal sichere Schnittstelle auf der Unsicherheit aufzubauen. Einbetten\n" +"dieses in ein größeres Modul, das nur sicheren Code enthält und ein ergonomisches darstellt\n" +"Schnittstelle. Beachten Sie, dass das äußere Modul unsichere Funktionen und Methoden enthalten kann\n" +"die direkt in den unsicheren Code aufrufen. Benutzer können dies verwenden, um Geschwindigkeitsvorteile zu erzielen." + +#: src\patterns/structural/unsafe-mods.md:13 +#, fuzzy +msgid "" +"- This restricts the unsafe code that must be audited\n" +"- Writing the outer module is much easier, since you can count on the guarantees\n" +" of the inner module" +msgstr "" +"- Dies schränkt den unsicheren Code ein, der überwacht werden muss\n" +"- Das Schreiben des äußeren Moduls ist viel einfacher, da Sie sich auf die Garantien verlassen können\n" +" des Innenmoduls" + +#: src\patterns/structural/unsafe-mods.md:19 +#, fuzzy +msgid "" +"- Sometimes, it may be hard to find a suitable interface.\n" +"- The abstraction may introduce inefficiencies." +msgstr "" +"- Manchmal kann es schwierig sein, eine geeignete Schnittstelle zu finden.\n" +"- Die Abstraktion kann zu Ineffizienzen führen." + +#: src\patterns/structural/unsafe-mods.md:24 +#, fuzzy +msgid "" +"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe operations\n" +" in submodules, presenting a safe interface to users.\n" +"- `std`'s `String` class is a wrapper over `Vec` with the added invariant\n" +" that the contents must be valid UTF-8. The operations on `String` ensure this\n" +" behavior.\n" +" However, users have the option of using an `unsafe` method to create a `String`,\n" +" in which case the onus is on them to guarantee the validity of the contents." +msgstr "" +"- Die Kiste [`toolshed`](https://docs.rs/toolshed) enthält seine unsicheren Operationen\n" +" in Untermodulen, die den Benutzern eine sichere Schnittstelle bieten.\n" +"- Die `String`-Klasse von `std` ist ein Wrapper über `Vec` mit der hinzugefügten Invariante\n" +" dass der Inhalt gültiges UTF-8 sein muss. Dafür sorgen die Operationen auf `String`\n" +" Verhalten.\n" +" Benutzer haben jedoch die Möglichkeit, eine \"unsichere\" Methode zu verwenden, um einen \"String\" zu erstellen,\n" +" in diesem Fall obliegt es ihnen, die Richtigkeit der Inhalte zu gewährleisten." + +#: src\patterns/structural/unsafe-mods.md:34 +#, fuzzy +msgid "- [Ralf Jung's Blog about invariants in unsafe code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgstr "- [Ralf Jungs Blog über Invarianten in unsicherem Code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" + +#: src\patterns/ffi/intro.md:1 +msgid "# FFI Patterns" +msgstr "# FFI-Muster" + +#: src\patterns/ffi/intro.md:3 +#, fuzzy +msgid "" +"Writing FFI code is an entire course in itself.\n" +"However, there are several idioms here that can act as pointers, and avoid traps\n" +"for inexperienced users of unsafe Rust." +msgstr "" +"Das Schreiben von FFI-Code ist ein ganzer Kurs für sich.\n" +"Es gibt hier jedoch mehrere Redewendungen, die als Hinweise dienen und Fallen vermeiden können\n" +"für unerfahrene Benutzer von unsicherem Rust." + +#: src\patterns/ffi/intro.md:7 +msgid "This section contains design patterns that may be useful when doing FFI." +msgstr "Dieser Abschnitt enthält Entwurfsmuster, die bei der Nutzung von FFI nützlich sein können." + +#: src\patterns/ffi/intro.md:9 +#, fuzzy +msgid "" +"1. [Object-Based API](./export.md) design that has good memory safety characteristics,\n" +" and a clean boundary of what is safe and what is unsafe\n" +"\n" +"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust types\n" +" together into an opaque \"object\"" +msgstr "" +"1. [Objektbasiertes API](./export.md)-Design mit guten Speichersicherheitseigenschaften,\n" +" und eine saubere Grenze dessen, was sicher und was unsicher ist\n" +"\n" +"2. [Type Consolidation into Wrappers](./wrappers.md) – gruppiert mehrere Rust-Typen\n" +" zusammen zu einem undurchsichtigen \"Objekt\"" + +#: src\patterns/ffi/export.md:1 +msgid "# Object-Based APIs" +msgstr "# Objektbasierte APIs" + +#: src\patterns/ffi/export.md:5 +#, fuzzy +msgid "" +"When designing APIs in Rust which are exposed to other languages, there are some\n" +"important design principles which are contrary to normal Rust API design:" +msgstr "" +"Beim Entwerfen von APIs in Rust, die anderen Sprachen ausgesetzt sind, gibt es einige\n" +"Wichtige Designprinzipien, die im Gegensatz zum normalen Rust-API-Design stehen:" + +#: src\patterns/ffi/export.md:8 +#, fuzzy +msgid "" +"1. All Encapsulated types should be _owned_ by Rust, _managed_ by the user,\n" +" and _opaque_.\n" +"2. All Transactional data types should be _owned_ by the user, and _transparent_.\n" +"3. All library behavior should be functions acting upon Encapsulated types.\n" +"4. All library behavior should be encapsulated into types not based on structure,\n" +" but _provenance/lifetime_." +msgstr "" +"1. Alle gekapselten Typen sollten _im Besitz_ von Rust sein, _verwaltet_ vom Benutzer,\n" +" und _undurchsichtig_.\n" +"2. Alle Transaktionsdatentypen sollten dem Benutzer _gehören_ und _transparent_ sein.\n" +"3. Das gesamte Bibliotheksverhalten sollte Funktionen sein, die auf gekapselte Typen wirken.\n" +"4. Das gesamte Bibliotheksverhalten sollte in Typen gekapselt werden, die nicht auf der Struktur basieren.\n" +" aber _provenance/lifetime_." + +#: src\patterns/ffi/export.md:17 +#, fuzzy +msgid "" +"Rust has built-in FFI support to other languages.\n" +"It does this by providing a way for crate authors to provide C-compatible APIs\n" +"through different ABIs (though that is unimportant to this practice)." +msgstr "" +"Rust hat eine eingebaute FFI-Unterstützung für andere Sprachen.\n" +"Es tut dies, indem es Crate-Autoren eine Möglichkeit bietet, C-kompatible APIs bereitzustellen\n" +"durch verschiedene ABIs (obwohl das für diese Praxis unwichtig ist)." + +#: src\patterns/ffi/export.md:21 +#, fuzzy +msgid "" +"Well-designed Rust FFI follows C API design principles, while compromising the\n" +"design in Rust as little as possible. There are three goals with any foreign API:" +msgstr "" +"Ein gut gestaltetes Rust-FFI folgt den C-API-Designprinzipien, während es die\n" +"Design in Rost so wenig wie möglich. Es gibt drei Ziele mit jeder fremden API:" + +#: src\patterns/ffi/export.md:24 +#, fuzzy +msgid "" +"1. Make it easy to use in the target language.\n" +"2. Avoid the API dictating internal unsafety on the Rust side as much as possible.\n" +"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as small\n" +" as possible." +msgstr "" +"1. Machen Sie es einfach, es in der Zielsprache zu verwenden.\n" +"2. Vermeiden Sie so weit wie möglich, dass die API interne Unsicherheiten auf der Rust-Seite diktiert.\n" +"3. Halten Sie das Potenzial für Speicherunsicherheit und „undefiniertes Verhalten“ von Rust so gering wie möglich\n" +" wie möglich." + +#: src\patterns/ffi/export.md:29 +#, fuzzy +msgid "" +"Rust code must trust the memory safety of the foreign language beyond a certain\n" +"point. However, every bit of `unsafe` code on the Rust side is an opportunity for\n" +"bugs, or to exacerbate `undefined behaviour`." +msgstr "" +"Rust-Code muss der Speichersicherheit der Fremdsprache über ein gewisses Maß hinaus vertrauen\n" +"Punkt. Allerdings ist jedes Bit an „unsicherem“ Code auf der Rust-Seite eine Gelegenheit für\n" +"Bugs oder um \"undefiniertes Verhalten\" zu verschlimmern." + +#: src\patterns/ffi/export.md:33 +#, fuzzy +msgid "" +"For example, if a pointer provenance is wrong, that may be a segfault due to\n" +"invalid memory access. But if it is manipulated by unsafe code, it could become\n" +"full-blown heap corruption." +msgstr "" +"Wenn zum Beispiel eine Zeigerherkunft falsch ist, kann das ein Segfault sein\n" +"ungültiger Speicherzugriff. Aber wenn es durch unsicheren Code manipuliert wird, könnte es werden\n" +"ausgewachsene Heap-Korruption." + +#: src\patterns/ffi/export.md:37 +#, fuzzy +msgid "" +"The Object-Based API design allows for writing shims that have good memory safety\n" +"characteristics, and a clean boundary of what is safe and what is `unsafe`." +msgstr "" +"Das objektbasierte API-Design ermöglicht das Schreiben von Shims mit guter Speichersicherheit\n" +"Eigenschaften und eine saubere Grenze dessen, was sicher und was \"unsicher\" ist." + +#: src\patterns/ffi/export.md:42 +#, fuzzy +msgid "" +"The POSIX standard defines the API to access an on-file database, known as [DBM](https://web.archive.org/web/20210105035602/https://www." +"mankier.com/0p/ndbm.h).\n" +"It is an excellent example of an \"object-based\" API." +msgstr "" +"Der POSIX-Standard definiert die API für den Zugriff auf eine archivierte Datenbank, bekannt als [DBM](https://web.archive.org/" +"web/20210105035602/https://www.mankier.com/0p/ndbm.h) .\n" +"Es ist ein hervorragendes Beispiel für eine \"objektbasierte\" API." + +#: src\patterns/ffi/export.md:45 +#, fuzzy +msgid "" +"Here is the definition in C, which hopefully should be easy to read for those\n" +"involved in FFI. The commentary below should help explain it for those who\n" +"miss the subtleties." +msgstr "" +"Hier ist die Definition in C, die hoffentlich für diejenigen leicht lesbar sein sollte\n" +"am FFI beteiligt. Der folgende Kommentar sollte helfen, es für diejenigen zu erklären, die es tun\n" +"vermisse die Feinheiten." + +#: src\patterns/ffi/export.md:49 +msgid "" +"```C\n" +"struct DBM;\n" +"typedef struct { void *dptr, size_t dsize } datum;\n" +"\n" +"int dbm_clearerr(DBM *);\n" +"void dbm_close(DBM *);\n" +"int dbm_delete(DBM *, datum);\n" +"int dbm_error(DBM *);\n" +"datum dbm_fetch(DBM *, datum);\n" +"datum dbm_firstkey(DBM *);\n" +"datum dbm_nextkey(DBM *);\n" +"DBM *dbm_open(const char *, int, mode_t);\n" +"int dbm_store(DBM *, datum, datum, int);\n" +"```" +msgstr "" + +#: src\patterns/ffi/export.md:64 +#, fuzzy +msgid "This API defines two types: `DBM` and `datum`." +msgstr "Diese API definiert zwei Typen: „DBM“ und „datum“." + +#: src\patterns/ffi/export.md:66 +#, fuzzy +msgid "" +"The `DBM` type was called an \"encapsulated\" type above.\n" +"It is designed to contain internal state, and acts as an entry point for the\n" +"library's behavior." +msgstr "" +"Der `DBM`-Typ wurde oben als \"eingekapselter\" Typ bezeichnet.\n" +"Es ist so konzipiert, dass es den internen Status enthält, und fungiert als Einstiegspunkt für die\n" +"Verhalten der Bibliothek." + +#: src\patterns/ffi/export.md:70 +#, fuzzy +msgid "" +"It is completely opaque to the user, who cannot create a `DBM` themselves since\n" +"they don't know its size or layout. Instead, they must call `dbm_open`, and that\n" +"only gives them _a pointer to one_." +msgstr "" +"Es ist völlig undurchsichtig für den Benutzer, der seitdem kein `DBM` selbst erstellen kann\n" +"Sie kennen weder Größe noch Layout. Stattdessen müssen sie `dbm_open` aufrufen, und das\n" +"gibt ihnen nur _einen Zeiger auf eins_." + +#: src\patterns/ffi/export.md:74 +#, fuzzy +msgid "" +"This means all `DBM`s are \"owned\" by the library in a Rust sense.\n" +"The internal state of unknown size is kept in memory controlled by the library,\n" +"not the user. The user can only manage its life cycle with `open` and `close`,\n" +"and perform operations on it with the other functions." +msgstr "" +"Das bedeutet, dass alle `DBM`s im Sinne von Rust der Bibliothek \"gehören\".\n" +"Der interne Zustand unbekannter Größe wird im Speicher gehalten, der von der Bibliothek gesteuert wird.\n" +"nicht der Benutzer. Der Benutzer kann seinen Lebenszyklus nur mit \"Öffnen\" und \"Schließen\" verwalten,\n" +"und mit den anderen Funktionen Operationen darauf ausführen." + +#: src\patterns/ffi/export.md:79 +#, fuzzy +msgid "" +"The `datum` type was called a \"transactional\" type above.\n" +"It is designed to facilitate the exchange of information between the library and\n" +"its user." +msgstr "" +"Der 'Datum'-Typ wurde oben als \"Transaktions\"-Typ bezeichnet.\n" +"Es soll den Informationsaustausch zwischen der Bibliothek und erleichtern\n" +"sein Benutzer." + +#: src\patterns/ffi/export.md:83 +#, fuzzy +msgid "" +"The database is designed to store \"unstructured data\", with no pre-defined length\n" +"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a bunch\n" +"of bytes, and a count of how many there are. The main difference is that there is\n" +"no type information, which is what `void` indicates." +msgstr "" +"Die Datenbank ist darauf ausgelegt, „unstrukturierte Daten“ ohne vordefinierte Länge zu speichern\n" +"oder Bedeutung. Als Ergebnis ist das „Datum“ das C-Äquivalent eines Rust-Slice: ein Bündel\n" +"von Bytes und eine Zählung, wie viele es sind. Der Hauptunterschied ist, dass es gibt\n" +"keine Typinformationen, was \"void\" anzeigt." + +#: src\patterns/ffi/export.md:88 +#, fuzzy +msgid "" +"Keep in mind that this header is written from the library's point of view.\n" +"The user likely has some type they are using, which has a known size.\n" +"But the library does not care, and by the rules of C casting, any type behind a\n" +"pointer can be cast to `void`." +msgstr "" +"Beachten Sie, dass dieser Header aus Sicht der Bibliothek geschrieben ist.\n" +"Der Benutzer hat wahrscheinlich einen Typ, den er verwendet, der eine bekannte Größe hat.\n" +"Aber die Bibliothek kümmert sich nicht darum, und nach den Regeln des C-Castings ist jeder Typ hinter a\n" +"Zeiger kann auf `void` gecastet werden." + +#: src\patterns/ffi/export.md:93 +#, fuzzy +msgid "" +"As noted earlier, this type is _transparent_ to the user. But also, this type is\n" +"_owned_ by the user.\n" +"This has subtle ramifications, due to that pointer inside it.\n" +"The question is, who owns the memory that pointer points to?" +msgstr "" +"Wie bereits erwähnt, ist dieser Typ für den Benutzer _transparent_. Aber auch diese Art ist\n" +"_im Besitz_ des Benutzers.\n" +"Dies hat aufgrund des darin enthaltenen Zeigers subtile Auswirkungen.\n" +"Die Frage ist, wem gehört der Speicher, auf den der Zeiger zeigt?" + +#: src\patterns/ffi/export.md:98 +#, fuzzy +msgid "" +"The answer for best memory safety is, \"the user\".\n" +"But in cases such as retrieving a value, the user does not know how to allocate\n" +"it correctly (since they don't know how long the value is). In this case, the library\n" +"code is expected to use the heap that the user has access to -- such as the C library\n" +"`malloc` and `free` -- and then _transfer ownership_ in the Rust sense." +msgstr "" +"Die Antwort für die beste Speichersicherheit ist \"der Benutzer\".\n" +"Aber in Fällen wie dem Abrufen eines Werts weiß der Benutzer nicht, wie er zuordnen soll\n" +"es richtig (da sie nicht wissen, wie lang der Wert ist). In diesem Fall die Bibliothek\n" +"Code soll den Heap verwenden, auf den der Benutzer Zugriff hat – wie etwa die C-Bibliothek\n" +"`malloc` und `free` -- und dann _Eigentum übertragen_ im Sinne von Rust." + +#: src\patterns/ffi/export.md:104 +#, fuzzy +msgid "" +"This may all seem speculative, but this is what a pointer means in C.\n" +"It means the same thing as Rust: \"user defined lifetime.\"\n" +"The user of the library needs to read the documentation in order to use it correctly.\n" +"That said, there are some decisions that have fewer or greater consequences if users\n" +"do it wrong. Minimizing those are what this best practice is about, and the key\n" +"is to _transfer ownership of everything that is transparent_." +msgstr "" +"Das mag alles spekulativ erscheinen, aber genau das bedeutet ein Zeiger in C.\n" +"Es bedeutet dasselbe wie Rust: \"benutzerdefinierte Lebensdauer\".\n" +"Der Benutzer der Bibliothek muss die Dokumentation lesen, um sie richtig zu verwenden.\n" +"Allerdings gibt es einige Entscheidungen, die weniger oder größere Konsequenzen für die Benutzer haben\n" +"mach es falsch. Diese zu minimieren, ist das, worum es bei dieser Best Practice geht, und der Schlüssel\n" +"ist es, _das Eigentum an allem zu übertragen, was transparent ist_." + +#: src\patterns/ffi/export.md:113 +#, fuzzy +msgid "" +"This minimizes the number of memory safety guarantees the user must uphold to a\n" +"relatively small number:" +msgstr "" +"Dies minimiert die Anzahl der Speichersicherheitsgarantien, die der Benutzer einhalten muss\n" +"relativ kleine Zahl:" + +#: src\patterns/ffi/export.md:116 +#, fuzzy +msgid "" +"1. Do not call any function with a pointer not returned by `dbm_open` (invalid\n" +" access or corruption).\n" +"2. Do not call any function on a pointer after close (use after free).\n" +"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of memory\n" +" at the advertised length." +msgstr "" +"1. Rufen Sie keine Funktion mit einem Zeiger auf, der nicht von `dbm_open` zurückgegeben wird (ungültig\n" +" Zugriff oder Korruption).\n" +"2. Rufen Sie nach dem Schließen keine Funktion für einen Zeiger auf (use after free).\n" +"3. Der „dptr“ auf jedem „Datum“ muss „NULL“ sein oder auf einen gültigen Speicherbereich zeigen\n" +" in der angegebenen Länge." + +#: src\patterns/ffi/export.md:122 +#, fuzzy +msgid "" +"In addition, it avoids a lot of pointer provenance issues.\n" +"To understand why, let us consider an alternative in some depth: key iteration." +msgstr "" +"Darüber hinaus vermeidet es viele Probleme mit der Herkunft von Zeigern.\n" +"Um zu verstehen, warum, betrachten wir eine Alternative eingehend: die Schlüsseliteration." + +#: src\patterns/ffi/export.md:125 +#, fuzzy +msgid "" +"Rust is well known for its iterators.\n" +"When implementing one, the programmer makes a separate type with a bounded lifetime\n" +"to its owner, and implements the `Iterator` trait." +msgstr "" +"Rust ist bekannt für seine Iteratoren.\n" +"Bei der Implementierung erstellt der Programmierer einen separaten Typ mit begrenzter Lebensdauer\n" +"an seinen Besitzer und implementiert das `Iterator`-Merkmal." + +#: src\patterns/ffi/export.md:129 +#, fuzzy +msgid "Here is how iteration would be done in Rust for `DBM`:" +msgstr "So würde die Iteration in Rust für `DBM` durchgeführt:" + +#: src\patterns/ffi/export.md:131 +msgid "" +"```rust,ignore\n" +"struct Dbm { ... }\n" +"\n" +"impl Dbm {\n" +" /* ... */\n" +" pub fn keys<'it>(&'it self) -> DbmKeysIter<'it> { ... }\n" +" /* ... */\n" +"}\n" +"\n" +"struct DbmKeysIter<'it> {\n" +" owner: &'it Dbm,\n" +"}\n" +"\n" +"impl<'it> Iterator for DbmKeysIter<'it> { ... }\n" +"```" +msgstr "" + +#: src\patterns/ffi/export.md:147 +#, fuzzy +msgid "" +"This is clean, idiomatic, and safe. thanks to Rust's guarantees.\n" +"However, consider what a straightforward API translation would look like:" +msgstr "" +"Das ist sauber, idiomatisch und sicher. dank Rusts Garantien.\n" +"Überlegen Sie jedoch, wie eine einfache API-Übersetzung aussehen würde:" + +#: src\patterns/ffi/export.md:150 +msgid "" +"```rust,ignore\n" +"#[no_mangle]\n" +"pub extern \"C\" fn dbm_iter_new(owner: *const Dbm) -> *mut DbmKeysIter {\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" +"}\n" +"#[no_mangle]\n" +"pub extern \"C\" fn dbm_iter_next(\n" +" iter: *mut DbmKeysIter,\n" +" key_out: *const datum\n" +") -> libc::c_int {\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" +"}\n" +"#[no_mangle]\n" +"pub extern \"C\" fn dbm_iter_del(*mut DbmKeysIter) {\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/ffi/export.md:168 +#, fuzzy +msgid "" +"This API loses a key piece of information: the lifetime of the iterator must not\n" +"exceed the lifetime of the `Dbm` object that owns it. A user of the library could\n" +"use it in a way which causes the iterator to outlive the data it is iterating on,\n" +"resulting in reading uninitialized memory." +msgstr "" +"Diese API verliert eine Schlüsselinformation: Die Lebensdauer des Iterators darf nicht\n" +"die Lebensdauer des `Dbm`-Objekts überschreiten, dem es gehört. Ein Benutzer der Bibliothek könnte\n" +"Verwenden Sie es auf eine Weise, die dazu führt, dass der Iterator die Daten überlebt, auf denen er iteriert,\n" +"was zum Lesen des nicht initialisierten Speichers führt." + +#: src\patterns/ffi/export.md:173 +#, fuzzy +msgid "This example written in C contains a bug that will be explained afterwards:" +msgstr "Dieses in C geschriebene Beispiel enthält einen Fehler, der später erklärt wird:" + +#: src\patterns/ffi/export.md:175 +msgid "" +"```C\n" +"int count_key_sizes(DBM *db) {\n" +" // DO NOT USE THIS FUNCTION. IT HAS A SUBTLE BUT SERIOUS BUG!\n" +" datum key;\n" +" int len = 0;\n" +"\n" +" if (!dbm_iter_new(db)) {\n" +" dbm_close(db);\n" +" return -1;\n" +" }\n" +"\n" +" int l;\n" +" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated by -1\n" +" free(key.dptr);\n" +" len += key.dsize;\n" +" if (l == 0) { // end of the iterator\n" +" dbm_close(owner);\n" +" }\n" +" }\n" +" if l >= 0 {\n" +" return -1;\n" +" } else {\n" +" return len;\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/ffi/export.md:202 +#, fuzzy +msgid "" +"This bug is a classic. Here's what happens when the iterator returns the\n" +"end-of-iteration marker:" +msgstr "" +"Dieser Fehler ist ein Klassiker. Folgendes passiert, wenn der Iterator die zurückgibt\n" +"Markierung für das Ende der Iteration:" + +#: src\patterns/ffi/export.md:205 +#, fuzzy +msgid "" +"1. The loop condition sets `l` to zero, and enters the loop because `0 >= 0`.\n" +"2. The length is incremented, in this case by zero.\n" +"3. The if statement is true, so the database is closed. There should be a break\n" +" statement here.\n" +"4. The loop condition executes again, causing a `next` call on the closed object." +msgstr "" +"1. Die Schleifenbedingung setzt \"l\" auf Null und tritt in die Schleife ein, weil \"0 >= 0\".\n" +"2. Die Länge wird erhöht, in diesem Fall um Null.\n" +"3. Die if-Anweisung ist wahr, also wird die Datenbank geschlossen. Es sollte eine Pause geben\n" +" Aussage hier.\n" +"4. Die Schleifenbedingung wird erneut ausgeführt, was einen „next“-Aufruf für das geschlossene Objekt bewirkt." + +#: src\patterns/ffi/export.md:211 +#, fuzzy +msgid "" +"The worst part about this bug?\n" +"If the Rust implementation was careful, this code will work most of the time!\n" +"If the memory for the `Dbm` object is not immediately reused, an internal check\n" +"will almost certainly fail, resulting in the iterator returning a `-1` indicating\n" +"an error. But occasionally, it will cause a segmentation fault, or even worse,\n" +"nonsensical memory corruption!" +msgstr "" +"Das Schlimmste an diesem Fehler?\n" +"Wenn die Rust-Implementierung vorsichtig war, wird dieser Code die meiste Zeit funktionieren!\n" +"Wenn der Speicher für das `Dbm`-Objekt nicht sofort wiederverwendet wird, erfolgt eine interne Überprüfung\n" +"wird mit ziemlicher Sicherheit fehlschlagen, was dazu führt, dass der Iterator ein \"-1\" zurückgibt, das anzeigt\n" +"ein Fehler. Aber gelegentlich wird es einen Segmentierungsfehler verursachen, oder noch schlimmer,\n" +"Unsinnige Speicherbeschädigung!" + +#: src\patterns/ffi/export.md:218 +#, fuzzy +msgid "" +"None of this can be avoided by Rust.\n" +"From its perspective, it put those objects on its heap, returned pointers to them,\n" +"and gave up control of their lifetimes. The C code simply must \"play nice\"." +msgstr "" +"Nichts davon kann von Rust verhindert werden.\n" +"Aus seiner Perspektive hat es diese Objekte auf seinen Haufen gelegt, Zeiger darauf zurückgegeben,\n" +"und gaben die Kontrolle über ihr Leben auf. Der C-Code muss einfach \"schön spielen\"." + +#: src\patterns/ffi/export.md:222 +#, fuzzy +msgid "" +"The programmer must read and understand the API documentation.\n" +"While some consider that par for the course in C, a good API design can mitigate\n" +"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ of\n" +"the iterator with its parent:" +msgstr "" +"Der Programmierer muss die API-Dokumentation lesen und verstehen.\n" +"Während einige dies als normal für den Kurs in C betrachten, kann ein gutes API-Design Abhilfe schaffen\n" +"dieses Risiko. Die POSIX-API für `DBM` tat dies durch _Konsolidierung der Eigentümerschaft_ von\n" +"der Iterator mit seinem Elternteil:" + +#: src\patterns/ffi/export.md:227 +msgid "" +"```C\n" +"datum dbm_firstkey(DBM *);\n" +"datum dbm_nextkey(DBM *);\n" +"```" +msgstr "" + +#: src\patterns/ffi/export.md:232 +#, fuzzy +msgid "Thus, all the lifetimes were bound together, and such unsafety was prevented." +msgstr "Somit waren alle Leben miteinander verbunden und eine solche Unsicherheit wurde verhindert." + +#: src\patterns/ffi/export.md:236 +#, fuzzy +msgid "" +"However, this design choice also has a number of drawbacks, which should be\n" +"considered as well." +msgstr "" +"Diese Designwahl hat jedoch auch eine Reihe von Nachteilen, die sein sollten\n" +"ebenso berücksichtigt." + +#: src\patterns/ffi/export.md:239 +#, fuzzy +msgid "" +"First, the API itself becomes less expressive.\n" +"With POSIX DBM, there is only one iterator per object, and every call changes\n" +"its state. This is much more restrictive than iterators in almost any language,\n" +"even though it is safe. Perhaps with other related objects, whose lifetimes are\n" +"less hierarchical, this limitation is more of a cost than the safety." +msgstr "" +"Erstens wird die API selbst weniger ausdrucksstark.\n" +"Bei POSIX DBM gibt es nur einen Iterator pro Objekt und jeder Aufruf ändert sich\n" +"sein Zustand. Dies ist viel restriktiver als Iteratoren in fast jeder Sprache,\n" +"obwohl es sicher ist. Vielleicht mit anderen verwandten Objekten, deren Lebenszeiten sind\n" +"weniger hierarchisch, diese Einschränkung ist eher ein Kostenfaktor als die Sicherheit." + +#: src\patterns/ffi/export.md:245 +#, fuzzy +msgid "" +"Second, depending on the relationships of the API's parts, significant design effort\n" +"may be involved. Many of the easier design points have other patterns associated\n" +"with them:" +msgstr "" +"Zweitens, abhängig von den Beziehungen der API-Teile, erheblicher Designaufwand\n" +"beteiligt sein können. Viele der einfacheren Entwurfspunkte sind mit anderen Mustern verbunden\n" +"mit ihnen:" + +#: src\patterns/ffi/export.md:249 +#, fuzzy +msgid "" +"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types together\n" +" into an opaque \"object\"\n" +"\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling with integer\n" +" codes and sentinel return values (such as `NULL` pointers)\n" +"\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows accepting\n" +" strings with minimal unsafe code, and is easier to get right than\n" +" [Passing Strings to FFI](../../idioms/ffi/passing-strings.md)" +msgstr "" +"- [Wrapper Type Consolidation](./wrappers.md) gruppiert mehrere Rust-Typen zusammen\n" +" in ein undurchsichtiges \"Objekt\"\n" +"\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) erklärt die Fehlerbehandlung mit Integer\n" +" Codes und Sentinel-Rückgabewerte (z. B. `NULL`-Zeiger)\n" +"\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) erlaubt das Akzeptieren\n" +" Zeichenfolgen mit minimalem unsicherem Code und ist einfacher zu korrigieren als\n" +" [Strings an FFI übergeben](../../idioms/ffi/passing-strings.md)" + +#: src\patterns/ffi/export.md:259 +#, fuzzy +msgid "" +"However, not every API can be done this way.\n" +"It is up to the best judgement of the programmer as to who their audience is." +msgstr "" +"Allerdings kann nicht jede API auf diese Weise ausgeführt werden.\n" +"Es liegt im Ermessen des Programmierers, wer sein Publikum ist." + +#: src\patterns/ffi/wrappers.md:1 +#, fuzzy +msgid "# Type Consolidation into Wrappers" +msgstr "# Geben Sie Consolidation in Wrappers ein" + +#: src\patterns/ffi/wrappers.md:5 +#, fuzzy +msgid "" +"This pattern is designed to allow gracefully handling multiple related types,\n" +"while minimizing the surface area for memory unsafety." +msgstr "" +"Dieses Muster wurde entwickelt, um eine elegante Handhabung mehrerer verwandter Typen zu ermöglichen.\n" +"während die Oberfläche für Speicherunsicherheit minimiert wird." + +#: src\patterns/ffi/wrappers.md:8 +#, fuzzy +msgid "" +"One of the cornerstones of Rust's aliasing rules is lifetimes.\n" +"This ensures that many patterns of access between types can be memory safe,\n" +"data race safety included." +msgstr "" +"Einer der Eckpfeiler der Aliasing-Regeln von Rust ist die Lebensdauer.\n" +"Dadurch wird sichergestellt, dass viele Zugriffsmuster zwischen Typen speichersicher sein können,\n" +"Data Race Safety inklusive." + +#: src\patterns/ffi/wrappers.md:12 +#, fuzzy +msgid "" +"However, when Rust types are exported to other languages, they are usually transformed\n" +"into pointers. In Rust, a pointer means \"the user manages the lifetime of the pointee.\"\n" +"It is their responsibility to avoid memory unsafety." +msgstr "" +"Wenn Rust-Typen jedoch in andere Sprachen exportiert werden, werden sie normalerweise transformiert\n" +"in Zeiger. In Rust bedeutet ein Zeiger „der Benutzer verwaltet die Lebensdauer des Pointees“.\n" +"Es liegt in ihrer Verantwortung, Speicherunsicherheit zu vermeiden." + +#: src\patterns/ffi/wrappers.md:16 +#, fuzzy +msgid "" +"Some level of trust in the user code is thus required, notably around use-after-free\n" +"which Rust can do nothing about. However, some API designs place higher burdens\n" +"than others on the code written in the other language." +msgstr "" +"Daher ist ein gewisses Maß an Vertrauen in den Benutzercode erforderlich, insbesondere in Bezug auf die Nutzung nach der Freischaltung\n" +"wofür Rust nichts kann. Einige API-Designs stellen jedoch höhere Belastungen dar\n" +"als andere auf dem in der anderen Sprache geschriebenen Code." + +#: src\patterns/ffi/wrappers.md:20 +#, fuzzy +msgid "" +"The lowest risk API is the \"consolidated wrapper\", where all possible interactions\n" +"with an object are folded into a \"wrapper type\", while keeping the Rust API clean." +msgstr "" +"Die API mit dem geringsten Risiko ist der „konsolidierte Wrapper“, in dem alle möglichen Interaktionen enthalten sind\n" +"mit einem Objekt werden in einen \"Wrapper-Typ\" gefaltet, während die Rust-API sauber bleibt." + +#: src\patterns/ffi/wrappers.md:25 +#, fuzzy +msgid "" +"To understand this, let us look at a classic example of an API to export: iteration\n" +"through a collection." +msgstr "" +"Um dies zu verstehen, sehen wir uns ein klassisches Beispiel für eine zu exportierende API an: Iteration\n" +"durch eine Sammlung." + +#: src\patterns/ffi/wrappers.md:28 +msgid "That API looks like this:" +msgstr "Diese API sieht so aus:" + +#: src\patterns/ffi/wrappers.md:30 +#, fuzzy +msgid "" +"1. The iterator is initialized with `first_key`.\n" +"2. Each call to `next_key` will advance the iterator.\n" +"3. Calls to `next_key` if the iterator is at the end will do nothing.\n" +"4. As noted above, the iterator is \"wrapped into\" the collection (unlike the native\n" +" Rust API)." +msgstr "" +"1. Der Iterator wird mit `first_key` initialisiert.\n" +"2. Jeder Aufruf von `next_key` wird den Iterator vorrücken.\n" +"3. Aufrufe von „next_key“, wenn der Iterator am Ende steht, werden nichts bewirken.\n" +"4. Wie oben erwähnt, wird der Iterator in die Sammlung „eingepackt“ (anders als der native\n" +" Rust-API)." + +#: src\patterns/ffi/wrappers.md:36 +#, fuzzy +msgid "" +"If the iterator implements `nth()` efficiently, then it is possible to make it\n" +"ephemeral to each function call:" +msgstr "" +"Wenn der Iterator `nth()` effizient implementiert, dann ist es möglich, es zu machen\n" +"ephemer für jeden Funktionsaufruf:" + +#: src\patterns/ffi/wrappers.md:39 +msgid "" +"```rust,ignore\n" +"struct MySetWrapper {\n" +" myset: MySet,\n" +" iter_next: usize,\n" +"}\n" +"\n" +"impl MySetWrapper {\n" +" pub fn first_key(&mut self) -> Option<&Key> {\n" +" self.iter_next = 0;\n" +" self.next_key()\n" +" }\n" +" pub fn next_key(&mut self) -> Option<&Key> {\n" +" if let Some(next) = self.myset.keys().nth(self.iter_next) {\n" +" self.iter_next += 1;\n" +" Some(next)\n" +" } else {\n" +" None\n" +" }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/ffi/wrappers.md:61 +#, fuzzy +msgid "As a result, the wrapper is simple and contains no `unsafe` code." +msgstr "Dadurch ist der Wrapper einfach und enthält keinen „unsicheren“ Code." + +#: src\patterns/ffi/wrappers.md:65 +#, fuzzy +msgid "" +"This makes APIs safer to use, avoiding issues with lifetimes between types.\n" +"See [Object-Based APIs](./export.md) for more on the advantages and pitfalls\n" +"this avoids." +msgstr "" +"Dies macht die Verwendung von APIs sicherer und vermeidet Probleme mit Lebensdauern zwischen Typen.\n" +"Weitere Informationen zu den Vorteilen und Fallstricken finden Sie unter [Objektbasierte APIs](./export.md).\n" +"dies vermeidet." + +#: src\patterns/ffi/wrappers.md:71 +#, fuzzy +msgid "" +"Often, wrapping types is quite difficult, and sometimes a Rust API compromise\n" +"would make things easier." +msgstr "" +"Wrapping-Typen sind oft ziemlich schwierig und manchmal ein Kompromiss für die Rust-API\n" +"würde die Sache erleichtern." + +#: src\patterns/ffi/wrappers.md:74 +#, fuzzy +msgid "" +"As an example, consider an iterator which does not efficiently implement `nth()`.\n" +"It would definitely be worth putting in special logic to make the object handle\n" +"iteration internally, or to support a different access pattern efficiently that\n" +"only the Foreign Function API will use." +msgstr "" +"Betrachten Sie als Beispiel einen Iterator, der `nth()` nicht effizient implementiert.\n" +"Es würde sich definitiv lohnen, eine spezielle Logik einzubauen, um das Objekt-Handle zu erstellen\n" +"Iteration intern, oder um ein anderes Zugriffsmuster effizient zu unterstützen\n" +"nur die Fremdfunktions-API wird verwendet." + +#: src\patterns/ffi/wrappers.md:79 +#, fuzzy +msgid "### Trying to Wrap Iterators (and Failing)" +msgstr "### Versuch, Iteratoren einzubinden (und fehlgeschlagen)" + +#: src\patterns/ffi/wrappers.md:81 +#, fuzzy +msgid "" +"To wrap any type of iterator into the API correctly, the wrapper would need to\n" +"do what a C version of the code would do: erase the lifetime of the iterator,\n" +"and manage it manually." +msgstr "" +"Um jede Art von Iterator korrekt in die API einzubinden, müsste der Wrapper dies tun\n" +"tun, was eine C-Version des Codes tun würde: die Lebensdauer des Iterators löschen,\n" +"und manuell verwalten." + +#: src\patterns/ffi/wrappers.md:85 +msgid "Suffice it to say, this is _incredibly_ difficult." +msgstr "Es genügt zu sagen, dass dies _unglaublich_ schwierig ist." + +#: src\patterns/ffi/wrappers.md:87 +msgid "Here is an illustration of just _one_ pitfall." +msgstr "Hier ist eine Illustration von nur _einem_ tückischen Problem." + +#: src\patterns/ffi/wrappers.md:89 +msgid "A first version of `MySetWrapper` would look like this:" +msgstr "Eine erste Version von `MySetWrapper` würde so aussehen:" + +#: src\patterns/ffi/wrappers.md:91 +msgid "" +"```rust,ignore\n" +"struct MySetWrapper {\n" +" myset: MySet,\n" +" iter_next: usize,\n" +" // created from a transmuted Box\n" +" iterator: Option>>,\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/ffi/wrappers.md:100 +#, fuzzy +msgid "" +"With `transmute` being used to extend a lifetime, and a pointer to hide it,\n" +"it's ugly already. But it gets even worse: _any other operation can cause\n" +"Rust `undefined behaviour`_." +msgstr "" +"Mit \"transmutieren\", das verwendet wird, um ein Leben zu verlängern, und einem Zeiger, um es zu verbergen,\n" +"es ist schon hässlich. Aber es kommt noch schlimmer: _jede andere Operation kann dazu führen\n" +"Rust `undefiniertes Verhalten`_." + +#: src\patterns/ffi/wrappers.md:104 +#, fuzzy +msgid "" +"Consider that the `MySet` in the wrapper could be manipulated by other\n" +"functions during iteration, such as storing a new value to the key it was\n" +"iterating over. The API doesn't discourage this, and in fact some similar C\n" +"libraries expect it." +msgstr "" +"Bedenken Sie, dass das `MySet` im Wrapper von anderen manipuliert werden könnte\n" +"Funktionen während der Iteration, z. B. das Speichern eines neuen Werts in dem Schlüssel, der er war\n" +"Iteration über. Die API entmutigt dies nicht, und tatsächlich einige ähnliche C\n" +"Bibliotheken erwarten es." + +#: src\patterns/ffi/wrappers.md:109 +msgid "A simple implementation of `myset_store` would be:" +msgstr "Eine einfache Implementierung von `myset_store` wäre:" + +#: src\patterns/ffi/wrappers.md:111 +msgid "" +"```rust,ignore\n" +"pub mod unsafe_module {\n" +"\n" +" // other module content\n" +"\n" +" pub fn myset_store(\n" +" myset: *mut MySetWrapper,\n" +" key: datum,\n" +" value: datum) -> libc::c_int {\n" +"\n" +" // DO NOT USE THIS CODE. IT IS UNSAFE TO DEMONSTRATE A PROLBEM.\n" +"\n" +" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in here!\n" +" &mut (*myset).myset\n" +" };\n" +"\n" +" /* ...check and cast key and value data... */\n" +"\n" +" match myset.store(casted_key, casted_value) {\n" +" Ok(_) => 0,\n" +" Err(e) => e.into()\n" +" }\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\patterns/ffi/wrappers.md:137 +#, fuzzy +msgid "" +"If the iterator exists when this function is called, we have violated one of Rust's\n" +"aliasing rules. According to Rust, the mutable reference in this block must have\n" +"_exclusive_ access to the object. If the iterator simply exists, it's not exclusive,\n" +"so we have `undefined behaviour`! " +msgstr "" +"Wenn der Iterator existiert, wenn diese Funktion aufgerufen wird, haben wir einen von Rust verletzt\n" +"Aliasing-Regeln. Laut Rust muss die veränderliche Referenz in diesem Block stehen\n" +"_exklusiver_ Zugriff auf das Objekt. Wenn der Iterator einfach existiert, ist er nicht exklusiv,\n" +"also haben wir `undefiniertes Verhalten`!" + +#: src\patterns/ffi/wrappers.md:142 +#, fuzzy +msgid "" +"To avoid this, we must have a way of ensuring that mutable reference really is exclusive.\n" +"That basically means clearing out the iterator's shared reference while it exists,\n" +"and then reconstructing it. In most cases, that will still be less efficient than\n" +"the C version." +msgstr "" +"Um dies zu vermeiden, müssen wir sicherstellen, dass veränderliche Referenzen wirklich exklusiv sind.\n" +"Das bedeutet im Grunde, dass die gemeinsame Referenz des Iterators gelöscht wird, während sie existiert.\n" +"und dann rekonstruieren. In den meisten Fällen ist das immer noch weniger effizient als\n" +"die C-Version." + +#: src\patterns/ffi/wrappers.md:147 +#, fuzzy +msgid "" +"Some may ask: how can C do this more efficiently?\n" +"The answer is, it cheats. Rust's aliasing rules are the problem, and C simply ignores\n" +"them for its pointers. In exchange, it is common to see code that is declared\n" +"in the manual as \"not thread safe\" under some or all circumstances. In fact,\n" +"the [GNU C library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"has an entire lexicon dedicated to concurrent behavior!" +msgstr "" +"Manche mögen fragen: Wie kann C das effizienter machen?\n" +"Die Antwort ist, es betrügt. Rusts Aliasing-Regeln sind das Problem, und C ignoriert es einfach\n" +"ihnen für seine Hinweise. Im Gegenzug ist es üblich, deklarierten Code zu sehen\n" +"im Handbuch unter bestimmten oder allen Umständen als \"nicht threadsicher\" bezeichnet. In der Tat,\n" +"die [GNU C-Bibliothek] (https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"hat ein ganzes Lexikon, das dem gleichzeitigen Verhalten gewidmet ist!" + +#: src\patterns/ffi/wrappers.md:154 +#, fuzzy +msgid "" +"Rust would rather make everything memory safe all the time, for both safety and\n" +"optimizations that C code cannot attain. Being denied access to certain shortcuts\n" +"is the price Rust programmers need to pay." +msgstr "" +"Rust würde lieber alles speichersicher machen, sowohl aus Sicherheits- als auch aus Sicherheitsgründen\n" +"Optimierungen, die C-Code nicht erreichen kann. Der Zugriff auf bestimmte Verknüpfungen wird verweigert\n" +"ist der Preis, den Rust-Programmierer zahlen müssen." + +#: src\patterns/ffi/wrappers.md:158 +#, fuzzy +msgid "" +"For the C programmers out there scratching their heads, the iterator need\n" +"not be read _during_ this code cause the UB. The exclusivity rule also enables\n" +"compiler optimizations which may cause inconsistent observations by the iterator's\n" +"shared reference (e.g. stack spills or reordering instructions for efficiency).\n" +"These observations may happen _any time after_ the mutable reference is created." +msgstr "" +"Für die C-Programmierer da draußen, die sich am Kopf kratzen, braucht der Iterator\n" +"nicht gelesen werden _während_ dieser Code verursacht die UB. Die Exklusivitätsregel ermöglicht auch\n" +"Compiler-Optimierungen, die zu inkonsistenten Beobachtungen durch den Iterator führen können\n" +"gemeinsame Referenz (z. B. Stapel von Verschüttungen oder Neuordnungsanweisungen für Effizienz).\n" +"Diese Beobachtungen können _jederzeit erfolgen, nachdem_ die veränderliche Referenz erstellt wurde." + +#: src\anti_patterns/index.md:1 +msgid "# Anti-patterns" +msgstr "# Antimuster" + +#: src\anti_patterns/index.md:3 +msgid "" +"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution to\n" +"a \"recurring problem that is usually ineffective and risks being highly\n" +"counterproductive\". Just as valuable as knowing how to solve a problem, is\n" +"knowing how _not_ to solve it. Anti-patterns give us great counter-examples to\n" +"consider relative to design patterns. Anti-patterns are not confined to code.\n" +"For example, a process can be an anti-pattern, too." +msgstr "" +"Ein [Antimuster](https://en.wikipedia.org/wiki/Anti-Pattern) ist eine Lösung für\n" +"ein \"wiederkehrendes Problem, das in der Regel unwirksam ist und das Risiko eingeht, höchst\n" +"kontraproduktiv zu sein\". Genauso wertvoll wie das Wissen, wie man ein Problem löst, ist\n" +"zu wissen, wie man es _nicht_ löst. Antimuster geben uns deshalb großartige Gegenbeispiele\n" +"zu Entwurfsmustern. Antimuster sind nicht auf Code beschränkt.\n" +"Ein Prozess kann beispielsweise auch ein Antimuster sein." + +#: src\anti_patterns/borrow_clone.md:1 +#, fuzzy +msgid "# Clone to satisfy the borrow checker" +msgstr "# Klonen, um den Borrow-Checker zu befriedigen" + +#: src\anti_patterns/borrow_clone.md:5 +#, fuzzy +msgid "" +"The borrow checker prevents Rust users from developing otherwise unsafe code by\n" +"ensuring that either: only one mutable reference exists, or potentially many but\n" +"all immutable references exist. If the code written does not hold true to these\n" +"conditions, this anti-pattern arises when the developer resolves the compiler\n" +"error by cloning the variable." +msgstr "" +"Der Borrow-Checker hindert Rust-Benutzer daran, ansonsten unsicheren Code zu entwickeln\n" +"Sicherstellen, dass entweder: nur eine änderbare Referenz existiert, oder möglicherweise viele aber\n" +"alle unveränderlichen Referenzen existieren. Wenn der geschriebene Code diesen nicht entspricht\n" +"Bedingungen entsteht dieses Antimuster, wenn der Entwickler den Compiler auflöst\n" +"Fehler durch Klonen der Variablen." + +#: src\anti_patterns/borrow_clone.md:13 +msgid "" +"```rust\n" +"// define any variable\n" +"let mut x = 5;\n" +"\n" +"// Borrow `x` -- but clone it first\n" +"let y = &mut (x.clone());\n" +"\n" +"// without the x.clone() two lines prior, this line would fail on compile as\n" +"// x has been borrowed\n" +"// thanks to x.clone(), x was never borrowed, and this line will run.\n" +"println!(\"{}\", x);\n" +"\n" +"// perform some action on the borrow to prevent rust from optimizing this\n" +"//out of existence\n" +"*y += 1;\n" +"```" +msgstr "" + +#: src\anti_patterns/borrow_clone.md:32 +#, fuzzy +msgid "" +"It is tempting, particularly for beginners, to use this pattern to resolve\n" +"confusing issues with the borrow checker. However, there are serious\n" +"consequences. Using `.clone()` causes a copy of the data to be made. Any changes\n" +"between the two are not synchronized -- as if two completely separate variables\n" +"exist." +msgstr "" +"Es ist verlockend, besonders für Anfänger, dieses Muster zur Lösung zu verwenden\n" +"verwirrende Probleme mit dem Leihprüfer. Es gibt jedoch ernste\n" +"Folgen. Die Verwendung von `.clone()` bewirkt, dass eine Kopie der Daten erstellt wird. Irgendwelche Veränderungen\n" +"zwischen den beiden sind nicht synchronisiert - als ob zwei völlig getrennte Variablen wären\n" +"existieren." + +#: src\anti_patterns/borrow_clone.md:38 +#, fuzzy +msgid "" +"There are special cases -- `Rc` is designed to handle clones intelligently.\n" +"It internally manages exactly one copy of the data, and cloning it will only\n" +"clone the reference." +msgstr "" +"Es gibt Sonderfälle – `Rc` wurde entwickelt, um Klone intelligent zu handhaben.\n" +"Es verwaltet intern genau eine Kopie der Daten, und das Klonen wird es nur\n" +"Klonen Sie die Referenz." + +#: src\anti_patterns/borrow_clone.md:42 +#, fuzzy +msgid "" +"There is also `Arc` which provides shared ownership of a value of type T\n" +"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new `Arc`\n" +"instance, which points to the same allocation on the heap as the source `Arc`,\n" +"while increasing a reference count." +msgstr "" +"Es gibt auch `Arc`, das den gemeinsamen Besitz eines Werts vom Typ T bereitstellt\n" +"die im Heap allokiert ist. Der Aufruf von `.clone()` auf `Arc` erzeugt einen neuen `Arc`\n" +"Instanz, die auf die gleiche Zuweisung auf dem Heap zeigt wie die Quelle `Arc`,\n" +"während eine Referenzzählung erhöht wird." + +#: src\anti_patterns/borrow_clone.md:47 +#, fuzzy +msgid "" +"In general, clones should be deliberate, with full understanding of the\n" +"consequences. If a clone is used to make a borrow checker error disappear,\n" +"that's a good indication this anti-pattern may be in use." +msgstr "" +"Im Allgemeinen sollten Klone bewusst sein, mit vollem Verständnis der\n" +"Folgen. Wenn ein Klon verwendet wird, um einen Borrow-Checker-Fehler verschwinden zu lassen,\n" +"das ist ein guter Hinweis darauf, dass dieses Antimuster verwendet wird." + +#: src\anti_patterns/borrow_clone.md:51 +#, fuzzy +msgid "" +"Even though `.clone()` is an indication of a bad pattern, sometimes\n" +"**it is fine to write inefficient code**, in cases such as when:" +msgstr "" +"Auch wenn `.clone()` manchmal ein Hinweis auf ein schlechtes Muster ist\n" +"**es ist in Ordnung, ineffizienten Code zu schreiben**, z. B. wenn:" + +#: src\anti_patterns/borrow_clone.md:54 +#, fuzzy +msgid "" +"- the developer is still new to ownership\n" +"- the code doesn't have great speed or memory constraints\n" +" (like hackathon projects or prototypes)\n" +"- satisfying the borrow checker is really complicated, and you prefer to\n" +" optimize readability over performance" +msgstr "" +"- Der Entwickler ist noch neu im Besitz\n" +"- Der Code hat keine großen Geschwindigkeits- oder Speicherbeschränkungen\n" +" (wie Hackathon-Projekte oder Prototypen)\n" +"- Den Kreditprüfer zu befriedigen ist wirklich kompliziert, und Sie ziehen es vor\n" +" Optimieren Sie die Lesbarkeit gegenüber der Leistung" + +#: src\anti_patterns/borrow_clone.md:60 +#, fuzzy +msgid "" +"If an unnecessary clone is suspected, The [Rust Book's chapter on Ownership](https://doc.rust-lang.org/book/ownership.html)\n" +"should be understood fully before assessing whether the clone is required or not." +msgstr "" +"Wenn ein unnötiger Klon vermutet wird, lesen Sie im [Kapitel des Rust Book über Eigentum](https://doc.rust-lang.org/book/ownership.html) " +"nach.\n" +"vollständig verstanden werden, bevor beurteilt wird, ob der Klon erforderlich ist oder nicht." + +#: src\anti_patterns/borrow_clone.md:63 +#, fuzzy +msgid "" +"Also be sure to always run `cargo clippy` in your project, which will detect some\n" +"cases in which `.clone()` is not necessary, like [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or [4](https://rust-lang.github.io/rust-clippy/master/index." +"html#clone_double_ref)." +msgstr "" +"Stellen Sie außerdem sicher, dass Sie in Ihrem Projekt immer \"cargo clippy\" ausführen, wodurch einige erkannt werden\n" +"Fälle, in denen `.clone()` nicht notwendig ist, wie [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) oder [4](https://rust-lang.github.io/rust-clippy/master /index." +"html#clone_double_ref)." + +#: src\anti_patterns/borrow_clone.md:70 +#, fuzzy +msgid "" +"- [`mem::{take(_), replace(_)}` to keep owned values in changed enums](../idioms/mem-replace.md)\n" +"- [`Rc` documentation, which handles .clone() intelligently](http://doc.rust-lang.org/std/rc/)\n" +"- [`Arc` documentation, a thread-safe reference-counting pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" +"- [Tricks with ownership in Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +msgstr "" +"- [`mem::{take(_), replace(_)}` um eigene Werte in geänderten Aufzählungen zu behalten](../idioms/mem-replace.md)\n" +"- [`Rc`-Dokumentation, die .clone() intelligent handhabt](http://doc.rust-lang.org/std/rc/)\n" +"- [`Arc`-Dokumentation, ein Thread-sicherer Referenzzählzeiger](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" +"- [Tricks mit Eigentum in Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" + +#: src\anti_patterns/deny-warnings.md:1 +msgid "# `#![deny(warnings)]`" +msgstr "" + +#: src\anti_patterns/deny-warnings.md:5 +#, fuzzy +msgid "" +"A well-intentioned crate author wants to ensure their code builds without\n" +"warnings. So they annotate their crate root with the following:" +msgstr "" +"Ein gut gemeinter Crate-Autor möchte sicherstellen, dass seine Code-Builds ohne\n" +"Warnungen. Also kommentieren sie ihre Kistenwurzel mit dem Folgenden:" + +#: src\anti_patterns/deny-warnings.md:10 +msgid "" +"```rust\n" +"#![deny(warnings)]\n" +"\n" +"// All is well.\n" +"```" +msgstr "" + +#: src\anti_patterns/deny-warnings.md:18 +msgid "It is short and will stop the build if anything is amiss." +msgstr "Es ist kurz und stoppt den Build, wenn etwas nicht stimmt." + +#: src\anti_patterns/deny-warnings.md:20 +msgid "## Drawbacks" +msgstr "## Nachteile" + +#: src\anti_patterns/deny-warnings.md:22 +#, fuzzy +msgid "" +"By disallowing the compiler to build with warnings, a crate author opts out of\n" +"Rust's famed stability. Sometimes new features or old misfeatures need a change\n" +"in how things are done, thus lints are written that `warn` for a certain grace\n" +"period before being turned to `deny`." +msgstr "" +"Indem er dem Compiler verbietet, mit Warnungen zu bauen, entscheidet sich ein Crate-Autor dagegen\n" +"Rusts berühmte Stabilität. Manchmal müssen neue Funktionen oder alte Fehlfunktionen geändert werden\n" +"in der Weise, wie Dinge getan werden, so werden Lints geschrieben, die vor einer gewissen Gnade 'warnen'\n" +"Zeitraum, bevor er zu \"deny\" gedreht wird." + +#: src\anti_patterns/deny-warnings.md:27 +#, fuzzy +msgid "" +"For example, it was discovered that a type could have two `impl`s with the same\n" +"method. This was deemed a bad idea, but in order to make the transition smooth,\n" +"the `overlapping-inherent-impls` lint was introduced to give a warning to those\n" +"stumbling on this fact, before it becomes a hard error in a future release." +msgstr "" +"Zum Beispiel wurde entdeckt, dass ein Typ zwei `impl`s mit demselben haben kann\n" +"Methode. Dies wurde als schlechte Idee angesehen, aber um den Übergang reibungslos zu gestalten,\n" +"der Lint `overlapping-inherent-impls` wurde eingeführt, um diese zu warnen\n" +"über diese Tatsache zu stolpern, bevor es in einer zukünftigen Version zu einem schwerwiegenden Fehler wird." + +#: src\anti_patterns/deny-warnings.md:32 +#, fuzzy +msgid "" +"Also sometimes APIs get deprecated, so their use will emit a warning where\n" +"before there was none." +msgstr "" +"Außerdem werden APIs manchmal veraltet, sodass bei ihrer Verwendung eine Warnung ausgegeben wird\n" +"vorher gab es keine." + +#: src\anti_patterns/deny-warnings.md:35 +#, fuzzy +msgid "All this conspires to potentially break the build whenever something changes." +msgstr "All dies wirkt sich darauf aus, den Build möglicherweise zu beschädigen, wenn sich etwas ändert." + +#: src\anti_patterns/deny-warnings.md:37 +#, fuzzy +msgid "" +"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can no\n" +"longer be used unless the annotation is removed. This is mitigated with\n" +"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all `deny`\n" +"lint errors into warnings." +msgstr "" +"Darüber hinaus können Kisten, die zusätzliche Flusen liefern (z. B. [rust-clippy]), nicht verwendet werden\n" +"nicht mehr verwendet werden, es sei denn, die Anmerkung wird entfernt. Dies wird mit gemildert\n" +"[--cap-lints]. Das Befehlszeilenargument `--cap-lints=warn` macht alle `deny`\n" +"Flusenfehler in Warnungen umwandeln." + +#: src\anti_patterns/deny-warnings.md:42 src\functional/generics-type-classes.md:227 +msgid "## Alternatives" +msgstr "## Alternativen" + +#: src\anti_patterns/deny-warnings.md:44 +#, fuzzy +msgid "" +"There are two ways of tackling this problem: First, we can decouple the build\n" +"setting from the code, and second, we can name the lints we want to deny\n" +"explicitly." +msgstr "" +"Es gibt zwei Möglichkeiten, dieses Problem anzugehen: Erstens können wir den Build entkoppeln\n" +"Einstellung aus dem Code, und zweitens können wir die Lints benennen, die wir verweigern möchten\n" +"ausdrücklich." + +#: src\anti_patterns/deny-warnings.md:48 +#, fuzzy +msgid "The following command line will build with all warnings set to `deny`:" +msgstr "Die folgende Befehlszeile wird erstellt, wobei alle Warnungen auf „deny“ gesetzt sind:" + +#: src\anti_patterns/deny-warnings.md:50 +msgid "`RUSTFLAGS=\"-D warnings\" cargo build`" +msgstr "" + +#: src\anti_patterns/deny-warnings.md:52 +#, fuzzy +msgid "" +"This can be done by any individual developer (or be set in a CI tool like\n" +"Travis, but remember that this may break the build when something changes)\n" +"without requiring a change to the code." +msgstr "" +"Dies kann von jedem einzelnen Entwickler durchgeführt werden (oder in einem CI-Tool wie z\n" +"Travis, aber denken Sie daran, dass dies den Build beschädigen kann, wenn sich etwas ändert)\n" +"ohne dass der Code geändert werden muss." + +#: src\anti_patterns/deny-warnings.md:56 +#, fuzzy +msgid "" +"Alternatively, we can specify the lints that we want to `deny` in the code.\n" +"Here is a list of warning lints that is (hopefully) safe to deny (as of Rustc 1.48.0):" +msgstr "" +"Alternativ können wir die Lints angeben, die wir im Code „verweigern“ möchten.\n" +"Hier ist eine Liste von Warnhinweisen, die (hoffentlich) sicher geleugnet werden können (ab Rustc 1.48.0):" + +#: src\anti_patterns/deny-warnings.md:59 +msgid "" +"```rust,ignore\n" +"#![deny(bad_style,\n" +" const_err,\n" +" dead_code,\n" +" improper_ctypes,\n" +" non_shorthand_field_patterns,\n" +" no_mangle_generic_items,\n" +" overflowing_literals,\n" +" path_statements,\n" +" patterns_in_fns_without_body,\n" +" private_in_public,\n" +" unconditional_recursion,\n" +" unused,\n" +" unused_allocation,\n" +" unused_comparisons,\n" +" unused_parens,\n" +" while_true)]\n" +"```" +msgstr "" + +#: src\anti_patterns/deny-warnings.md:78 +#, fuzzy +msgid "In addition, the following `allow`ed lints may be a good idea to `deny`:" +msgstr "Darüber hinaus kann es eine gute Idee sein, die folgenden „erlaubten“ Lints zu „verweigern“:" + +#: src\anti_patterns/deny-warnings.md:80 +msgid "" +"```rust,ignore\n" +"#![deny(missing_debug_implementations,\n" +" missing_docs,\n" +" trivial_casts,\n" +" trivial_numeric_casts,\n" +" unused_extern_crates,\n" +" unused_import_braces,\n" +" unused_qualifications,\n" +" unused_results)]\n" +"```" +msgstr "" + +#: src\anti_patterns/deny-warnings.md:91 +#, fuzzy +msgid "Some may also want to add `missing-copy-implementations` to their list." +msgstr "Einige möchten vielleicht auch `missing-copy-implementations` zu ihrer Liste hinzufügen." + +#: src\anti_patterns/deny-warnings.md:93 +#, fuzzy +msgid "" +"Note that we explicitly did not add the `deprecated` lint, as it is fairly\n" +"certain that there will be more deprecated APIs in the future." +msgstr "" +"Beachten Sie, dass wir den „veralteten“ Lint ausdrücklich nicht hinzugefügt haben, da dies fair ist\n" +"sicher, dass es in Zukunft mehr veraltete APIs geben wird." + +#: src\anti_patterns/deny-warnings.md:98 +#, fuzzy +msgid "" +"- [A collection of all clippy lints](https://rust-lang.github.io/rust-clippy/master)\n" +"- [deprecate attribute] documentation\n" +"- Type `rustc -W help` for a list of lints on your system. Also type\n" +" `rustc --help` for a general list of options\n" +"- [rust-clippy] is a collection of lints for better Rust code" +msgstr "" +"- [Eine Sammlung aller Clippy-Lints](https://rust-lang.github.io/rust-clippy/master)\n" +"- [veraltetes Attribut] Dokumentation\n" +"- Geben Sie `rustc -W help` ein, um eine Liste der Lints auf Ihrem System anzuzeigen. Auch tippen\n" +" `rustc --help` für eine allgemeine Liste von Optionen\n" +"- [rust-clippy] ist eine Sammlung von Lints für besseren Rust-Code" + +#: src\anti_patterns/deref.md:1 +msgid "# `Deref` polymorphism" +msgstr "# `Deref`-Polymorphismus" + +#: src\anti_patterns/deref.md:5 +#, fuzzy +msgid "" +"Misuse the `Deref` trait to emulate inheritance between structs, and thus reuse\n" +"methods." +msgstr "" +"Missbrauchen Sie das `Deref`-Merkmal, um die Vererbung zwischen Strukturen zu emulieren und somit wiederzuverwenden\n" +"Methoden." + +#: src\anti_patterns/deref.md:10 +#, fuzzy +msgid "" +"Sometimes we want to emulate the following common pattern from OO languages such\n" +"as Java:" +msgstr "" +"Manchmal möchten wir das folgende gemeinsame Muster von OO-Sprachen emulieren, wie z\n" +"als Java:" + +#: src\anti_patterns/deref.md:13 +msgid "" +"```java\n" +"class Foo {\n" +" void m() { ... }\n" +"}\n" +"\n" +"class Bar extends Foo {}\n" +"\n" +"public static void main(String[] args) {\n" +" Bar b = new Bar();\n" +" b.m();\n" +"}\n" +"```" +msgstr "" + +#: src\anti_patterns/deref.md:26 +#, fuzzy +msgid "We can use the deref polymorphism anti-pattern to do so:" +msgstr "Wir können dazu das Polymorphismus-Antimuster deref verwenden:" + +#: src\anti_patterns/deref.md:28 +msgid "" +"```rust\n" +"use std::ops::Deref;\n" +"\n" +"struct Foo {}\n" +"\n" +"impl Foo {\n" +" fn m(&self) {\n" +" //..\n" +" }\n" +"}\n" +"\n" +"struct Bar {\n" +" f: Foo,\n" +"}\n" +"\n" +"impl Deref for Bar {\n" +" type Target = Foo;\n" +" fn deref(&self) -> &Foo {\n" +" &self.f\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" let b = Bar { f: Foo {} };\n" +" b.m();\n" +"}\n" +"```" +msgstr "" + +#: src\anti_patterns/deref.md:56 +#, fuzzy +msgid "" +"There is no struct inheritance in Rust. Instead we use composition and include\n" +"an instance of `Foo` in `Bar` (since the field is a value, it is stored inline,\n" +"so if there were fields, they would have the same layout in memory as the Java\n" +"version (probably, you should use `#[repr(C)]` if you want to be sure))." +msgstr "" +"In Rust gibt es keine Strukturvererbung. Stattdessen verwenden wir „composition“ und „include“.\n" +"eine Instanz von `Foo` in `Bar` (da das Feld ein Wert ist, wird es inline gespeichert,\n" +"Wenn es also Felder gäbe, hätten sie das gleiche Layout im Speicher wie Java\n" +"Version (wahrscheinlich sollten Sie `#[repr(C)]` verwenden, wenn Sie sicher sein wollen))." + +#: src\anti_patterns/deref.md:61 +#, fuzzy +msgid "" +"In order to make the method call work we implement `Deref` for `Bar` with `Foo`\n" +"as the target (returning the embedded `Foo` field). That means that when we\n" +"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That is\n" +"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, here we\n" +"have two unrelated types. However, since the dot operator does implicit\n" +"dereferencing, it means that the method call will search for methods on `Foo` as\n" +"well as `Bar`." +msgstr "" +"Damit der Methodenaufruf funktioniert, implementieren wir `Deref` für `Bar` mit `Foo`\n" +"als Ziel (gibt das eingebettete `Foo`-Feld zurück). Das heißt, wenn wir\n" +"Dereferenzieren Sie einen `Bar` (zum Beispiel mit `*`), dann erhalten wir ein `Foo`. Das ist\n" +"ziemlich komisch. Die Dereferenzierung ergibt normalerweise ein `T` aus einer Referenz auf `T`, hier wir\n" +"haben zwei voneinander unabhängige Typen. Da der Punktoperator jedoch implizit funktioniert\n" +"Dereferenzierung bedeutet, dass der Methodenaufruf nach Methoden auf `Foo` as sucht\n" +"sowie \"Bar\"." + +#: src\anti_patterns/deref.md:71 +msgid "You save a little boilerplate, e.g.," +msgstr "Sie sparen sich etwas von einem wiederkehrenden Textbaustein, z.B.," + +#: src\anti_patterns/deref.md:73 +msgid "" +"```rust,ignore\n" +"impl Bar {\n" +" fn m(&self) {\n" +" self.f.m()\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\anti_patterns/deref.md:83 +#, fuzzy +msgid "" +"Most importantly this is a surprising idiom - future programmers reading this in\n" +"code will not expect this to happen. That's because we are misusing the `Deref`\n" +"trait rather than using it as intended (and documented, etc.). It's also because\n" +"the mechanism here is completely implicit." +msgstr "" +"Am wichtigsten ist, dass dies eine überraschende Redewendung ist - zukünftige Programmierer, die dies lesen\n" +"Code erwartet dies nicht. Das liegt daran, dass wir das `Deref` missbrauchen\n" +"Merkmal, anstatt es wie beabsichtigt (und dokumentiert usw.) zu verwenden. Es liegt auch daran\n" +"der Mechanismus ist hier völlig implizit." + +#: src\anti_patterns/deref.md:88 +#, fuzzy +msgid "" +"This pattern does not introduce subtyping between `Foo` and `Bar` like\n" +"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` are\n" +"not automatically implemented for `Bar`, so this pattern interacts badly with\n" +"bounds checking and thus generic programming." +msgstr "" +"Dieses Muster führt keine Untertypisierung zwischen „Foo“ und „Bar“ ein\n" +"Vererbung in Java oder C++ tut es. Weiterhin sind Traits von `Foo` implementiert\n" +"nicht automatisch für `Bar` implementiert, daher interagiert dieses Muster schlecht mit\n" +"Bounds Checking und damit generische Programmierung." + +#: src\anti_patterns/deref.md:93 +#, fuzzy +msgid "" +"Using this pattern gives subtly different semantics from most OO languages with\n" +"regards to `self`. Usually it remains a reference to the sub-class, with this\n" +"pattern it will be the 'class' where the method is defined." +msgstr "" +"Die Verwendung dieses Musters ergibt eine subtil unterschiedliche Semantik von den meisten OO-Sprachen mit\n" +"bezüglich „selbst“. In der Regel bleibt es dabei ein Verweis auf die Unterklasse\n" +"Muster ist die 'Klasse', in der die Methode definiert ist." + +#: src\anti_patterns/deref.md:97 +#, fuzzy +msgid "" +"Finally, this pattern only supports single inheritance, and has no notion of\n" +"interfaces, class-based privacy, or other inheritance-related features. So, it\n" +"gives an experience that will be subtly surprising to programmers used to Java\n" +"inheritance, etc." +msgstr "" +"Schließlich unterstützt dieses Muster nur die einfache Vererbung und hat keine Ahnung von\n" +"Schnittstellen, klassenbasierter Datenschutz oder andere vererbungsbezogene Funktionen. So dass es\n" +"bietet eine Erfahrung, die Programmierer, die an Java gewöhnt sind, auf subtile Weise überraschen wird\n" +"Erbe usw." + +#: src\anti_patterns/deref.md:104 +#, fuzzy +msgid "" +"There is no one good alternative. Depending on the exact circumstances it might\n" +"be better to re-implement using traits or to write out the facade methods to\n" +"dispatch to `Foo` manually. We do intend to add a mechanism for inheritance\n" +"similar to this to Rust, but it is likely to be some time before it reaches\n" +"stable Rust. See these [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"[posts](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" +"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more details." +msgstr "" +"Es gibt keine gute Alternative. Abhängig von den genauen Umständen könnte es sein\n" +"Besser ist es, mithilfe von Traits neu zu implementieren oder die Fassadenmethoden aufzuschreiben\n" +"Versand an `Foo` manuell. Wir beabsichtigen, einen Mechanismus für die Vererbung hinzuzufügen\n" +"Ähnlich wie bei Rust, aber es wird wahrscheinlich einige Zeit dauern, bis es erreicht wird\n" +"stabiler Rost. Siehe diesen [Blog] (http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"[Beiträge](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" +"und diese [RFC-Ausgabe](https://github.com/rust-lang/rfcs/issues/349) für weitere Details." + +#: src\anti_patterns/deref.md:112 +#, fuzzy +msgid "" +"The `Deref` trait is designed for the implementation of custom pointer types.\n" +"The intention is that it will take a pointer-to-`T` to a `T`, not convert\n" +"between different types. It is a shame that this isn't (probably cannot be)\n" +"enforced by the trait definition." +msgstr "" +"Die Eigenschaft „Deref“ ist für die Implementierung benutzerdefinierter Zeigertypen konzipiert.\n" +"Die Absicht ist, dass ein Zeiger auf „T“ in ein „T“ umgewandelt und nicht konvertiert wird\n" +"zwischen verschiedenen Typen. Es ist eine Schande, dass dies nicht ist (wahrscheinlich nicht sein kann)\n" +"durch die Eigenschaftsdefinition erzwungen." + +#: src\anti_patterns/deref.md:117 +#, fuzzy +msgid "" +"Rust tries to strike a careful balance between explicit and implicit mechanisms,\n" +"favouring explicit conversions between types. Automatic dereferencing in the dot\n" +"operator is a case where the ergonomics strongly favour an implicit mechanism,\n" +"but the intention is that this is limited to degrees of indirection, not\n" +"conversion between arbitrary types." +msgstr "" +"Rust versucht, eine sorgfältige Balance zwischen expliziten und impliziten Mechanismen zu finden,\n" +"Begünstigung expliziter Konvertierungen zwischen Typen. Automatische Dereferenzierung im Punkt\n" +"Bediener ist ein Fall, in dem die Ergonomie einen impliziten Mechanismus stark begünstigt,\n" +"aber die Absicht ist, dass dies auf indirekte Grade beschränkt ist, nicht\n" +"Konvertierung zwischen beliebigen Typen." + +#: src\anti_patterns/deref.md:125 +#, fuzzy +msgid "" +"- [Collections are smart pointers idiom](../idioms/deref.md).\n" +"- Delegation crates for less boilerplate like [delegate](https://crates.io/crates/delegate)\n" +" or [ambassador](https://crates.io/crates/ambassador)\n" +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +msgstr "" +"- [Collections are smart pointers idiom](../idioms/deref.md).\n" +"- Delegationskisten für weniger Boilerplate wie [Delegierter](https://crates.io/crates/delegate)\n" +" oder [Botschafter](https://crates.io/crates/ambassador)\n" +"- [Dokumentation für das `Deref`-Merkmal](https://doc.rust-lang.org/std/ops/trait.Deref.html)." + +#: src\functional/index.md:1 +msgid "# Functional Usage of Rust" +msgstr "# Funktionales Programmieren in Rust" + +#: src\functional/index.md:3 +msgid "" +"Rust is an imperative language, but it follows many\n" +"[functional programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." +msgstr "" +"Rust ist eine imperative Sprache, folgt aber vielen\n" +"Paradigmen [Funktionaler Programmiersprachen](https://en.wikipedia.org/wiki/Functional_programming)." + +#: src\functional/index.md:6 +#, fuzzy +msgid "" +"> In computer science, _functional programming_ is a programming paradigm where\n" +"> programs are constructed by applying and composing functions.\n" +"> It is a declarative programming paradigm in which function definitions are\n" +"> trees of expressions that each return a value, rather than a sequence of\n" +"> imperative statements which change the state of the program." +msgstr "" +"> In der Informatik ist _funktionale Programmierung_ ein Programmierparadigma, bei dem\n" +"> Programme werden durch Anwenden und Zusammensetzen von Funktionen erstellt.\n" +"> Es ist ein deklaratives Programmierparadigma, in dem Funktionsdefinitionen enthalten sind\n" +"> Bäume von Ausdrücken, die jeweils einen Wert zurückgeben, und nicht eine Folge von\n" +"> zwingende Anweisungen, die den Zustand des Programms ändern." + +#: src\functional/paradigms.md:1 +msgid "# Programming paradigms" +msgstr "# Programmierparadigmen" + +#: src\functional/paradigms.md:3 +msgid "" +"One of the biggest hurdles to understanding functional programs when coming\n" +"from an imperative background is the shift in thinking. Imperative programs\n" +"describe **how** to do something, whereas declarative programs describe\n" +"**what** to do. Let's sum the numbers from 1 to 10 to show this." +msgstr "" +"Wenn sie von einer imperativen Programmiersprache kommen, ist eine der größten Hürden\n" +"um funktionale Programme zu verstehen, das Umdenken. Imperative Programme\n" +"beschreiben **wie** etwas zu tun ist, wohingegen deklarative Programme beschreiben\n" +"**was** zu tun ist. Lassen Sie uns die Zahlen von 1 bis 10 summieren, um dies zu zeigen." + +#: src\functional/paradigms.md:8 +msgid "## Imperative" +msgstr "## Imperativ" + +#: src\functional/paradigms.md:10 +msgid "" +"```rust\n" +"let mut sum = 0;\n" +"for i in 1..11 {\n" +" sum += i;\n" +"}\n" +"println!(\"{}\", sum);\n" +"```" +msgstr "" + +#: src\functional/paradigms.md:18 +#, fuzzy +msgid "" +"With imperative programs, we have to play compiler to see what is happening.\n" +"Here, we start with a `sum` of `0`.\n" +"Next, we iterate through the range from 1 to 10.\n" +"Each time through the loop, we add the corresponding value in the range.\n" +"Then we print it out." +msgstr "" +"Bei imperativen Programmen müssen wir den Compiler spielen, um zu sehen, was passiert.\n" +"Hier beginnen wir mit einer „Summe“ von „0“.\n" +"Als nächstes durchlaufen wir den Bereich von 1 bis 10.\n" +"Jedes Mal, wenn wir die Schleife durchlaufen, fügen wir den entsprechenden Wert im Bereich hinzu.\n" +"Dann drucken wir es aus." + +#: src\functional/paradigms.md:24 +msgid "" +"| `i` | `sum` |\n" +"| :-: | :---: |\n" +"| 1 | 1 |\n" +"| 2 | 3 |\n" +"| 3 | 6 |\n" +"| 4 | 10 |\n" +"| 5 | 15 |\n" +"| 6 | 21 |\n" +"| 7 | 28 |\n" +"| 8 | 36 |\n" +"| 9 | 45 |\n" +"| 10 | 55 |" +msgstr "" + +#: src\functional/paradigms.md:37 +msgid "" +"This is how most of us start out programming. We learn that a program is a set\n" +"of steps." +msgstr "" +"So beginnen die meisten von uns mit dem Programmieren. Wir lernen, dass ein Programm\n" +"eine Menge von Schritten ist." + +#: src\functional/paradigms.md:40 +msgid "## Declarative" +msgstr "## Deklarativ" + +#: src\functional/paradigms.md:42 +msgid "" +"```rust\n" +"println!(\"{}\", (1..11).fold(0, |a, b| a + b));\n" +"```" +msgstr "" + +#: src\functional/paradigms.md:46 +#, fuzzy +msgid "" +"Whoa! This is really different! What's going on here?\n" +"Remember that with declarative programs we are describing **what** to do,\n" +"rather than **how** to do it. `fold` is a function that [composes](https://en.wikipedia.org/wiki/Function_composition)\n" +"functions. The name is a convention from Haskell." +msgstr "" +"Wow! Das ist wirklich anders! Was ist denn hier los?\n" +"Denken Sie daran, dass wir mit deklarativen Programmen beschreiben, **was** zu tun ist,\n" +"anstatt **wie** es zu tun. `fold` ist eine Funktion, die [zusammensetzt](https://en.wikipedia.org/wiki/Function_composition)\n" +"Funktionen. Der Name ist eine Konvention von Haskell." + +#: src\functional/paradigms.md:51 +#, fuzzy +msgid "" +"Here, we are composing functions of addition (this closure: `|a, b| a + b`)\n" +"with a range from 1 to 10. The `0` is the starting point, so `a` is `0` at\n" +"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the result.\n" +"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the next\n" +"result. This process continues until we get to the last element in the range,\n" +"`10`." +msgstr "" +"Hier bilden wir Additionsfunktionen (dieser Abschluss: `|a, b| a + b`)\n" +"mit einem Bereich von 1 bis 10. Die '0' ist der Startpunkt, also ist 'a' '0' bei\n" +"Erste. \"b\" ist das erste Element des Bereichs, \"1\". `0 + 1 = 1` ist das Ergebnis.\n" +"Jetzt `folden` wir also wieder, mit `a = 1`, `b = 2` und so kommt `1 + 2 = 3` als nächstes\n" +"Ergebnis. Dieser Vorgang wird fortgesetzt, bis wir zum letzten Element im Bereich gelangen.\n" +"\"10\"." + +#: src\functional/paradigms.md:58 +#, fuzzy +msgid "" +"| `a` | `b` | result |\n" +"| :-: | :-: | :----: |\n" +"| 0 | 1 | 1 |\n" +"| 1 | 2 | 3 |\n" +"| 3 | 3 | 6 |\n" +"| 6 | 4 | 10 |\n" +"| 10 | 5 | 15 |\n" +"| 15 | 6 | 21 |\n" +"| 21 | 7 | 28 |\n" +"| 28 | 8 | 36 |\n" +"| 36 | 9 | 45 |\n" +"| 45 | 10 | 55 |" +msgstr "" +"| \"ein\" | \"b\" | Ergebnis |\n" +"| :-: | :-: | :----: |\n" +"| 0 | 1 | 1 |\n" +"| 1 | 2 | 3 |\n" +"| 3 | 3 | 6 |\n" +"| 6 | 4 | 10 |\n" +"| 10 | 5 | 15 |\n" +"| 15 | 6 | 21 |\n" +"| 21 | 7 | 28 |\n" +"| 28 | 8 | 36 |\n" +"| 36 | 9 | 45 |\n" +"| 45 | 10 | 55 |" + +#: src\functional/generics-type-classes.md:1 +#, fuzzy +msgid "# Generics as Type Classes" +msgstr "# Generika als Typklassen" + +#: src\functional/generics-type-classes.md:5 +#, fuzzy +msgid "" +"Rust's type system is designed more like functional languages (like Haskell)\n" +"rather than imperative languages (like Java and C++). As a result, Rust can turn\n" +"many kinds of programming problems into \"static typing\" problems. This is one\n" +"of the biggest wins of choosing a functional language, and is critical to many\n" +"of Rust's compile time guarantees." +msgstr "" +"Das Typsystem von Rust ist eher wie funktionale Sprachen (wie Haskell) konzipiert\n" +"eher als imperative Sprachen (wie Java und C++). Dadurch kann sich Rust drehen\n" +"viele Arten von Programmierproblemen in \"statische Typisierungsprobleme\" umwandeln. Dies ist einer\n" +"einer der größten Gewinne bei der Auswahl einer funktionalen Sprache und für viele von entscheidender Bedeutung\n" +"der Kompilierzeitgarantien von Rust." + +#: src\functional/generics-type-classes.md:11 +msgid "" +"A key part of this idea is the way generic types work. In C++ and Java, for\n" +"example, generic types are a meta-programming construct for the compiler.\n" +"`vector` and `vector` in C++ are just two different copies of the\n" +"same boilerplate code for a `vector` type (known as a `template`) with two\n" +"different types filled in." +msgstr "" +"Ein wichtiger Teil dieser Idee ist die Funktionsweise generischer Typen. In C++ und Java\n" +"sind generische Typen ein Metaprogrammierungskonstrukt für den Compiler.\n" +"`vector` und `vector` in C++ sind nur zwei verschiedene Kopien des\n" +"gleichen Textbaustein-Codes für einen `vector`-Typ (bekannt als `template`) mit zwei\n" +"verschiedenen Typen ausgefüllt." + +#: src\functional/generics-type-classes.md:17 +#, fuzzy +msgid "" +"In Rust, a generic type parameter creates what is known in functional languages\n" +"as a \"type class constraint\", and each different parameter filled in by an end\n" +"user _actually changes the type_. In other words, `Vec` and `Vec`\n" +"_are two different types_, which are recognized as distinct by all parts of the\n" +"type system." +msgstr "" +"In Rust erzeugt ein generischer Typparameter das, was in funktionalen Sprachen bekannt ist\n" +"als \"Typklasseneinschränkung\" und jeder unterschiedliche Parameter wird durch ein Ende ausgefüllt\n" +"Benutzer _ändert tatsächlich den Typ_. Mit anderen Worten, `Vec` und `Vec`\n" +"_sind zwei verschiedene Typen_, die von allen Teilen des als verschieden erkannt werden\n" +"Typ System." + +#: src\functional/generics-type-classes.md:23 +msgid "" +"This is called **monomorphization**, where different types are created from\n" +"**polymorphic** code. This special behavior requires `impl` blocks to specify\n" +"generic parameters. Different values for the generic type cause different types,\n" +"and different types can have different `impl` blocks." +msgstr "" +"Dies wird **Monomorphisierung** genannt, wobei verschiedene Typen von **polymorphem**\n" +"Code erstellt werden. Dieses spezielle Verhalten erfordert die Angabe von generischen Parametern\n" +"in `impl`-Blöcken.\n" +"Unterschiedliche Werte für den generischen Typ bewirken unterschiedliche Typen,\n" +"und unterschiedliche Typen können unterschiedliche `impl`-Blöcke haben." + +#: src\functional/generics-type-classes.md:28 +#, fuzzy +msgid "" +"In object-oriented languages, classes can inherit behavior from their parents.\n" +"However, this allows the attachment of not only additional behavior to\n" +"particular members of a type class, but extra behavior as well." +msgstr "" +"In objektorientierten Sprachen können Klassen Verhalten von ihren Eltern erben.\n" +"Dies lässt jedoch das Anbringen von nicht nur zusätzlichem Verhalten zu\n" +"bestimmte Mitglieder einer Typklasse, aber auch zusätzliches Verhalten." + +#: src\functional/generics-type-classes.md:32 +#, fuzzy +msgid "" +"The nearest equivalent is the runtime polymorphism in Javascript and Python,\n" +"where new members can be added to objects willy-nilly by any constructor.\n" +"However, unlike those languages, all of Rust's additional methods can be type\n" +"checked when they are used, because their generics are statically defined. That\n" +"makes them more usable while remaining safe." +msgstr "" +"Das nächste Äquivalent ist der Laufzeitpolymorphismus in Javascript und Python,\n" +"wo neue Member willkürlich von jedem Konstruktor zu Objekten hinzugefügt werden können.\n" +"Im Gegensatz zu diesen Sprachen können jedoch alle zusätzlichen Methoden von Rust typisiert werden\n" +"bei ihrer Verwendung überprüft, da ihre Generika statisch definiert sind. Das\n" +"macht sie benutzerfreundlicher und bleibt gleichzeitig sicher." + +#: src\functional/generics-type-classes.md:40 +#, fuzzy +msgid "" +"Suppose you are designing a storage server for a series of lab machines.\n" +"Because of the software involved, there are two different protocols you need\n" +"to support: BOOTP (for PXE network boot), and NFS (for remote mount storage)." +msgstr "" +"Angenommen, Sie entwerfen einen Speicherserver für eine Reihe von Labormaschinen.\n" +"Aufgrund der verwendeten Software benötigen Sie zwei verschiedene Protokolle\n" +"Unterstützung: BOOTP (für PXE-Netzwerkstart) und NFS (für Remote-Mount-Speicher)." + +#: src\functional/generics-type-classes.md:44 +#, fuzzy +msgid "" +"Your goal is to have one program, written in Rust, which can handle both of\n" +"them. It will have protocol handlers and listen for both kinds of requests. The\n" +"main application logic will then allow a lab administrator to configure storage\n" +"and security controls for the actual files." +msgstr "" +"Ihr Ziel ist es, ein in Rust geschriebenes Programm zu haben, das beides verarbeiten kann\n" +"ihnen. Es wird Protokoll-Handler haben und auf beide Arten von Anfragen lauschen. Der\n" +"Die Hauptanwendungslogik ermöglicht es dann einem Lab-Administrator, den Speicher zu konfigurieren\n" +"und Sicherheitskontrollen für die eigentlichen Dateien." + +#: src\functional/generics-type-classes.md:49 +#, fuzzy +msgid "" +"The requests from machines in the lab for files contain the same basic\n" +"information, no matter what protocol they came from: an authentication method,\n" +"and a file name to retrieve. A straightforward implementation would look\n" +"something like this:" +msgstr "" +"Die Anfragen von Computern im Labor nach Dateien enthalten die gleichen grundlegenden\n" +"Informationen, egal aus welchem Protokoll sie stammen: eine Authentifizierungsmethode,\n" +"und einen abzurufenden Dateinamen. Eine einfache Implementierung würde aussehen\n" +"etwas wie das:" + +#: src\functional/generics-type-classes.md:54 +msgid "" +"```rust,ignore\n" +"enum AuthInfo {\n" +" Nfs(crate::nfs::AuthInfo),\n" +" Bootp(crate::bootp::AuthInfo),\n" +"}\n" +"\n" +"struct FileDownloadRequest {\n" +" file_name: PathBuf,\n" +" authentication: AuthInfo,\n" +"}\n" +"```" +msgstr "" + +#: src\functional/generics-type-classes.md:66 +#, fuzzy +msgid "" +"This design might work well enough. But now suppose you needed to support\n" +"adding metadata that was _protocol specific_. For example, with NFS, you\n" +"wanted to determine what their mount point was in order to enforce additional\n" +"security rules." +msgstr "" +"Dieses Design könnte gut genug funktionieren. Aber nehmen Sie jetzt an, Sie müssten unterstützen\n" +"Hinzufügen von Metadaten, die _protokollspezifisch_ waren. Mit NFS zum Beispiel Sie\n" +"wollte feststellen, was ihr Einhängepunkt war, um zusätzliche zu erzwingen\n" +"Sicherheitsregeln." + +#: src\functional/generics-type-classes.md:71 +#, fuzzy +msgid "" +"The way the current struct is designed leaves the protocol decision until\n" +"runtime. That means any method that applies to one protocol and not the other\n" +"requires the programmer to do a runtime check." +msgstr "" +"Die Art und Weise, wie die aktuelle Struktur entworfen ist, überlässt die Protokollentscheidung bis\n" +"Laufzeit. Das bedeutet jede Methode, die für ein Protokoll gilt und nicht für das andere\n" +"erfordert vom Programmierer eine Laufzeitprüfung." + +#: src\functional/generics-type-classes.md:75 +#, fuzzy +msgid "Here is how getting an NFS mount point would look:" +msgstr "So würde das Abrufen eines NFS-Mount-Punkts aussehen:" + +#: src\functional/generics-type-classes.md:77 +msgid "" +"```rust,ignore\n" +"struct FileDownloadRequest {\n" +" file_name: PathBuf,\n" +" authentication: AuthInfo,\n" +" mount_point: Option,\n" +"}\n" +"\n" +"impl FileDownloadRequest {\n" +" // ... other methods ...\n" +"\n" +" /// Gets an NFS mount point if this is an NFS request. Otherwise,\n" +" /// return None.\n" +" pub fn mount_point(&self) -> Option<&Path> {\n" +" self.mount_point.as_ref()\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\functional/generics-type-classes.md:95 +#, fuzzy +msgid "" +"Every caller of `mount_point()` must check for `None` and write code to handle\n" +"it. This is true even if they know only NFS requests are ever used in a given\n" +"code path!" +msgstr "" +"Jeder Aufrufer von `mount_point()` muss auf `None` prüfen und den zu handhabenden Code schreiben\n" +"Es. Dies gilt auch dann, wenn sie wissen, dass nur NFS-Anforderungen jemals in einem gegebenen Fall verwendet werden\n" +"Codepfad!" + +#: src\functional/generics-type-classes.md:99 +#, fuzzy +msgid "" +"It would be far more optimal to cause a compile-time error if the different\n" +"request types were confused. After all, the entire path of the user's code,\n" +"including what functions from the library they use, will know whether a request\n" +"is an NFS request or a BOOTP request." +msgstr "" +"Es wäre weitaus optimaler, einen Kompilierzeitfehler zu verursachen, wenn dies anders wäre\n" +"Anfragetypen wurden verwechselt. Schließlich ist der gesamte Pfad des Codes des Benutzers,\n" +"ua welche Funktionen aus der Bibliothek sie nutzen, ob eine Anfrage bekannt ist\n" +"ist eine NFS-Anforderung oder eine BOOTP-Anforderung." + +#: src\functional/generics-type-classes.md:104 +#, fuzzy +msgid "" +"In Rust, this is actually possible! The solution is to _add a generic type_ in\n" +"order to split the API." +msgstr "" +"In Rust ist das tatsächlich möglich! Die Lösung besteht darin, _einen generischen Typ hinzuzufügen_\n" +"um die API aufzuteilen." + +#: src\functional/generics-type-classes.md:107 +msgid "Here is what that looks like:" +msgstr "So sieht das aus:" + +#: src\functional/generics-type-classes.md:109 +msgid "" +"```rust\n" +"use std::path::{Path, PathBuf};\n" +"\n" +"mod nfs {\n" +" #[derive(Clone)]\n" +" pub(crate) struct AuthInfo(String); // NFS session management omitted\n" +"}\n" +"\n" +"mod bootp {\n" +" pub(crate) struct AuthInfo(); // no authentication in bootp\n" +"}\n" +"\n" +"// private module, lest outside users invent their own protocol kinds!\n" +"mod proto_trait {\n" +" use std::path::{Path, PathBuf};\n" +" use super::{bootp, nfs};\n" +"\n" +" pub(crate) trait ProtoKind {\n" +" type AuthInfo;\n" +" fn auth_info(&self) -> Self::AuthInfo;\n" +" }\n" +"\n" +" pub struct Nfs {\n" +" auth: nfs::AuthInfo,\n" +" mount_point: PathBuf,\n" +" }\n" +"\n" +" impl Nfs {\n" +" pub(crate) fn mount_point(&self) -> &Path {\n" +" &self.mount_point\n" +" }\n" +" }\n" +"\n" +" impl ProtoKind for Nfs {\n" +" type AuthInfo = nfs::AuthInfo;\n" +" fn auth_info(&self) -> Self::AuthInfo {\n" +" self.auth.clone()\n" +" }\n" +" }\n" +"\n" +" pub struct Bootp(); // no additional metadata\n" +"\n" +" impl ProtoKind for Bootp {\n" +" type AuthInfo = bootp::AuthInfo;\n" +" fn auth_info(&self) -> Self::AuthInfo {\n" +" bootp::AuthInfo()\n" +" }\n" +" }\n" +"}\n" +"\n" +"use proto_trait::ProtoKind; // keep internal to prevent impls\n" +"pub use proto_trait::{Nfs, Bootp}; // re-export so callers can see them\n" +"\n" +"struct FileDownloadRequest {\n" +" file_name: PathBuf,\n" +" protocol: P,\n" +"}\n" +"\n" +"// all common API parts go into a generic impl block\n" +"impl FileDownloadRequest

{\n" +" fn file_path(&self) -> &Path {\n" +" &self.file_name\n" +" }\n" +"\n" +" fn auth_info(&self) -> P::AuthInfo {\n" +" self.protocol.auth_info()\n" +" }\n" +"}\n" +"\n" +"// all protocol-specific impls go into their own block\n" +"impl FileDownloadRequest {\n" +" fn mount_point(&self) -> &Path {\n" +" self.protocol.mount_point()\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" // your code here\n" +"}\n" +"```" +msgstr "" + +#: src\functional/generics-type-classes.md:190 +msgid "" +"With this approach, if the user were to make a mistake and use the wrong\n" +"type;" +msgstr "" + +#: src\functional/generics-type-classes.md:193 +msgid "" +"```rust,ignore\n" +"fn main() {\n" +" let mut socket = crate::bootp::listen()?;\n" +" while let Some(request) = socket.next_request()? {\n" +" match request.mount_point().as_ref()\n" +" \"/secure\" => socket.send(\"Access denied\"),\n" +" _ => {} // continue on...\n" +" }\n" +" // Rest of the code here\n" +" }\n" +"}\n" +"```" +msgstr "" + +#: src\functional/generics-type-classes.md:206 +#, fuzzy +msgid "" +"They would get a syntax error. The type `FileDownloadRequest` does not\n" +"implement `mount_point()`, only the type `FileDownloadRequest` does. And\n" +"that is created by the NFS module, not the BOOTP module of course!" +msgstr "" +"Sie würden einen Syntaxfehler erhalten. Der Typ `FileDownloadRequest` tut dies nicht\n" +"implementieren `mount_point()`, nur der Typ `FileDownloadRequest` tut dies. Und\n" +"das vom NFS-Modul erstellt wird, natürlich nicht vom BOOTP-Modul!" + +#: src\functional/generics-type-classes.md:212 +#, fuzzy +msgid "" +"First, it allows fields that are common to multiple states to be de-duplicated.\n" +"By making the non-shared fields generic, they are implemented once." +msgstr "" +"Erstens können Felder, die mehreren Zuständen gemeinsam sind, dedupliziert werden.\n" +"Indem die nicht gemeinsam genutzten Felder generisch gemacht werden, werden sie einmal implementiert." + +#: src\functional/generics-type-classes.md:215 +#, fuzzy +msgid "" +"Second, it makes the `impl` blocks easier to read, because they are broken down\n" +"by state. Methods common to all states are typed once in one block, and methods\n" +"unique to one state are in a separate block." +msgstr "" +"Zweitens macht es die \"impl\"-Blöcke leichter lesbar, weil sie aufgeschlüsselt sind\n" +"nach Bundesland. Methoden, die allen Zuständen gemeinsam sind, werden einmal in einem Block eingegeben, und Methoden\n" +"eindeutig für einen Zustand sind in einem separaten Block." + +#: src\functional/generics-type-classes.md:219 +#, fuzzy +msgid "Both of these mean there are fewer lines of code, and they are better organized." +msgstr "Beides bedeutet, dass es weniger Codezeilen gibt und sie besser organisiert sind." + +#: src\functional/generics-type-classes.md:223 +#, fuzzy +msgid "" +"This currently increases the size of the binary, due to the way monomorphization\n" +"is implemented in the compiler. Hopefully the implementation will be able to\n" +"improve in the future." +msgstr "" +"Dies erhöht derzeit die Größe der Binärdatei aufgrund der Art und Weise der Monomorphisierung\n" +"ist im Compiler implementiert. Hoffentlich wird die Umsetzung dazu in der Lage sein\n" +"in Zukunft verbessern." + +#: src\functional/generics-type-classes.md:229 +#, fuzzy +msgid "" +"- If a type seems to need a \"split API\" due to construction or partial\n" +" initialization, consider the\n" +" [Builder Pattern](../patterns/creational/builder.md) instead.\n" +"\n" +"- If the API between types does not change -- only the behavior does -- then\n" +" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better used\n" +" instead." +msgstr "" +"- Wenn ein Typ konstruktionsbedingt oder partiell eine \"geteilte API\" zu benötigen scheint\n" +" Initialisierung, betrachten Sie die\n" +" [Builder Pattern](../patterns/creational/builder.md) stattdessen.\n" +"\n" +"- Wenn sich die API zwischen den Typen nicht ändert – nur das Verhalten – dann\n" +" das [Strategy Pattern](../patterns/behavioural/strategy.md) wird besser verwendet\n" +" stattdessen." + +#: src\functional/generics-type-classes.md:239 +msgid "This pattern is used throughout the standard library:" +msgstr "Dieses Muster wird in der gesamten Standardbibliothek verwendet:" + +#: src\functional/generics-type-classes.md:241 +#, fuzzy +msgid "" +"- `Vec` can be cast from a String, unlike every other type of `Vec`.[^1]\n" +"- They can also be cast into a binary heap, but only if they contain a type\n" +" that implements the `Ord` trait.[^2]\n" +"- The `to_string` method was specialized for `Cow` only of type `str`.[^3]" +msgstr "" +"- `Vec` kann im Gegensatz zu jedem anderen Typ von `Vec` aus einem String gecastet werden.[^1]\n" +"- Sie können auch in einen binären Heap gecastet werden, aber nur, wenn sie einen Typ enthalten\n" +" die das `Ord`-Merkmal implementiert.[^2]\n" +"- Die Methode `to_string` wurde nur auf `Cow` vom Typ `str` spezialisiert.[^3]" + +#: src\functional/generics-type-classes.md:246 +#, fuzzy +msgid "It is also used by several popular crates to allow API flexibility:" +msgstr "Es wird auch von mehreren beliebten Crates verwendet, um API-Flexibilität zu ermöglichen:" + +#: src\functional/generics-type-classes.md:248 +#, fuzzy +msgid "" +"- The `embedded-hal` ecosystem used for embedded devices makes extensive use of\n" +" this pattern. For example, it allows statically verifying the configuration of\n" +" device registers used to control embedded pins. When a pin is put into a mode,\n" +" it returns a `Pin` struct, whose generic determines the functions\n" +" usable in that mode, which are not on the `Pin` itself. [^4]\n" +"\n" +"- The `hyper` HTTP client library uses this to expose rich APIs for different\n" +" pluggable requests. Clients with different connectors have different methods\n" +" on them as well as different trait implementations, while a core set of\n" +" methods apply to any connector. [^5]\n" +"\n" +"- The \"type state\" pattern -- where an object gains and loses API based on an\n" +" internal state or invariant -- is implemented in Rust using the same basic\n" +" concept, and a slightly different technique. [^6]" +msgstr "" +"- Das für eingebettete Geräte verwendete „Embedded-Hal“-Ökosystem macht ausgiebigen Gebrauch\n" +" dieses Muster. Beispielsweise ermöglicht es die statische Überprüfung der Konfiguration von\n" +" Geräteregister zur Steuerung eingebetteter Pins. Wenn ein Pin in einen Modus versetzt wird,\n" +" es gibt eine `Pin`-Struktur zurück, deren Generika die Funktionen bestimmt\n" +" in diesem Modus nutzbar, die nicht auf dem `Pin` selbst liegen. [^4]\n" +"\n" +"- Die \"Hyper\"-HTTP-Client-Bibliothek verwendet dies, um reichhaltige APIs für verschiedene verfügbar zu machen\n" +" austauschbare Anfragen. Clients mit unterschiedlichen Konnektoren haben unterschiedliche Methoden\n" +" auf ihnen sowie verschiedene Trait-Implementierungen, während ein Kernsatz von\n" +" Methoden gelten für jeden Connector. [^5]\n" +"\n" +"- Das \"Type State\"-Muster -- wo ein Objekt API basierend auf einem gewinnt oder verliert\n" +" interner Zustand oder Invariante -- wird in Rust auf der gleichen Basis implementiert\n" +" Konzept und eine etwas andere Technik. [^6]" + +#: src\functional/generics-type-classes.md:263 +#, fuzzy +msgid "See: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" +msgstr "Siehe: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 )" + +#: src\functional/generics-type-classes.md:265 +#, fuzzy +msgid "" +"See: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/binary_heap." +"rs.html#1345-1354)" +msgstr "" +"Siehe: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections /" +"binary_heap.rs.html#1345-1354)" + +#: src\functional/generics-type-classes.md:267 +#, fuzzy +msgid "See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" +msgstr "Siehe: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" + +#: src\functional/generics-type-classes.md:269 +#, fuzzy +msgid "" +"Example:\n" +"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/" +"gpioa/struct.PA0.html)" +msgstr "" +"Beispiel:\n" +"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/ " +"gpioa/struct.PA0.html)" + +#: src\functional/generics-type-classes.md:272 +#, fuzzy +msgid "" +"See:\n" +"[https://docs.rs/hyper/0.14.5/hyper/client/struct.Client.html](https://docs.rs/hyper/0.14.5/hyper/client/struct.Client.html)" +msgstr "" +"Sehen:\n" +"[https://docs.rs/hyper/0.14.5/hyper/client/struct.Client.html](https://docs.rs/hyper/0.14.5/hyper/client/struct.Client.html)" + +#: src\functional/generics-type-classes.md:275 +#, fuzzy +msgid "" +"See:\n" +"[The Case for the Type State Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-" +"typestate-pattern-the-typestate-pattern-itself/)\n" +"and\n" +"[Rusty Typestate Series (an extensive thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index)" +msgstr "" +"Sehen:\n" +"[Der Fall für das Typzustandsmuster](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/de/blog/der-fall-fur-den-" +"typzustand- Muster-der-Typzustand-Muster-selbst/)\n" +"Und\n" +"[Rusty Typestate Series (eine umfangreiche Dissertation)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/" +"rust-typestate-series/rust-typestate-index )" + +#: src\functional/lenses.md:1 +msgid "# Lenses and Prisms" +msgstr "# Linsen und Prismen" + +#: src\functional/lenses.md:3 +#, fuzzy +msgid "" +"This is a pure functional concept that is not frequently used in Rust.\n" +"Nevertheless, exploring the concept may be helpful to understand other\n" +"patterns in Rust APIs, such as [visitors](../patterns/behavioural/visitor.md).\n" +"They also have niche use cases." +msgstr "" +"Dies ist ein rein funktionales Konzept, das in Rust nicht häufig verwendet wird.\n" +"Dennoch kann die Erforschung des Konzepts hilfreich sein, um andere zu verstehen\n" +"Muster in Rust-APIs, wie [Besucher](../patterns/behavioural/visitor.md).\n" +"Sie haben auch Nischenanwendungsfälle." + +#: src\functional/lenses.md:8 +msgid "## Lenses: Uniform Access Across Types" +msgstr "## Linsen: Einheitlicher Zugriff auf alle Typen" + +#: src\functional/lenses.md:10 +#, fuzzy +msgid "" +"A lens is a concept from functional programming languages that allows\n" +"accessing parts of a data type in an abstract, unified way.[^1]\n" +"In basic concept, it is similar to the way Rust traits work with type erasure,\n" +"but it has a bit more power and flexibility." +msgstr "" +"Eine Linse ist ein Konzept aus funktionalen Programmiersprachen, das es ermöglicht\n" +"abstrakter, einheitlicher Zugriff auf Teile eines Datentyps.[^1]\n" +"Im Grundkonzept ähnelt es der Art und Weise, wie Rust-Eigenschaften mit Typlöschung arbeiten,\n" +"aber es hat ein bisschen mehr Kraft und Flexibilität." + +#: src\functional/lenses.md:15 +#, fuzzy +msgid "" +"For example, suppose a bank contains several JSON formats for customer\n" +"data.\n" +"This is because they come from different databases or legacy systems.\n" +"One database contains the data needed to perform credit checks:" +msgstr "" +"Angenommen, eine Bank enthält mehrere JSON-Formate für Kunden\n" +"Daten.\n" +"Dies liegt daran, dass sie aus verschiedenen Datenbanken oder Altsystemen stammen.\n" +"Eine Datenbank enthält die Daten, die für die Durchführung von Bonitätsprüfungen benötigt werden:" + +#: src\functional/lenses.md:20 +msgid "" +"```json\n" +"{ \"name\": \"Jane Doe\",\n" +" \"dob\": \"2002-02-24\",\n" +" [...]\n" +" \"customer_id\": 1048576332,\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:28 +msgid "Another one contains the account information:" +msgstr "Eine andere enthält die Kontoinformationen:" + +#: src\functional/lenses.md:30 +msgid "" +"```json\n" +"{ \"customer_id\": 1048576332,\n" +" \"accounts\": [\n" +" { \"account_id\": 2121,\n" +" \"account_type: \"savings\",\n" +" \"joint_customer_ids\": [],\n" +" [...]\n" +" },\n" +" { \"account_id\": 2122,\n" +" \"account_type: \"checking\",\n" +" \"joint_customer_ids\": [1048576333],\n" +" [...]\n" +" },\n" +" ]\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:47 +msgid "" +"Notice that both types have a customer ID number which corresponds to a person.\n" +"How would a single function handle both records of different types?" +msgstr "" +"Beachten Sie, dass beide Typen eine Kunden-ID-Nummer haben, die einer Person entspricht.\n" +"Wie würde eine einzelne Funktion beide Datensätze unterschiedlichen Typs behandeln?" + +#: src\functional/lenses.md:50 +msgid "" +"In Rust, a `struct` could represent each of these types, and a trait would have\n" +"a `get_customer_id` function they would implement:" +msgstr "" +"In Rust könnte ein `struct` jeden dieser Typen repräsentieren und ein Merkmal\n" +"hätte eine `get_customer_id`-Funktion, die diese implementieren würden:" + +#: src\functional/lenses.md:53 +msgid "" +"```rust\n" +"use std::collections::HashSet;\n" +"\n" +"pub struct Account {\n" +" account_id: u32,\n" +" account_type: String,\n" +" // other fields omitted\n" +"}\n" +"\n" +"pub trait CustomerId {\n" +" fn get_customer_id(&self) -> u64;\n" +"}\n" +"\n" +"pub struct CreditRecord {\n" +" customer_id: u64,\n" +" name: String,\n" +" dob: String,\n" +" // other fields omitted\n" +"}\n" +"\n" +"impl CustomerId for CreditRecord {\n" +" fn get_customer_id(&self) -> u64 {\n" +" self.customer_id\n" +" }\n" +"}\n" +"\n" +"pub struct AccountRecord {\n" +" customer_id: u64,\n" +" accounts: Vec,\n" +"}\n" +"\n" +"impl CustomerId for AccountRecord {\n" +" fn get_customer_id(&self) -> u64 {\n" +" self.customer_id\n" +" }\n" +"}\n" +"\n" +"// static polymorphism: only one type, but each function call can choose it\n" +"fn unique_ids_set(records: &[R]) -> HashSet {\n" +" records.iter().map(|r| r.get_customer_id()).collect()\n" +"}\n" +"\n" +"// dynamic dispatch: iterates over any type with a customer ID, collecting all\n" +"// values together\n" +"fn unique_ids_iter(iterator: I) -> HashSet\n" +" where I: Iterator>\n" +"{\n" +" iterator.map(|r| r.as_ref().get_customer_id()).collect()\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:104 +#, fuzzy +msgid "" +"Lenses, however, allow the code supporting customer ID to be moved from the\n" +"_type_ to the _accessor function_.\n" +"Rather than implementing a trait on each type, all matching structures can\n" +"simply be accessed the same way." +msgstr "" +"Objektive ermöglichen jedoch, dass der Code, der die Kunden-ID unterstützt, von verschoben wird\n" +"_type_ zur _accessor function_.\n" +"Anstatt für jeden Typ eine Eigenschaft zu implementieren, können alle übereinstimmenden Strukturen dies tun\n" +"einfach auf die gleiche Weise aufgerufen werden." + +#: src\functional/lenses.md:109 +#, fuzzy +msgid "" +"While the Rust language itself does not support this (type erasure is the\n" +"preferred solution to this problem), the [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows code\n" +"that feels like this to be written with macros:" +msgstr "" +"Während die Rust-Sprache selbst dies nicht unterstützt (Typlöschung ist die\n" +"bevorzugte Lösung für dieses Problem), lässt die [lens-rs-Kiste](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) Code zu\n" +"das fühlt sich so an, mit Makros geschrieben zu werden:" + +#: src\functional/lenses.md:113 +msgid "" +"```rust,ignore\n" +"use std::collections::HashSet;\n" +"\n" +"use lens_rs::{optics, Lens, LensRef, Optics};\n" +"\n" +"#[derive(Clone, Debug, Lens /* derive to allow lenses to work */)]\n" +"pub struct CreditRecord {\n" +" #[optic(ref)] // macro attribute to allow viewing this field\n" +" customer_id: u64,\n" +" name: String,\n" +" dob: String,\n" +" // other fields omitted\n" +"}\n" +"\n" +"#[derive(Clone, Debug)]\n" +"pub struct Account {\n" +" account_id: u32,\n" +" account_type: String,\n" +" // other fields omitted\n" +"}\n" +"\n" +"#[derive(Clone, Debug, Lens)]\n" +"pub struct AccountRecord {\n" +" #[optic(ref)]\n" +" customer_id: u64,\n" +" accounts: Vec,\n" +"}\n" +"\n" +"fn unique_ids_lens(iter: impl Iterator) -> HashSet\n" +"where\n" +" T: LensRef, // any type with this field\n" +"{\n" +" iter.map(|r| *r.view_ref(optics!(customer_id))).collect()\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:149 +#, fuzzy +msgid "" +"The version of `unique_ids_lens` shown here allows any type to be in the iterator,\n" +"so long as it has an attribute called `customer_id` which can be accessed by\n" +"the function.\n" +"This is how most functional programming languages operate on lenses." +msgstr "" +"Die hier gezeigte Version von `unique_ids_lens` lässt jeden Typ im Iterator zu,\n" +"solange es ein Attribut namens \"customer_id\" hat, auf das zugegriffen werden kann\n" +"die Funktion.\n" +"So arbeiten die meisten funktionalen Programmiersprachen mit Linsen." + +#: src\functional/lenses.md:154 +#, fuzzy +msgid "" +"Rather than macros, they achieve this with a technique known as \"currying\".\n" +"That is, they \"partially construct\" the function, leaving the type of the\n" +"final parameter (the value being operated on) unfilled until the function is\n" +"called.\n" +"Thus it can be called with different types dynamically even from one place in\n" +"the code.\n" +"That is what the `optics!` and `view_ref` in the example above simulates." +msgstr "" +"Anstelle von Makros erreichen sie dies mit einer Technik, die als \"Currying\" bekannt ist.\n" +"Das heißt, sie \"konstruieren teilweise\" die Funktion und lassen den Typ der\n" +"letzter Parameter (der Wert, auf dem operiert wird) ungefüllt, bis die Funktion ausgeführt wird\n" +"genannt.\n" +"Dadurch kann es dynamisch sogar von einer Stelle aus mit unterschiedlichen Typen aufgerufen werden\n" +"der Code.\n" +"Das ist es, was `optics!` und `view_ref` im obigen Beispiel simulieren." + +#: src\functional/lenses.md:162 +msgid "" +"The functional approach need not be restricted to accessing members.\n" +"More powerful lenses can be created which both _set_ and _get_ data in a\n" +"structure.\n" +"But the concept really becomes interesting when used as a building block for\n" +"composition.\n" +"That is where the concept appears more clearly in Rust." +msgstr "" +"Der funktionale Ansatz muss nicht auf den Zugriff auf Mitglieder beschränkt sein.\n" +"Es können leistungsstärkere Linsen erstellt werden, die sowohl Daten in einer Struktur\n" +"_setzen_ als auch aus ihr _herausholen_.\n" +"Aber das Konzept wird wirklich interessant, wenn es als Baustein für Komposition\n" +"verwendet wird.\n" +"Hier zeigt sich das Konzept von Rust deutlicher." + +#: src\functional/lenses.md:169 +msgid "## Prisms: A Higher-Order form of \"Optics\"" +msgstr "## Prismen: Eine Form der \"Optik\" höherer Ordnung" + +#: src\functional/lenses.md:171 +#, fuzzy +msgid "" +"A simple function such as `unique_ids_lens` above operates on a single lens.\n" +"A _prism_ is a function that operates on a _family_ of lenses.\n" +"It is one conceptual level higher, using lenses as a building block, and\n" +"continuing the metaphor, is part of a family of \"optics\".\n" +"It is the main one that is useful in understanding Rust APIs, so will be the\n" +"focus here." +msgstr "" +"Eine einfache Funktion wie `unique_ids_lens` oben arbeitet mit einem einzelnen Objektiv.\n" +"Ein _Prisma_ ist eine Funktion, die auf eine _Familie_ von Linsen wirkt.\n" +"Es ist eine konzeptionelle Ebene höher und verwendet Linsen als Baustein\n" +"um die Metapher fortzusetzen, ist Teil einer Familie von \"Optiken\".\n" +"Es ist das wichtigste, das für das Verständnis von Rust-APIs nützlich ist, ebenso wie die\n" +"Fokus hier." + +#: src\functional/lenses.md:178 +#, fuzzy +msgid "" +"The same way that traits allow \"lens-like\" design with static polymorphism and\n" +"dynamic dispatch, prism-like designs appear in Rust APIs which split problems\n" +"into multiple associated types to be composed.\n" +"A good example of this is the traits in the parsing crate _Serde_." +msgstr "" +"Auf die gleiche Weise ermöglichen Traits ein \"linsenähnliches\" Design mit statischem Polymorphismus und\n" +"dynamischer Versand, prismenartige Designs erscheinen in Rust-APIs, die Probleme aufteilen\n" +"in mehrere zusammengehörige Typen zusammengestellt werden.\n" +"Ein gutes Beispiel dafür sind die Traits in der Parsing-Kiste _Serde_." + +#: src\functional/lenses.md:183 +#, fuzzy +msgid "" +"Trying to understand the way _Serde_ works by only reading the API is a\n" +"challenge, especially the first time.\n" +"Consider the `Deserializer` trait, implemented by some type in any library\n" +"which parses a new format:" +msgstr "" +"Zu versuchen, die Funktionsweise von _Serde_ zu verstehen, indem man nur die API liest, ist a\n" +"Herausforderung, vor allem beim ersten Mal.\n" +"Betrachten Sie die Eigenschaft `Deserializer`, die von irgendeinem Typ in jeder Bibliothek implementiert wird\n" +"die ein neues Format analysiert:" + +#: src\functional/lenses.md:188 +msgid "" +"```rust,ignore\n" +"pub trait Deserializer<'de>: Sized {\n" +" type Error: Error;\n" +"\n" +" fn deserialize_any(self, visitor: V) -> Result\n" +" where\n" +" V: Visitor<'de>;\n" +"\n" +" fn deserialize_bool(self, visitor: V) -> Result\n" +" where\n" +" V: Visitor<'de>;\n" +"\n" +" // remainder ommitted\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:204 +#, fuzzy +msgid "" +"For a trait that is just supposed to parse data from a format and return a\n" +"value, this looks odd." +msgstr "" +"Für eine Eigenschaft, die nur Daten aus einem Format parsen und a zurückgeben soll\n" +"Wert, das sieht seltsam aus." + +#: src\functional/lenses.md:207 +#, fuzzy +msgid "Why are all the return types type erased?" +msgstr "Warum werden alle Rückgabetypen gelöscht?" + +#: src\functional/lenses.md:209 +#, fuzzy +msgid "" +"To understand that, we need to keep the lens concept in mind and look at\n" +"the definition of the `Visitor` type that is passed in generically:" +msgstr "" +"Um das zu verstehen, müssen wir das Linsenkonzept im Auge behalten und betrachten\n" +"die generisch übergebene Definition des Typs `Visitor`:" + +#: src\functional/lenses.md:212 +msgid "" +"```rust,ignore\n" +"pub trait Visitor<'de>: Sized {\n" +" type Value;\n" +"\n" +" fn visit_bool(self, v: bool) -> Result\n" +" where\n" +" E: Error;\n" +"\n" +" fn visit_u64(self, v: u64) -> Result\n" +" where\n" +" E: Error;\n" +"\n" +" fn visit_str(self, v: &str) -> Result\n" +" where\n" +" E: Error;\n" +"\n" +" // remainder omitted\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:232 +#, fuzzy +msgid "" +"The job of the `Visitor` type is to construct values in the _Serde_ data model,\n" +"which are represented by its associated `Value` type." +msgstr "" +"Die Aufgabe des Typs „Visitor“ besteht darin, Werte im _Serde_-Datenmodell zu konstruieren,\n" +"die durch den zugehörigen Typ \"Wert\" dargestellt werden." + +#: src\functional/lenses.md:235 +#, fuzzy +msgid "" +"These values represent parts of the Rust value being deserialized.\n" +"If this fails, it returns an `Error` type - an error type determined by the\n" +"`Deserializer` when its methods were called." +msgstr "" +"Diese Werte stellen Teile des Rust-Werts dar, der deserialisiert wird.\n" +"Wenn dies fehlschlägt, gibt es einen „Error“-Typ zurück – einen Fehlertyp, der durch die bestimmt wird\n" +"`Deserializer`, wenn seine Methoden aufgerufen wurden." + +#: src\functional/lenses.md:239 +#, fuzzy +msgid "" +"This highlights that `Deserializer` is similar to `CustomerId` from earlier,\n" +"allowing any format parser which implements it to create `Value`s based on what\n" +"it parsed.\n" +"The `Value` trait is acting like a lens in functional programming languages." +msgstr "" +"Dies unterstreicht, dass \"Deserializer\" ähnlich wie \"CustomerId\" von früher ist,\n" +"jedem Formatparser, der es implementiert, erlauben, „Werte“ basierend auf was zu erstellen\n" +"es analysiert.\n" +"Das Merkmal „Wert“ wirkt wie eine Linse in funktionalen Programmiersprachen." + +#: src\functional/lenses.md:244 +#, fuzzy +msgid "" +"But unlike the `CustomerId` trait, the return types of `Visitor` methods are\n" +"_generic_, and the concrete `Value` type is _determined by the Visitor itself_." +msgstr "" +"Aber im Gegensatz zum 'CustomerId'-Merkmal sind die Rückgabetypen der 'Visitor'-Methoden\n" +"_allgemein_, und der konkrete `Wert`-Typ wird _vom Besucher selbst bestimmt_." + +#: src\functional/lenses.md:247 +#, fuzzy +msgid "" +"Instead of acting as one lens, it effectively acts as a family of\n" +"lenses, one for each concrete type of `Visitor`." +msgstr "" +"Anstatt als ein Objektiv zu fungieren, fungiert es effektiv als eine Familie von\n" +"Linsen, eine für jeden konkreten Typ von \"Besucher\"." + +#: src\functional/lenses.md:250 +#, fuzzy +msgid "" +"The `Deserializer` API is based on having a generic set of \"lenses\" work across\n" +"a set of other generic types for \"observation\".\n" +"It is a _prism_." +msgstr "" +"Die „Deserializer“-API basiert darauf, dass ein generischer Satz von „Linsen“ übergreifend funktioniert\n" +"eine Reihe anderer generischer Typen für \"Beobachtung\".\n" +"Es ist ein _Prisma_." + +#: src\functional/lenses.md:254 +#, fuzzy +msgid "For example, consider the identity record from earlier but simplified:" +msgstr "Betrachten Sie zum Beispiel den Identitätsdatensatz von früher, aber vereinfacht:" + +#: src\functional/lenses.md:256 +msgid "" +"```json\n" +"{ \"name\": \"Jane Doe\",\n" +" \"customer_id\": 1048576332,\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:262 +#, fuzzy +msgid "How would the _Serde_ library deserialize this JSON into `struct CreditRecord`?" +msgstr "Wie würde die _Serde_-Bibliothek dieses JSON in „struct CreditRecord“ deserialisieren?" + +#: src\functional/lenses.md:264 +#, fuzzy +msgid "" +"1. The user would call a library function to deserialize the data. This would\n" +" create a `Deserializer` based on the JSON format.\n" +"1. Based on the fields in the struct, a `Visitor` would be created (more on\n" +" that in a moment) which knows how to create each type in a generic data\n" +" model that was needed to represent it: `u64` and `String`.\n" +"1. The deserializer would make calls to the `Visitor` as it parsed items.\n" +"1. The `Visitor` would indicate if the items found were expected, and if not,\n" +" raise an error to indicate deserialization has failed." +msgstr "" +"1. Der Benutzer würde eine Bibliotheksfunktion aufrufen, um die Daten zu deserialisieren. Das würde\n" +" Erstellen Sie einen `Deserializer` basierend auf dem JSON-Format.\n" +"1. Basierend auf den Feldern in der Struktur würde ein `Besucher` erstellt (mehr dazu\n" +" das gleich), der weiß, wie man jeden Typ in generischen Daten erstellt\n" +" Modell, das zur Darstellung benötigt wurde: `u64` und `String`.\n" +"1. Der Deserialisierer würde den „Besucher“ aufrufen, während er Elemente analysiert.\n" +"1. Der „Besucher“ würde angeben, ob die gefundenen Gegenstände erwartet wurden, und wenn nicht,\n" +" löst einen Fehler aus, um anzuzeigen, dass die Deserialisierung fehlgeschlagen ist." + +#: src\functional/lenses.md:273 +#, fuzzy +msgid "For our very simple structure above, the expected pattern would be:" +msgstr "Für unsere sehr einfache Struktur oben wäre das erwartete Muster:" + +#: src\functional/lenses.md:275 +#, fuzzy +msgid "" +"1. Visit a map (_Serde_'s equvialent to `HashMap` or JSON's dictionary).\n" +"1. Visit a string key called \"name\".\n" +"1. Visit a string value, which will go into the `name` field.\n" +"1. Visit a string key called \"customer_id\".\n" +"1. Visit a string value, which will go into the `customer_id` field.\n" +"1. Visit the end of the map." +msgstr "" +"1. Besuchen Sie eine Karte (das Äquivalent von _Serde_ zu `HashMap` oder dem Wörterbuch von JSON).\n" +"1. Besuchen Sie einen Zeichenfolgenschlüssel namens \"Name\".\n" +"1. Besuchen Sie einen Zeichenfolgenwert, der in das Feld „Name“ eingefügt wird.\n" +"1. Besuchen Sie einen Zeichenfolgenschlüssel namens „customer_id“.\n" +"1. Besuchen Sie einen String-Wert, der in das Feld „customer_id“ geht.\n" +"1. Besuchen Sie das Ende der Karte." + +#: src\functional/lenses.md:282 +#, fuzzy +msgid "But what determines which \"observation\" pattern is expected?" +msgstr "Aber was bestimmt, welches \"Beobachtungsmuster\" erwartet wird?" + +#: src\functional/lenses.md:284 +#, fuzzy +msgid "" +"A functional programming language would be able to use currying to create\n" +"reflection of each type based on the type itself.\n" +"Rust does not support that, so every single type would need to have its own\n" +"code written based on its fields and their properties." +msgstr "" +"Eine funktionale Programmiersprache wäre in der Lage, Currying zum Erstellen zu verwenden\n" +"Reflexion jedes Typs basierend auf dem Typ selbst.\n" +"Rust unterstützt das nicht, also müsste jeder einzelne Typ seinen eigenen haben\n" +"Code, der basierend auf seinen Feldern und ihren Eigenschaften geschrieben wurde." + +#: src\functional/lenses.md:289 +#, fuzzy +msgid "_Serde_ solves this usability challenge with a derive macro:" +msgstr "_Serde_ löst diese Usability-Herausforderung mit einem Ableitungsmakro:" + +#: src\functional/lenses.md:291 +msgid "" +"```rust,ignore\n" +"use serde::Deserialize;\n" +"\n" +"#[derive(Deserialize)]\n" +"struct IdRecord {\n" +" name: String,\n" +" customer_id: String,\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:301 +#, fuzzy +msgid "" +"That macro simply generates an impl block causing the struct to implement a\n" +"trait called `Deserialize`." +msgstr "" +"Dieses Makro generiert einfach einen Impl-Block, der bewirkt, dass die Struktur a implementiert\n" +"Merkmal namens `Deserialize`." + +#: src\functional/lenses.md:304 +msgid "It is defined this way:" +msgstr "Es ist so definiert:" + +#: src\functional/lenses.md:306 +msgid "" +"```rust,ignore\n" +"pub trait Deserialize<'de>: Sized {\n" +" fn deserialize(deserializer: D) -> Result\n" +" where\n" +" D: Deserializer<'de>;\n" +"}\n" +"```" +msgstr "" + +#: src\functional/lenses.md:314 +#, fuzzy +msgid "" +"This is the function that determines how to create the struct itself.\n" +"Code is generated based on the struct's fields.\n" +"When the parsing library is called - in our example, a JSON parsing library -\n" +"it creates a `Deserializer` and calls `Type::deserialize` with it as a\n" +"parameter." +msgstr "" +"Dies ist die Funktion, die bestimmt, wie die Struktur selbst erstellt wird.\n" +"Code wird basierend auf den Feldern der Struktur generiert.\n" +"Wenn die Parsing-Bibliothek aufgerufen wird – in unserem Beispiel eine JSON-Parsing-Bibliothek –\n" +"es erstellt einen `Deserializer` und ruft damit `Type::deserialize` als\n" +"Parameter." + +#: src\functional/lenses.md:320 +#, fuzzy +msgid "" +"The `deserialize` code will then create a `Visitor` which will have its calls\n" +"\"refracted\" by the `Deserializer`.\n" +"If everything goes well, eventually that `Visitor` will construct a value\n" +"corresponding to the type being parsed and return it." +msgstr "" +"Der „Deserialize“-Code erstellt dann einen „Besucher“, der seine Aufrufe hat\n" +"vom `Deserializer` \"gebrochen\".\n" +"Wenn alles gut geht, wird dieser „Besucher“ schließlich einen Wert konstruieren\n" +"entsprechend dem zu analysierenden Typ und gibt ihn zurück." + +#: src\functional/lenses.md:325 +#, fuzzy +msgid "For a complete example, see the [_Serde_ documentation](https://serde.rs/deserialize-struct.html)." +msgstr "Ein vollständiges Beispiel finden Sie in der [_Serde_-Dokumentation] (https://serde.rs/deserialize-struct.html)." + +#: src\functional/lenses.md:327 +#, fuzzy +msgid "To wrap up, this is the power of _Serde_:" +msgstr "Zusammenfassend ist dies die Macht von _Serde_:" + +#: src\functional/lenses.md:329 +#, fuzzy +msgid "" +"1. The structure being parsed is represented by an `impl` block for `Deserialize`\n" +"1. The input data format (e.g. JSON) is represented by a `Deserializer` called\n" +" by `Deserialize`\n" +"1. The `Deserializer` acts like a prism which \"refracts\" lens-like `Visitor`\n" +" calls which actually build the data value" +msgstr "" +"1. Die zu parsende Struktur wird durch einen „impl“-Block für „Deserialize“ dargestellt\n" +"1. Das Eingabedatenformat (z. B. JSON) wird durch einen `Deserializer` namens repräsentiert\n" +" durch `Deserialisieren`\n" +"1. Der „Deserializer“ wirkt wie ein Prisma, das den linsenartigen „Besucher“ „bricht“.\n" +" Aufrufe, die den Datenwert tatsächlich aufbauen" + +#: src\functional/lenses.md:335 +#, fuzzy +msgid "" +"The result is that types to be deserialized only implement the \"top layer\" of\n" +"the API, and file formats only need to implement the \"bottom layer\".\n" +"Each piece can then \"just work\" with the rest of the ecosystem, since generic\n" +"types will bridge them." +msgstr "" +"Das Ergebnis ist, dass zu deserialisierende Typen nur die \"oberste Schicht\" implementieren\n" +"die API und Dateiformate müssen nur die \"unterste Schicht\" implementieren.\n" +"Jedes Stück kann dann \"einfach mit dem Rest des Ökosystems zusammenarbeiten\", da es generisch ist\n" +"Typen werden sie überbrücken." + +#: src\functional/lenses.md:340 +#, fuzzy +msgid "" +"To emphasize, the only reason this model works on any format and any type is\n" +"because the `Deserializer` trait's output type **is specified by the\n" +"implementor of `Visitor` it is passed**, rather than being tied to one specific\n" +"type.\n" +"This was not true in the account example earlier." +msgstr "" +"Um zu betonen, der einzige Grund, warum dieses Modell in jedem Format und jedem Typ funktioniert, ist\n" +"da der Ausgabetyp des `Deserializer`-Traits ** durch die spezifiziert wird\n" +"Implementierer von `Visitor` wird es übergeben**, anstatt an ein bestimmtes gebunden zu sein\n" +"Typ.\n" +"Dies war im vorherigen Kontobeispiel nicht der Fall." + +#: src\functional/lenses.md:346 +#, fuzzy +msgid "" +"Rust's generic-inspired type system can bring it close to these concepts and\n" +"use their power, as shown in this API design.\n" +"But it may also need procedural macros to create bridges for its generics." +msgstr "" +"Rusts generisch inspiriertes Typsystem kann es diesen Konzepten nahe bringen und\n" +"nutzen Sie ihre Macht, wie in diesem API-Design gezeigt.\n" +"Es kann jedoch auch prozedurale Makros benötigen, um Brücken für seine Generika zu erstellen." + +#: src\functional/lenses.md:350 +msgid "## See Also" +msgstr "## Siehe auch" + +#: src\functional/lenses.md:352 +#, fuzzy +msgid "" +"- [lens-rs crate](https://crates.io/crates/lens-rs) for a pre-built lenses\n" +" implementation, with a cleaner interface than these examples\n" +"- [serde](https://serde.rs) itself, which makes these concepts intuitive for\n" +" end users (i.e. defining the structs) without needing to undestand the\n" +" details\n" +"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for drawing\n" +" computer graphics that uses lens API design, including proceducal macros to\n" +" create full prisms for buffers of different pixel types that remain generic\n" +"- [An Article about Lenses in Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-" +"lens-and-other-optics-in-scala-e5f7e2fdafe)\n" +" that is very readable even without Scala expertise.\n" +"- [Paper: Profunctor Optics: Modular Data\n" +" Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +msgstr "" +"- [Lens-rs-Kiste] (https://crates.io/crates/lens-rs) für vorgefertigte Linsen\n" +" Implementierung, mit einer saubereren Schnittstelle als diese Beispiele\n" +"- [serde](https://serde.rs) selbst, was diese Konzepte für intuitiv macht\n" +" Endbenutzer (d. h. die Strukturen definieren), ohne die verstehen zu müssen\n" +" Einzelheiten\n" +"- [Luminanz](https://github.com/phaazon/luminance-rs) ist eine Kiste zum Zeichnen\n" +" Computergrafik, die Objektiv-API-Design verwendet, einschließlich prozeduraler Makros\n" +" Erstellen Sie vollständige Prismen für Puffer verschiedener Pixeltypen, die generisch bleiben\n" +"- [Ein Artikel über Linsen in Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-" +"lens-and-other-optics-in- scala-e5f7e2fdafe)\n" +" das ist auch ohne Scala-Expertise sehr gut lesbar.\n" +"- [Aufsatz: Profunctor Optics: Modular Data\n" +" Zugriffsberechtigte] (https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" + +#: src\functional/lenses.md:365 +#, fuzzy +msgid "" +"[School of Haskell: A Little Lens Starter Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/to-" +"infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" +msgstr "" +"[School of Haskell: Ein kleines Objektiv-Starter-Tutorial] (https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/" +"school/to-infinity-and-beyond/pick-of- die-woche/ein-kleines-objektiv-starter-tutorial)" + +#: src\additional_resources/index.md:1 +msgid "# Additional resources" +msgstr "# Zusätzliche Ressourcen" + +#: src\additional_resources/index.md:3 +msgid "A collection of complementary helpful content" +msgstr "Eine Sammlung ergänzender hilfreicher Inhalte" + +#: src\additional_resources/index.md:5 +msgid "## Talks" +msgstr "## Gespräche" + +#: src\additional_resources/index.md:7 +msgid "" +"- [Design Patterns in Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) by\n" +" Nicholas Cameron at the PDRust (2016)\n" +"- [Writing Idiomatic Libraries in Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +" by Pascal Hertleif at RustFest (2017)\n" +"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) by\n" +" Nicholas Cameron at LinuxConfAu (2018)" +msgstr "" +"- [Designmuster in Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) von\n" +" Nicholas Cameron beim PDRust (2016)\n" +"- [Idiomatische Bibliotheken in Rust schreiben](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +" von Pascal Hertleif beim RustFest (2017)\n" +"- [Techniken zur Programmierung in Rust](https://www.youtube.com/watch?v=vqavdUGKeb4) von\n" +" Nicholas Cameron auf der LinuxConfAu (2018)" + +#: src\additional_resources/index.md:14 +msgid "## Books (Online)" +msgstr "## Bücher (Online)" + +#: src\additional_resources/index.md:16 +msgid "- [The Rust API Guidelines](https://rust-lang.github.io/api-guidelines)" +msgstr "- [Die Rust-API-Richtlinien](https://rust-lang.github.io/api-guidelines)" + +#: src\additional_resources/design-principles.md:1 +msgid "# Design principles" +msgstr "# Design-Prinzipien" + +#: src\additional_resources/design-principles.md:3 +msgid "## A brief overview over common design principles" +msgstr "## Ein kurzer Überblick über gängige Gestaltungsprinzipien" + +#: src\additional_resources/design-principles.md:7 +msgid "## [SOLID](https://en.wikipedia.org/wiki/SOLID)" +msgstr "## [SOLID](https://en.wikipedia.org/wiki/SOLID)" + +#: src\additional_resources/design-principles.md:9 +#, fuzzy +msgid "" +"- [Single Responsibility Principle (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" A class should only have a single responsibility, that is, only changes to\n" +" one part of the software's specification should be able to affect the\n" +" specification of the class.\n" +"- [Open/Closed Principle (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +" \"Software entities ... should be open for extension, but closed for\n" +" modification.\"\n" +"- [Liskov Substitution Principle (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Objects in a program should be replaceable with instances of their subtypes\n" +" without altering the correctness of that program.\"\n" +"- [Interface Segregation Principle (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +" \"Many client-specific interfaces are better than one general-purpose\n" +" interface.\"\n" +"- [Dependency Inversion Principle (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +" One should \"depend upon abstractions, [not] concretions.\"" +msgstr "" +"- [Single-Responsibility-Prinzip (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" Eine Klasse sollte nur eine einzige Verantwortung haben, dh nur Änderungen an\n" +" Ein Teil der Softwarespezifikation sollte in der Lage sein, das zu beeinflussen\n" +" Angabe der Klasse.\n" +"- [Open/Closed-Prinzip (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +" „Softwareentitäten … sollten für Erweiterungen offen, aber geschlossen sein\n" +" Änderung.\"\n" +"- [Liskov-Substitutionsprinzip (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" „Objekte in einem Programm sollten durch Instanzen ihrer Untertypen ersetzbar sein\n" +" ohne die Korrektheit dieses Programms zu verändern.\"\n" +"- [Prinzip der Schnittstellentrennung (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +" „Viele kundenspezifische Schnittstellen sind besser als eine universelle\n" +" Schnittstelle.\"\n" +"- [Prinzip der Abhängigkeitsinversion (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +" Man sollte „sich auf Abstraktionen verlassen, [nicht] Konkretionen“." + +#: src\additional_resources/design-principles.md:25 +msgid "## [DRY (Don’t Repeat Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgstr "## [DRY (Nicht wiederholen)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" + +#: src\additional_resources/design-principles.md:27 +#, fuzzy +msgid "" +"\"Every piece of knowledge must have a single, unambiguous, authoritative\n" +"representation within a system\"" +msgstr "" +"„Jedes Wissen muss eine einzige, unzweideutige Autorität haben\n" +"Repräsentation innerhalb eines Systems\"" + +#: src\additional_resources/design-principles.md:30 +msgid "## [KISS principle](https://en.wikipedia.org/wiki/KISS_principle)" +msgstr "## [KISS-Prinzip](https://en.wikipedia.org/wiki/KISS_principle)" + +#: src\additional_resources/design-principles.md:32 +msgid "" +"most systems work best if they are kept simple rather than made complicated;\n" +"therefore, simplicity should be a key goal in design, and unnecessary\n" +"complexity should be avoided" +msgstr "" + +#: src\additional_resources/design-principles.md:36 +#, fuzzy +msgid "## [Law of Demeter (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter)" +msgstr "## [Law of Demeter (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter)" + +#: src\additional_resources/design-principles.md:38 +#, fuzzy +msgid "" +"a given object should assume as little as possible about the structure or\n" +"properties of anything else (including its subcomponents), in accordance with\n" +"the principle of \"information hiding\"" +msgstr "" +"ein gegebenes Objekt sollte so wenig wie möglich über die Struktur annehmen bzw\n" +"Eigenschaften von allem anderen (einschließlich seiner Unterkomponenten), in Übereinstimmung mit\n" +"das Prinzip des „Information Hiding“" + +#: src\additional_resources/design-principles.md:42 +#, fuzzy +msgid "## [Design by contract (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgstr "## [Design by Contract (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" + +#: src\additional_resources/design-principles.md:44 +#, fuzzy +msgid "" +"software designers should define formal, precise and verifiable interface\n" +"specifications for software components, which extend the ordinary definition of\n" +"abstract data types with preconditions, postconditions and invariants" +msgstr "" +"Softwaredesigner sollten formale, präzise und überprüfbare Schnittstellen definieren\n" +"Spezifikationen für Softwarekomponenten, die die gewöhnliche Definition von erweitern\n" +"abstrakte Datentypen mit Vorbedingungen, Nachbedingungen und Invarianten" + +#: src\additional_resources/design-principles.md:48 +#, fuzzy +msgid "## [Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgstr "## [Kapselung](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" + +#: src\additional_resources/design-principles.md:50 +#, fuzzy +msgid "" +"bundling of data with the methods that operate on that data, or the restricting\n" +"of direct access to some of an object's components. Encapsulation is used to\n" +"hide the values or state of a structured data object inside a class, preventing\n" +"unauthorized parties' direct access to them." +msgstr "" +"Bündelung von Daten mit den Methoden, die auf diesen Daten arbeiten, oder die Einschränkung\n" +"des direkten Zugriffs auf einige der Komponenten eines Objekts. Kapselung ist gewöhnungsbedürftig\n" +"verstecken Sie die Werte oder den Status eines strukturierten Datenobjekts innerhalb einer Klasse und verhindern Sie\n" +"den direkten Zugriff Unbefugter auf sie." + +#: src\additional_resources/design-principles.md:55 +#, fuzzy +msgid "## [Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgstr "## [Befehl-Abfrage-Trennung (CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" + +#: src\additional_resources/design-principles.md:57 +#, fuzzy +msgid "" +"“Functions should not produce abstract side effects...only commands\n" +"(procedures) will be permitted to produce side effects.” - Bertrand Meyer:\n" +"Object-Oriented Software Construction" +msgstr "" +"„Funktionen sollten keine abstrakten Seiteneffekte erzeugen ... nur Befehle\n" +"(Verfahren) dürfen Nebenwirkungen hervorrufen.“ -Bertrand Meyer:\n" +"Objektorientierte Softwarekonstruktion" + +#: src\additional_resources/design-principles.md:61 +#, fuzzy +msgid "## [Principle of least astonishment (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgstr "## [Prinzip des geringsten Erstaunens (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" + +#: src\additional_resources/design-principles.md:63 +#, fuzzy +msgid "" +"a component of a system should behave in a way that most users will expect it\n" +"to behave. The behavior should not astonish or surprise users" +msgstr "" +"Eine Komponente eines Systems sollte sich so verhalten, wie es die meisten Benutzer erwarten\n" +"sich benehmen. Das Verhalten sollte die Benutzer nicht überraschen oder überraschen" + +#: src\additional_resources/design-principles.md:66 +#, fuzzy +msgid "## Linguistic-Modular-Units" +msgstr "## Sprachliche-Modular-Einheiten" + +#: src\additional_resources/design-principles.md:68 +#, fuzzy +msgid "" +"“Modules must correspond to syntactic units in the language used.” - Bertrand\n" +"Meyer: Object-Oriented Software Construction" +msgstr "" +"„Module müssen syntaktischen Einheiten in der verwendeten Sprache entsprechen.“ -Bertrand\n" +"Meyer: Objektorientierte Softwarekonstruktion" + +#: src\additional_resources/design-principles.md:71 +#, fuzzy +msgid "## Self-Documentation" +msgstr "## Selbstdokumentation" + +#: src\additional_resources/design-principles.md:73 +#, fuzzy +msgid "" +"“The designer of a module should strive to make all information about the\n" +"module part of the module itself.” - Bertrand Meyer: Object-Oriented Software\n" +"Construction" +msgstr "" +"„Der Designer eines Moduls sollte sich bemühen, alle Informationen über das zu machen\n" +"Modulteil des Moduls selbst.“ - Bertrand Meyer: Objektorientierte Software\n" +"Konstruktion" + +#: src\additional_resources/design-principles.md:77 +#, fuzzy +msgid "## Uniform-Access" +msgstr "## Uniform-Zugang" + +#: src\additional_resources/design-principles.md:79 +#, fuzzy +msgid "" +"“All services offered by a module should be available through a uniform\n" +"notation, which does not betray whether they are implemented through storage or\n" +"through computation.” - Bertrand Meyer: Object-Oriented Software Construction" +msgstr "" +"„Alle Dienste, die ein Modul anbietet, sollten einheitlich verfügbar sein\n" +"Notation, die nicht verrät, ob sie durch Speicherung oder realisiert sind\n" +"durch Berechnung.“ - Bertrand Meyer: Objektorientierte Softwarekonstruktion" + +#: src\additional_resources/design-principles.md:83 +#, fuzzy +msgid "## Single-Choice" +msgstr "## Single-Choice" + +#: src\additional_resources/design-principles.md:85 +#, fuzzy +msgid "" +"“Whenever a software system must support a set of alternatives, one and only\n" +"one module in the system should know their exhaustive list.” - Bertrand Meyer:\n" +"Object-Oriented Software Construction" +msgstr "" +"„Wann immer ein Softwaresystem eine Reihe von Alternativen unterstützen muss, eine und nur eine\n" +"ein Modul im System sollte ihre vollständige Liste kennen.“ -Bertrand Meyer:\n" +"Objektorientierte Softwarekonstruktion" + +#: src\additional_resources/design-principles.md:89 +#, fuzzy +msgid "## Persistence-Closure" +msgstr "## Persistenz-Closure" + +#: src\additional_resources/design-principles.md:91 +#, fuzzy +msgid "" +"“Whenever a storage mechanism stores an object, it must store with it the\n" +"dependents of that object. Whenever a retrieval mechanism retrieves a\n" +"previously stored object, it must also retrieve any dependent of that object\n" +"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented Software\n" +"Construction" +msgstr "" +"„Wann immer ein Speichermechanismus ein Objekt speichert, muss er damit auch das speichern\n" +"abhängig von diesem Objekt. Immer wenn ein Abrufmechanismus a abruft\n" +"zuvor gespeicherte Objekt, muss es auch alle abhängigen Objekte dieses Objekts abrufen\n" +"das wurde noch nicht abgerufen.“ - Bertrand Meyer: Objektorientierte Software\n" +"Konstruktion" diff --git a/po/es.po b/po/es.po index f656dd5..c71c710 100644 --- a/po/es.po +++ b/po/es.po @@ -1,16 +1,16 @@ - msgid "" msgstr "" "Project-Id-Version: Rust Design Patterns\n" "POT-Creation-Date: \n" -"PO-Revision-Date: 2023-04-08 21:55+0200\n" -"Last-Translator: \n" +"PO-Revision-Date: 2023-04-09 03:22+0200\n" +"Last-Translator: EMAIL@ADDRESS\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" -"Language: es\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Generator: Poedit 3.2.2\n" #: src\SUMMARY.md:3 #, fuzzy @@ -266,12 +266,10 @@ msgstr "## Participación" #, fuzzy msgid "" "If you are interested in contributing to this book, check out the\n" -"[contribution " -"guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +"[contribution guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." msgstr "" "Si está interesado en contribuir a este libro, consulte el\n" -"[directrices de " -"contribución](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +"[directrices de contribución](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." #: src\intro.md:8 #, fuzzy @@ -287,13 +285,10 @@ msgid "" "abstract from these particularities to find the common practices that\n" "are generically applicable." msgstr "" -"En el desarrollo de software, a menudo nos encontramos con problemas que " -"comparten\n" +"En el desarrollo de software, a menudo nos encontramos con problemas que comparten\n" "similitudes independientemente del entorno en el que aparecen. Aunque el\n" -"detalles de implementación son cruciales para resolver la tarea en cuestión, " -"podemos\n" -"abstraerse de estas particularidades para encontrar las prácticas comunes " -"que\n" +"detalles de implementación son cruciales para resolver la tarea en cuestión, podemos\n" +"abstraerse de estas particularidades para encontrar las prácticas comunes que\n" "son de aplicación genérica." #: src\intro.md:16 @@ -305,13 +300,10 @@ msgid "" "language for developers, making them an excellent tool for effective\n" "communication when problem-solving in teams." msgstr "" -"Los patrones de diseño son una colección de soluciones reutilizables y " -"probadas para\n" -"problemas recurrentes en ingeniería. Hacen que nuestro software sea más " -"modular,\n" +"Los patrones de diseño son una colección de soluciones reutilizables y probadas para\n" +"problemas recurrentes en ingeniería. Hacen que nuestro software sea más modular,\n" "mantenible y extensible. Además, estos patrones proporcionan un común\n" -"lenguaje para desarrolladores, lo que los convierte en una excelente " -"herramienta para\n" +"lenguaje para desarrolladores, lo que los convierte en una excelente herramienta para\n" "comunicación en la resolución de problemas en equipo." #: src\intro.md:22 src\patterns/index.md:14 @@ -322,8 +314,7 @@ msgstr "## Patrones de diseño en Rust" #: src\intro.md:24 #, fuzzy msgid "" -"Rust is not object-oriented, and the combination of all its " -"characteristics,\n" +"Rust is not object-oriented, and the combination of all its characteristics,\n" "such as functional elements, a strong type system, and the borrow checker,\n" "makes it unique.\n" "Because of this, Rust design patterns vary with respect to other\n" @@ -331,10 +322,8 @@ msgid "" "That's why we decided to write this book. We hope you enjoy reading it!\n" "The book is divided in three main chapters:" msgstr "" -"Rust no está orientado a objetos, y la combinación de todas sus " -"características,\n" -"tales como elementos funcionales, un sistema de tipo fuerte y el verificador " -"de préstamo,\n" +"Rust no está orientado a objetos, y la combinación de todas sus características,\n" +"tales como elementos funcionales, un sistema de tipo fuerte y el verificador de préstamo,\n" "lo hace único.\n" "Debido a esto, los patrones de diseño de Rust varían con respecto a otros\n" "lenguajes de programación tradicionales orientados a objetos.\n" @@ -349,21 +338,17 @@ msgid "" " You should break them only if you have a good reason for it.\n" "- [Design patterns](./patterns/index.md): methods to solve common problems\n" " when coding.\n" -"- [Anti-patterns](./anti_patterns/index.md): methods to solve common " -"problems\n" +"- [Anti-patterns](./anti_patterns/index.md): methods to solve common problems\n" " when coding.\n" " However, while design patterns give us benefits,\n" " anti-patterns create more problems." msgstr "" -"- [Expresiones idiomáticas](./idioms/index.md): pautas a seguir al " -"codificar.\n" +"- [Expresiones idiomáticas](./idioms/index.md): pautas a seguir al codificar.\n" " Son las normas sociales de la comunidad.\n" " Debe romperlos solo si tiene una buena razón para ello.\n" -"- [Patrones de diseño] (./patrones/index.md): métodos para resolver " -"problemas comunes\n" +"- [Patrones de diseño] (./patrones/index.md): métodos para resolver problemas comunes\n" " al codificar.\n" -"- [Anti-patterns](./anti_patterns/index.md): métodos para resolver problemas " -"comunes\n" +"- [Anti-patterns](./anti_patterns/index.md): métodos para resolver problemas comunes\n" " al codificar.\n" " Sin embargo, mientras que los patrones de diseño nos dan beneficios,\n" " los antipatrones crean más problemas." @@ -376,15 +361,13 @@ msgstr "# Traducciones" #: src\translations.md:3 #, fuzzy msgid "" -"We are utilizing " -"[mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" -"Please read up on how to _add_ and _update_ translations in [their " -"repository](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations)" +"We are utilizing [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Please read up on how to _add_ and _update_ translations in [their repository](https://github.com/google/mdbook-i18n-helpers#creating-" +"and-updating-translations)" msgstr "" -"Estamos utilizando " -"[mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" -"Lea cómo _agregar_ y _actualizar_ traducciones en [su " -"repositorio](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations)" +"Estamos utilizando [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Lea cómo _agregar_ y _actualizar_ traducciones en [su repositorio](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-" +"translations)" #: src\translations.md:6 #, fuzzy @@ -418,11 +401,9 @@ msgid "" "Writing idiomatic code allows other developers to understand better what is\n" "happening." msgstr "" -"[Los modismos] (https://en.wikipedia.org/wiki/Programming_idiom) se usan " -"comúnmente\n" +"[Los modismos] (https://en.wikipedia.org/wiki/Programming_idiom) se usan comúnmente\n" "estilos, pautas y patrones acordados en gran medida por una comunidad.\n" -"Escribir código idiomático permite que otros desarrolladores entiendan mejor " -"qué es\n" +"Escribir código idiomático permite que otros desarrolladores entiendan mejor qué es\n" "sucediendo." #: src\idioms/index.md:8 @@ -433,55 +414,39 @@ msgid "" "Instead, the source code is mainly beneficial to the developer.\n" "So, since we have this abstraction layer, why not make it more readable?" msgstr "" -"Después de todo, a la computadora solo le importa el código de máquina que " -"se genera.\n" +"Después de todo, a la computadora solo le importa el código de máquina que se genera.\n" "por el compilador.\n" -"En cambio, el código fuente es principalmente beneficioso para el " -"desarrollador.\n" -"Entonces, ya que tenemos esta capa de abstracción, ¿por qué no hacerla más " -"legible?" +"En cambio, el código fuente es principalmente beneficioso para el desarrollador.\n" +"Entonces, ya que tenemos esta capa de abstracción, ¿por qué no hacerla más legible?" #: src\idioms/index.md:13 msgid "" -"Remember the [KISS " -"principle](https://en.wikipedia.org/wiki/KISS_principle):\n" -"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they " -"are\n" -"kept simple rather than made complicated; therefore, simplicity should be a " -"key\n" +"Remember the [KISS principle](https://en.wikipedia.org/wiki/KISS_principle):\n" +"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they are\n" +"kept simple rather than made complicated; therefore, simplicity should be a key\n" "goal in design, and unnecessary complexity should be avoided\"." msgstr "" #: src\idioms/index.md:18 #, fuzzy msgid "> Code is there for humans, not computers, to understand." -msgstr "" -"> El código está ahí para que lo entiendan los humanos, no las computadoras." +msgstr "> El código está ahí para que lo entiendan los humanos, no las computadoras." #: src\idioms/coercion-arguments.md:1 #, fuzzy msgid "# Use borrowed types for arguments" msgstr "# Usar tipos prestados para argumentos" -#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 -#: src\idioms/default.md:3 src\idioms/deref.md:3 src\idioms/dtor-finally.md:3 -#: src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 -#: src\idioms/ffi/errors.md:3 src\idioms/ffi/accepting-strings.md:3 -#: src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 -#: src\idioms/pass-var-to-closure.md:3 src\idioms/priv-extend.md:3 -#: src\idioms/temporary-mutability.md:3 -#: src\idioms/return-consumed-arg-on-error.md:3 -#: src\patterns/behavioural/command.md:3 -#: src\patterns/behavioural/interpreter.md:3 -#: src\patterns/behavioural/newtype.md:13 src\patterns/behavioural/RAII.md:3 -#: src\patterns/behavioural/strategy.md:3 src\patterns/behavioural/visitor.md:3 -#: src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 -#: src\patterns/structural/compose-structs.md:5 -#: src\patterns/structural/small-crates.md:3 -#: src\patterns/structural/unsafe-mods.md:3 src\patterns/ffi/export.md:3 -#: src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 -#: src\anti_patterns/deny-warnings.md:3 src\anti_patterns/deref.md:3 -#: src\functional/generics-type-classes.md:3 +#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 src\idioms/default.md:3 src\idioms/deref.md:3 +#: src\idioms/dtor-finally.md:3 src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 src\idioms/ffi/errors.md:3 +#: src\idioms/ffi/accepting-strings.md:3 src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 +#: src\idioms/pass-var-to-closure.md:3 src\idioms/priv-extend.md:3 src\idioms/temporary-mutability.md:3 +#: src\idioms/return-consumed-arg-on-error.md:3 src\patterns/behavioural/command.md:3 src\patterns/behavioural/interpreter.md:3 +#: src\patterns/behavioural/newtype.md:13 src\patterns/behavioural/RAII.md:3 src\patterns/behavioural/strategy.md:3 +#: src\patterns/behavioural/visitor.md:3 src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 +#: src\patterns/structural/compose-structs.md:5 src\patterns/structural/small-crates.md:3 src\patterns/structural/unsafe-mods.md:3 +#: src\patterns/ffi/export.md:3 src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 src\anti_patterns/deny-warnings.md:3 +#: src\anti_patterns/deref.md:3 src\functional/generics-type-classes.md:3 #, fuzzy msgid "## Description" msgstr "## Descripción" @@ -489,15 +454,12 @@ msgstr "## Descripción" #: src\idioms/coercion-arguments.md:5 #, fuzzy msgid "" -"Using a target of a deref coercion can increase the flexibility of your " -"code\n" +"Using a target of a deref coercion can increase the flexibility of your code\n" "when you are deciding which argument type to use for a function argument.\n" "In this way, the function will accept more input types." msgstr "" -"El uso de un objetivo de coerción de desref puede aumentar la flexibilidad " -"de su código\n" -"cuando está decidiendo qué tipo de argumento usar para un argumento de " -"función.\n" +"El uso de un objetivo de coerción de desref puede aumentar la flexibilidad de su código\n" +"cuando está decidiendo qué tipo de argumento usar para un argumento de función.\n" "De esta forma, la función aceptará más tipos de entrada." #: src\idioms/coercion-arguments.md:9 @@ -516,39 +478,25 @@ msgstr "" #: src\idioms/coercion-arguments.md:14 #, fuzzy msgid "" -"Using borrowed types you can avoid layers of indirection for those " -"instances\n" -"where the owned type already provides a layer of indirection. For instance, " -"a\n" +"Using borrowed types you can avoid layers of indirection for those instances\n" +"where the owned type already provides a layer of indirection. For instance, a\n" "`String` has a layer of indirection, so a `&String` will have two layers of\n" -"indirection. We can avoid this by using `&str` instead, and letting " -"`&String`\n" +"indirection. We can avoid this by using `&str` instead, and letting `&String`\n" "coerce to a `&str` whenever the function is invoked." msgstr "" -"Usando tipos prestados puede evitar capas de direccionamiento indirecto para " -"esas instancias\n" -"donde el tipo propio ya proporciona una capa de direccionamiento indirecto. " -"Por ejemplo, un\n" -"`String` tiene una capa de direccionamiento indirecto, por lo que `&String` " -"tendrá dos capas de\n" -"indirección Podemos evitar esto usando `&str` en su lugar, y dejando que " -"`&String`\n" +"Usando tipos prestados puede evitar capas de direccionamiento indirecto para esas instancias\n" +"donde el tipo propio ya proporciona una capa de direccionamiento indirecto. Por ejemplo, un\n" +"`String` tiene una capa de direccionamiento indirecto, por lo que `&String` tendrá dos capas de\n" +"indirección Podemos evitar esto usando `&str` en su lugar, y dejando que `&String`\n" "coaccionar a `&str` cada vez que se invoca la función." -#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 -#: src\idioms/default.md:20 src\idioms/deref.md:9 src\idioms/dtor-finally.md:9 -#: src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 -#: src\idioms/pass-var-to-closure.md:12 src\idioms/priv-extend.md:18 -#: src\idioms/temporary-mutability.md:12 -#: src\idioms/return-consumed-arg-on-error.md:8 -#: src\patterns/behavioural/command.md:18 -#: src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 -#: src\patterns/behavioural/strategy.md:28 -#: src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 -#: src\patterns/creational/fold.md:12 -#: src\patterns/structural/compose-structs.md:17 -#: src\anti_patterns/borrow_clone.md:11 src\anti_patterns/deny-warnings.md:8 -#: src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 +#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 src\idioms/default.md:20 src\idioms/deref.md:9 +#: src\idioms/dtor-finally.md:9 src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 src\idioms/pass-var-to-closure.md:12 +#: src\idioms/priv-extend.md:18 src\idioms/temporary-mutability.md:12 src\idioms/return-consumed-arg-on-error.md:8 +#: src\patterns/behavioural/command.md:18 src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 +#: src\patterns/behavioural/strategy.md:28 src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 +#: src\patterns/creational/fold.md:12 src\patterns/structural/compose-structs.md:17 src\anti_patterns/borrow_clone.md:11 +#: src\anti_patterns/deny-warnings.md:8 src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 #, fuzzy msgid "## Example" msgstr "## Ejemplo" @@ -556,28 +504,23 @@ msgstr "## Ejemplo" #: src\idioms/coercion-arguments.md:22 #, fuzzy msgid "" -"For this example, we will illustrate some differences for using `&String` as " -"a\n" -"function argument versus using a `&str`, but the ideas apply as well to " -"using\n" +"For this example, we will illustrate some differences for using `&String` as a\n" +"function argument versus using a `&str`, but the ideas apply as well to using\n" "`&Vec` versus using a `&[T]` or using a `&Box` versus a `&T`." msgstr "" "Para este ejemplo, ilustraremos algunas diferencias al usar `&String` como\n" -"argumento de función versus usar `&str`, pero las ideas se aplican también " -"al uso\n" +"argumento de función versus usar `&str`, pero las ideas se aplican también al uso\n" "`&Vec` versus usar `&[T]` o usar `&Box` versus `&T`." #: src\idioms/coercion-arguments.md:26 #, fuzzy msgid "" "Consider an example where we wish to determine if a word contains three\n" -"consecutive vowels. We don't need to own the string to determine this, so " -"we\n" +"consecutive vowels. We don't need to own the string to determine this, so we\n" "will take a reference." msgstr "" "Considere un ejemplo donde deseamos determinar si una palabra contiene tres\n" -"vocales consecutivas. No necesitamos ser dueños de la cadena para determinar " -"esto, así que\n" +"vocales consecutivas. No necesitamos ser dueños de la cadena para determinar esto, así que\n" "tomará una referencia." #: src\idioms/coercion-arguments.md:30 @@ -622,17 +565,13 @@ msgstr "" #, fuzzy msgid "" "This works fine because we are passing a `&String` type as a parameter.\n" -"If we remove the comments on the last two lines, the example will fail. " -"This\n" -"is because a `&str` type will not coerce to a `&String` type. We can fix " -"this\n" +"If we remove the comments on the last two lines, the example will fail. This\n" +"is because a `&str` type will not coerce to a `&String` type. We can fix this\n" "by simply modifying the type for our argument." msgstr "" "Esto funciona bien porque estamos pasando un tipo `&String` como parámetro.\n" -"Si eliminamos los comentarios de las dos últimas líneas, el ejemplo fallará. " -"Este\n" -"es porque un tipo `&str` no forzará a un tipo `&String`. podemos arreglar " -"esto\n" +"Si eliminamos los comentarios de las dos últimas líneas, el ejemplo fallará. Este\n" +"es porque un tipo `&str` no forzará a un tipo `&String`. podemos arreglar esto\n" "simplemente modificando el tipo de nuestro argumento." #: src\idioms/coercion-arguments.md:67 @@ -664,37 +603,28 @@ msgstr "" #, fuzzy msgid "" "But wait, that's not all! There is more to this story.\n" -"It's likely that you may say to yourself: that doesn't matter, I will never " -"be\n" -"using a `&'static str` as an input anyways (as we did when we used " -"`\"Ferris\"`).\n" -"Even ignoring this special example, you may still find that using `&str` " -"will\n" +"It's likely that you may say to yourself: that doesn't matter, I will never be\n" +"using a `&'static str` as an input anyways (as we did when we used `\"Ferris\"`).\n" +"Even ignoring this special example, you may still find that using `&str` will\n" "give you more flexibility than using a `&String`." msgstr "" "Pero espera, ¡eso no es todo! Hay más en esta historia.\n" "Es probable que te digas a ti mismo: eso no importa, nunca seré\n" -"usando `&'static str` como entrada de todos modos (como hicimos cuando " -"usamos `\"Ferris\"`).\n" -"Incluso ignorando este ejemplo especial, aún puede encontrar que usar " -"`&str`\n" +"usando `&'static str` como entrada de todos modos (como hicimos cuando usamos `\"Ferris\"`).\n" +"Incluso ignorando este ejemplo especial, aún puede encontrar que usar `&str`\n" "darle más flexibilidad que usar un `&String`." #: src\idioms/coercion-arguments.md:86 #, fuzzy msgid "" "Let's now take an example where someone gives us a sentence, and we want to\n" -"determine if any of the words in the sentence contain three consecutive " -"vowels.\n" -"We probably should make use of the function we have already defined and " -"simply\n" +"determine if any of the words in the sentence contain three consecutive vowels.\n" +"We probably should make use of the function we have already defined and simply\n" "feed in each word from the sentence." msgstr "" "Ahora tomemos un ejemplo en el que alguien nos da una oración y queremos\n" -"determinar si alguna de las palabras de la oración contiene tres vocales " -"consecutivas.\n" -"Probablemente deberíamos hacer uso de la función que ya hemos definido y " -"simplemente\n" +"determinar si alguna de las palabras de la oración contiene tres vocales consecutivas.\n" +"Probablemente deberíamos hacer uso de la función que ya hemos definido y simplemente\n" "Introduzca cada palabra de la oración." #: src\idioms/coercion-arguments.md:91 @@ -723,8 +653,7 @@ msgid "" "\n" "fn main() {\n" " let sentence_string =\n" -" \"Once upon a time, there was a friendly curious crab named " -"Ferris\".to_string();\n" +" \"Once upon a time, there was a friendly curious crab named Ferris\".to_string();\n" " for word in sentence_string.split(' ') {\n" " if three_vowels(word) {\n" " println!(\"{} has three consecutive vowels!\", word);\n" @@ -737,12 +666,10 @@ msgstr "" #: src\idioms/coercion-arguments.md:121 #, fuzzy msgid "" -"Running this example using our function declared with an argument type " -"`&str`\n" +"Running this example using our function declared with an argument type `&str`\n" "will yield" msgstr "" -"Ejecutando este ejemplo usando nuestra función declarada con un tipo de " -"argumento `&str`\n" +"Ejecutando este ejemplo usando nuestra función declarada con un tipo de argumento `&str`\n" "rendirá" #: src\idioms/coercion-arguments.md:124 @@ -756,34 +683,21 @@ msgstr "" #, fuzzy msgid "" "However, this example will not run when our function is declared with an\n" -"argument type `&String`. This is because string slices are a `&str` and not " -"a\n" -"`&String` which would require an allocation to be converted to `&String` " -"which\n" -"is not implicit, whereas converting from `String` to `&str` is cheap and " -"implicit." -msgstr "" -"Sin embargo, este ejemplo no se ejecutará cuando nuestra función se declare " -"con un\n" -"tipo de argumento `&String`. Esto se debe a que los segmentos de cadena son " -"un `&str` y no un\n" +"argument type `&String`. This is because string slices are a `&str` and not a\n" +"`&String` which would require an allocation to be converted to `&String` which\n" +"is not implicit, whereas converting from `String` to `&str` is cheap and implicit." +msgstr "" +"Sin embargo, este ejemplo no se ejecutará cuando nuestra función se declare con un\n" +"tipo de argumento `&String`. Esto se debe a que los segmentos de cadena son un `&str` y no un\n" "`&String` que requeriría convertir una asignación a `&String` que\n" -"no es implícito, mientras que convertir de `String` a `&str` es económico e " -"implícito." - -#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 -#: src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 -#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 -#: src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 -#: src\patterns/behavioural/command.md:218 -#: src\patterns/behavioural/interpreter.md:142 -#: src\patterns/behavioural/newtype.md:104 src\patterns/behavioural/RAII.md:111 -#: src\patterns/behavioural/strategy.md:174 -#: src\patterns/behavioural/visitor.md:106 -#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 -#: src\patterns/structural/small-crates.md:45 -#: src\patterns/structural/unsafe-mods.md:32 -#: src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 +"no es implícito, mientras que convertir de `String` a `&str` es económico e implícito." + +#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 +#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 +#: src\patterns/behavioural/command.md:218 src\patterns/behavioural/interpreter.md:142 src\patterns/behavioural/newtype.md:104 +#: src\patterns/behavioural/RAII.md:111 src\patterns/behavioural/strategy.md:174 src\patterns/behavioural/visitor.md:106 +#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 src\patterns/structural/small-crates.md:45 +#: src\patterns/structural/unsafe-mods.md:32 src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 #: src\anti_patterns/deref.md:123 src\functional/generics-type-classes.md:237 #, fuzzy msgid "## See also" @@ -792,20 +706,16 @@ msgstr "## Ver también" #: src\idioms/coercion-arguments.md:135 #, fuzzy msgid "" -"- [Rust Language Reference on Type " -"Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- [Rust Language Reference on Type Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" "- For more discussion on how to handle `String` and `&str` see\n" -" [this blog series " -"(2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html)\n" +" [this blog series (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-" +"functions.html)\n" " by Herman J. Radtke III" msgstr "" -"- [Referencia del lenguaje Rust sobre coerciones de " -"tipos](https://doc.rust-lang.org/reference/type-coercions.html)\n" -"- Para obtener más información sobre cómo manejar `String` y `&str`, " -"consulte\n" -" [esta serie de blogs " -"(2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html " -")\n" +"- [Referencia del lenguaje Rust sobre coerciones de tipos](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- Para obtener más información sobre cómo manejar `String` y `&str`, consulte\n" +" [esta serie de blogs (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-" +"functions.html )\n" " por Herman J. Radtke III" #: src\idioms/concat-format.md:1 @@ -816,16 +726,14 @@ msgstr "# Concatenar cadenas con `formato!`" #: src\idioms/concat-format.md:5 #, fuzzy msgid "" -"It is possible to build up strings using the `push` and `push_str` methods " -"on a\n" +"It is possible to build up strings using the `push` and `push_str` methods on a\n" "mutable `String`, or using its `+` operator. However, it is often more\n" "convenient to use `format!`, especially where there is a mix of literal and\n" "non-literal strings." msgstr "" "Es posible construir cadenas usando los métodos `push` y `push_str` en un\n" "`String` mutable, o usando su operador `+`. Sin embargo, a menudo es más\n" -"conveniente usar `formato!`, especialmente donde hay una mezcla de literal " -"y\n" +"conveniente usar `formato!`, especialmente donde hay una mezcla de literal y\n" "cadenas no literales." #: src\idioms/concat-format.md:12 @@ -844,46 +752,29 @@ msgid "" "```" msgstr "" -#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 -#: src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 -#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 -#: src\idioms/ffi/accepting-strings.md:68 src\idioms/ffi/passing-strings.md:68 -#: src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 -#: src\idioms/return-consumed-arg-on-error.md:55 -#: src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 -#: src\patterns/behavioural/strategy.md:96 -#: src\patterns/creational/builder.md:68 -#: src\patterns/structural/compose-structs.md:75 -#: src\patterns/structural/small-crates.md:12 -#: src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 -#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 -#: src\anti_patterns/deref.md:69 src\functional/generics-type-classes.md:210 +#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 +#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 src\idioms/ffi/accepting-strings.md:68 +#: src\idioms/ffi/passing-strings.md:68 src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 +#: src\idioms/return-consumed-arg-on-error.md:55 src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 +#: src\patterns/behavioural/strategy.md:96 src\patterns/creational/builder.md:68 src\patterns/structural/compose-structs.md:75 +#: src\patterns/structural/small-crates.md:12 src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 +#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 src\anti_patterns/deref.md:69 +#: src\functional/generics-type-classes.md:210 #, fuzzy msgid "## Advantages" msgstr "## Ventajas" #: src\idioms/concat-format.md:27 #, fuzzy -msgid "" -"Using `format!` is usually the most succinct and readable way to combine " -"strings." -msgstr "" -"Usar `format!` suele ser la forma más sucinta y legible de combinar cadenas." - -#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 -#: src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 -#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 -#: src\idioms/ffi/accepting-strings.md:141 -#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 -#: src\idioms/temporary-mutability.md:42 -#: src\idioms/return-consumed-arg-on-error.md:59 -#: src\patterns/behavioural/newtype.md:77 -#: src\patterns/behavioural/strategy.md:104 -#: src\patterns/creational/builder.md:76 -#: src\patterns/structural/compose-structs.md:81 -#: src\patterns/structural/small-crates.md:22 -#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 -#: src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 +msgid "Using `format!` is usually the most succinct and readable way to combine strings." +msgstr "Usar `format!` suele ser la forma más sucinta y legible de combinar cadenas." + +#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 +#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 src\idioms/ffi/accepting-strings.md:141 +#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 src\idioms/temporary-mutability.md:42 +#: src\idioms/return-consumed-arg-on-error.md:59 src\patterns/behavioural/newtype.md:77 src\patterns/behavioural/strategy.md:104 +#: src\patterns/creational/builder.md:76 src\patterns/structural/compose-structs.md:81 src\patterns/structural/small-crates.md:22 +#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 #: src\functional/generics-type-classes.md:221 #, fuzzy msgid "## Disadvantages" @@ -892,16 +783,12 @@ msgstr "## Desventajas" #: src\idioms/concat-format.md:31 #, fuzzy msgid "" -"It is usually not the most efficient way to combine strings - a series of " -"`push`\n" -"operations on a mutable string is usually the most efficient (especially if " -"the\n" +"It is usually not the most efficient way to combine strings - a series of `push`\n" +"operations on a mutable string is usually the most efficient (especially if the\n" "string has been pre-allocated to the expected size)." msgstr "" -"Por lo general, no es la forma más eficiente de combinar cadenas: una serie " -"de `push`\n" -"operaciones en una cadena mutable suele ser la más eficiente (especialmente " -"si el\n" +"Por lo general, no es la forma más eficiente de combinar cadenas: una serie de `push`\n" +"operaciones en una cadena mutable suele ser la más eficiente (especialmente si el\n" "cadena se ha preasignado al tamaño esperado)." #: src\idioms/ctor.md:1 @@ -918,13 +805,10 @@ msgstr "## Descripción\r" #, fuzzy msgid "" "Rust does not have constructors as a language construct. Instead, the\r\n" -"convention is to use an [associated function][associated function] `new` to " -"create an object:" +"convention is to use an [associated function][associated function] `new` to create an object:" msgstr "" -"Rust no tiene constructores como una construcción de lenguaje. En cambio, " -"el\r\n" -"la convención es usar una [función asociada][función asociada] `nueva` para " -"crear un objeto:" +"Rust no tiene constructores como una construcción de lenguaje. En cambio, el\r\n" +"la convención es usar una [función asociada][función asociada] `nueva` para crear un objeto:" #: src\idioms/ctor.md:8 msgid "" @@ -963,11 +847,8 @@ msgstr "## Constructores predeterminados\r" #: src\idioms/ctor.md:37 #, fuzzy -msgid "" -"Rust supports default constructors with the [`Default`][std-default] trait:" -msgstr "" -"Rust admite constructores predeterminados con el rasgo " -"[`Default`][std-default]:" +msgid "Rust supports default constructors with the [`Default`][std-default] trait:" +msgstr "Rust admite constructores predeterminados con el rasgo [`Default`][std-default]:" #: src\idioms/ctor.md:39 msgid "" @@ -1002,12 +883,10 @@ msgstr "" #: src\idioms/ctor.md:66 #, fuzzy msgid "" -"`Default` can also be derived if all types of all fields implement " -"`Default`,\r\n" +"`Default` can also be derived if all types of all fields implement `Default`,\r\n" "like they do with `Second`:" msgstr "" -"`Predeterminado` también se puede derivar si todos los tipos de todos los " -"campos implementan `Predeterminado`,\r\n" +"`Predeterminado` también se puede derivar si todos los tipos de todos los campos implementan `Predeterminado`,\r\n" "como lo hacen con `Second`:" #: src\idioms/ctor.md:69 @@ -1045,8 +924,7 @@ msgid "" "should, even if it is functionally identical to default." msgstr "" "**Nota:** Es común y se espera que los tipos implementen ambos\r\n" -"'Predeterminado' y un constructor 'nuevo' vacío. `nuevo` es el " -"constructor\r\n" +"'Predeterminado' y un constructor 'nuevo' vacío. `nuevo` es el constructor\r\n" "convención en Rust, y los usuarios esperan que exista, por lo que si es\r\n" "razonable que el constructor básico no tome argumentos, entonces\r\n" "debería, incluso si es funcionalmente idéntico al predeterminado." @@ -1054,18 +932,13 @@ msgstr "" #: src\idioms/ctor.md:97 #, fuzzy msgid "" -"**Hint:** The advantage of implementing or deriving `Default` is that your " -"type\r\n" -"can now be used where a `Default` implementation is required, most " -"prominently,\r\n" +"**Hint:** The advantage of implementing or deriving `Default` is that your type\r\n" +"can now be used where a `Default` implementation is required, most prominently,\r\n" "any of the [`*or_default` functions in the standard library][std-or-default]." msgstr "" -"**Sugerencia:** La ventaja de implementar o derivar `Default` es que su " -"tipo\r\n" -"ahora se puede usar donde se requiere una implementación 'Predeterminada', " -"más prominentemente,\r\n" -"cualquiera de las funciones [`*or_default` en la biblioteca " -"estándar][std-or-default]." +"**Sugerencia:** La ventaja de implementar o derivar `Default` es que su tipo\r\n" +"ahora se puede usar donde se requiere una implementación 'Predeterminada', más prominentemente,\r\n" +"cualquiera de las funciones [`*or_default` en la biblioteca estándar][std-or-default]." #: src\idioms/ctor.md:101 #, fuzzy @@ -1078,20 +951,17 @@ msgid "" "- The [default idiom](default.md) for a more in-depth description of the\r\n" " `Default` trait.\r\n" "\r\n" -"- The [builder pattern](../patterns/creational/builder.md) for " -"constructing\r\n" +"- The [builder pattern](../patterns/creational/builder.md) for constructing\r\n" " objects where there are multiple configurations.\r\n" "\r\n" "- [API Guidelines/C-COMMON-TRAITS][API Guidelines/C-COMMON-TRAITS] for\r\n" " implementing both, `Default` and `new`.\r\n" "\r" msgstr "" -"- El [modismo predeterminado](default.md) para una descripción más detallada " -"del\r\n" +"- El [modismo predeterminado](default.md) para una descripción más detallada del\r\n" " Rasgo 'predeterminado'.\r\n" "\r\n" -"- El [patrón del constructor] (../patterns/creational/builder.md) para " -"construir\r\n" +"- El [patrón del constructor] (../patterns/creational/builder.md) para construir\r\n" " objetos donde hay múltiples configuraciones.\r\n" "\r\n" "- [Directrices API/C-COMMON-TRAITS][Directrices API/C-COMMON-TRAITS] para\r\n" @@ -1106,11 +976,9 @@ msgstr "# El rasgo `Por defecto`" #: src\idioms/default.md:5 msgid "" "Many types in Rust have a [constructor]. However, this is _specific_ to the\n" -"type; Rust cannot abstract over \"everything that has a `new()` method\". " -"To\n" +"type; Rust cannot abstract over \"everything that has a `new()` method\". To\n" "allow this, the [`Default`] trait was conceived, which can be used with\n" -"containers and other generic types (e.g. see " -"[`Option::unwrap_or_default()`]).\n" +"containers and other generic types (e.g. see [`Option::unwrap_or_default()`]).\n" "Notably, some containers already implement it where applicable." msgstr "" @@ -1123,10 +991,8 @@ msgid "" "types implement `Default`, the more useful it becomes." msgstr "" "No solo implementan contenedores de un elemento como `Cow`, `Box` o `Arc`\n" -"'Predeterminado' para los tipos 'Predeterminados' contenidos, uno puede " -"automáticamente\n" -"`#[derive(Default)]` para estructuras cuyos campos lo implementan, así que " -"cuanto más\n" +"'Predeterminado' para los tipos 'Predeterminados' contenidos, uno puede automáticamente\n" +"`#[derive(Default)]` para estructuras cuyos campos lo implementan, así que cuanto más\n" "tipos implementan `Default`, más útil se vuelve." #: src\idioms/default.md:16 @@ -1136,12 +1002,9 @@ msgid "" "`default()` method does not. There can even be multiple constructors with\n" "different names, but there can only be one `Default` implementation per type." msgstr "" -"Por otro lado, los constructores pueden tomar múltiples argumentos, mientras " -"que los\n" -"El método `default()` no lo hace. Incluso puede haber múltiples " -"constructores con\n" -"nombres diferentes, pero solo puede haber una implementación " -"`Predeterminada` por tipo." +"Por otro lado, los constructores pueden tomar múltiples argumentos, mientras que los\n" +"El método `default()` no lo hace. Incluso puede haber múltiples constructores con\n" +"nombres diferentes, pero solo puede haber una implementación `Predeterminada` por tipo." #: src\idioms/default.md:22 msgid "" @@ -1172,8 +1035,7 @@ msgid "" " conf.check = true;\n" " println!(\"conf = {:#?}\", conf);\n" " \n" -" // partial initialization with default values, creates the same " -"instance\n" +" // partial initialization with default values, creates the same instance\n" " let conf1 = MyConfiguration {\n" " check: true,\n" " ..Default::default()\n" @@ -1186,18 +1048,15 @@ msgstr "" #: src\idioms/default.md:60 #, fuzzy msgid "" -"- The [constructor] idiom is another way to generate instances that may or " -"may\n" +"- The [constructor] idiom is another way to generate instances that may or may\n" " not be \"default\"\n" "- The [`Default`] documentation (scroll down for the list of implementors)\n" "- [`Option::unwrap_or_default()`]\n" "- [`derive(new)`]" msgstr "" -"- El lenguaje [constructor] es otra forma de generar instancias que pueden o " -"pueden\n" +"- El lenguaje [constructor] es otra forma de generar instancias que pueden o pueden\n" " no ser \"predeterminado\"\n" -"- La documentación [`Default`] (desplácese hacia abajo para ver la lista de " -"implementadores)\n" +"- La documentación [`Default`] (desplácese hacia abajo para ver la lista de implementadores)\n" "- [`Opción::unwrap_or_default()`]\n" "- [`derivar(nuevo)`]" @@ -1214,8 +1073,7 @@ msgid "" "and borrowed views of data." msgstr "" "Utilice [`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)\n" -"rasgo para tratar las colecciones como punteros inteligentes, ofreciendo " -"propiedad\n" +"rasgo para tratar las colecciones como punteros inteligentes, ofreciendo propiedad\n" "y vistas prestadas de datos." #: src\idioms/deref.md:11 @@ -1241,23 +1099,16 @@ msgstr "" #: src\idioms/deref.md:28 #, fuzzy msgid "" -"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a " -"borrowed\n" -"collection of `T`s. Implementing `Deref` for `Vec` allows implicit " -"dereferencing\n" +"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a borrowed\n" +"collection of `T`s. Implementing `Deref` for `Vec` allows implicit dereferencing\n" "from `&Vec` to `&[T]` and includes the relationship in auto-derefencing\n" -"searches. Most methods you might expect to be implemented for `Vec`s are " -"instead\n" +"searches. Most methods you might expect to be implemented for `Vec`s are instead\n" "implemented for slices." msgstr "" -"Un `Vec` es una colección propietaria de `T`s, mientras que un segmento " -"(`&[T]`) es un préstamo\n" -"colección de `T`s. La implementación de `Deref` para `Vec` permite la " -"desreferenciación implícita\n" -"de `&Vec` a `&[T]` e incluye la relación en la eliminación automática de " -"referencias\n" -"búsquedas. La mayoría de los métodos que podría esperar que se implementen " -"para `Vec`s son en su lugar\n" +"Un `Vec` es una colección propietaria de `T`s, mientras que un segmento (`&[T]`) es un préstamo\n" +"colección de `T`s. La implementación de `Deref` para `Vec` permite la desreferenciación implícita\n" +"de `&Vec` a `&[T]` e incluye la relación en la eliminación automática de referencias\n" +"búsquedas. La mayoría de los métodos que podría esperar que se implementen para `Vec`s son en su lugar\n" "implementado para rebanadas." #: src\idioms/deref.md:34 @@ -1265,18 +1116,12 @@ msgstr "" msgid "Also `String` and `&str` have a similar relation." msgstr "También `String` y `&str` tienen una relación similar." -#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 -#: src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 -#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 -#: src\idioms/return-consumed-arg-on-error.md:43 -#: src\patterns/behavioural/command.md:8 -#: src\patterns/behavioural/interpreter.md:16 -#: src\patterns/behavioural/newtype.md:56 src\patterns/behavioural/RAII.md:72 -#: src\patterns/behavioural/strategy.md:19 -#: src\patterns/behavioural/visitor.md:72 src\patterns/creational/builder.md:63 -#: src\patterns/creational/fold.md:73 -#: src\patterns/structural/compose-structs.md:71 src\patterns/ffi/export.md:15 -#: src\anti_patterns/borrow_clone.md:30 +#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 +#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 src\idioms/return-consumed-arg-on-error.md:43 +#: src\patterns/behavioural/command.md:8 src\patterns/behavioural/interpreter.md:16 src\patterns/behavioural/newtype.md:56 +#: src\patterns/behavioural/RAII.md:72 src\patterns/behavioural/strategy.md:19 src\patterns/behavioural/visitor.md:72 +#: src\patterns/creational/builder.md:63 src\patterns/creational/fold.md:73 src\patterns/structural/compose-structs.md:71 +#: src\patterns/ffi/export.md:15 src\anti_patterns/borrow_clone.md:30 #, fuzzy msgid "## Motivation" msgstr "## Motivación" @@ -1284,19 +1129,14 @@ msgstr "## Motivación" #: src\idioms/deref.md:38 #, fuzzy msgid "" -"Ownership and borrowing are key aspects of the Rust language. Data " -"structures\n" +"Ownership and borrowing are key aspects of the Rust language. Data structures\n" "must account for these semantics properly to give a good user\n" -"experience. When implementing a data structure that owns its data, offering " -"a\n" +"experience. When implementing a data structure that owns its data, offering a\n" "borrowed view of that data allows for more flexible APIs." msgstr "" -"La propiedad y el préstamo son aspectos clave del lenguaje Rust. Estructuras " -"de datos\n" -"debe tener en cuenta esta semántica correctamente para dar a un buen " -"usuario\n" -"experiencia. Al implementar una estructura de datos que posee sus datos, " -"ofrecer una\n" +"La propiedad y el préstamo son aspectos clave del lenguaje Rust. Estructuras de datos\n" +"debe tener en cuenta esta semántica correctamente para dar a un buen usuario\n" +"experiencia. Al implementar una estructura de datos que posee sus datos, ofrecer una\n" "La vista prestada de esos datos permite API más flexibles." #: src\idioms/deref.md:45 @@ -1305,40 +1145,29 @@ msgid "" "Most methods can be implemented only for the borrowed view, they are then\n" "implicitly available for the owning view." msgstr "" -"La mayoría de los métodos se pueden implementar solo para la vista prestada, " -"luego se\n" +"La mayoría de los métodos se pueden implementar solo para la vista prestada, luego se\n" "implícitamente disponible para la vista propietaria." #: src\idioms/deref.md:48 #, fuzzy msgid "Gives clients a choice between borrowing or taking ownership of data." -msgstr "" -"Brinda a los clientes la opción de tomar prestados o tomar posesión de los " -"datos." +msgstr "Brinda a los clientes la opción de tomar prestados o tomar posesión de los datos." #: src\idioms/deref.md:52 #, fuzzy msgid "" -"Methods and traits only available via dereferencing are not taken into " -"account\n" -"when bounds checking, so generic programming with data structures using " -"this\n" +"Methods and traits only available via dereferencing are not taken into account\n" +"when bounds checking, so generic programming with data structures using this\n" "pattern can get complex (see the `Borrow` and `AsRef` traits, etc.)." msgstr "" -"No se tienen en cuenta los métodos y características que solo están " -"disponibles a través de la desreferenciación.\n" -"cuando se verifican los límites, por lo que la programación genérica con " -"estructuras de datos usa esto\n" +"No se tienen en cuenta los métodos y características que solo están disponibles a través de la desreferenciación.\n" +"cuando se verifican los límites, por lo que la programación genérica con estructuras de datos usa esto\n" "El patrón puede volverse complejo (ver los rasgos `Borrow` y `AsRef`, etc.)." -#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 -#: src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 -#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 -#: src\patterns/behavioural/interpreter.md:103 -#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 -#: src\patterns/behavioural/strategy.md:110 -#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 -#: src\patterns/creational/fold.md:85 +#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 +#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 src\patterns/behavioural/interpreter.md:103 +#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 src\patterns/behavioural/strategy.md:110 +#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 src\patterns/creational/fold.md:85 #: src\patterns/structural/compose-structs.md:89 src\anti_patterns/deref.md:102 #, fuzzy msgid "## Discussion" @@ -1347,78 +1176,56 @@ msgstr "## Discusión" #: src\idioms/deref.md:58 #, fuzzy msgid "" -"Smart pointers and collections are analogous: a smart pointer points to a " -"single\n" -"object, whereas a collection points to many objects. From the point of view " -"of\n" -"the type system, there is little difference between the two. A collection " -"owns\n" +"Smart pointers and collections are analogous: a smart pointer points to a single\n" +"object, whereas a collection points to many objects. From the point of view of\n" +"the type system, there is little difference between the two. A collection owns\n" "its data if the only way to access each datum is via the collection and the\n" "collection is responsible for deleting the data (even in cases of shared\n" -"ownership, some kind of borrowed view may be appropriate). If a collection " -"owns\n" -"its data, it is usually useful to provide a view of the data as borrowed so " -"that\n" +"ownership, some kind of borrowed view may be appropriate). If a collection owns\n" +"its data, it is usually useful to provide a view of the data as borrowed so that\n" "it can be referenced multiple times." msgstr "" -"Los punteros inteligentes y las colecciones son análogos: un puntero " -"inteligente apunta a un solo\n" -"objeto, mientras que una colección apunta a muchos objetos. Desde el punto " -"de vista de\n" +"Los punteros inteligentes y las colecciones son análogos: un puntero inteligente apunta a un solo\n" +"objeto, mientras que una colección apunta a muchos objetos. Desde el punto de vista de\n" "el sistema de tipos, hay poca diferencia entre los dos. Una colección posee\n" -"sus datos si la única forma de acceder a cada dato es a través de la " -"recopilación y el\n" -"recogida es responsable de la eliminación de los datos (incluso en los casos " -"de compartir\n" -"propiedad, algún tipo de vista prestada puede ser apropiado). Si una " -"colección posee\n" -"sus datos, por lo general es útil proporcionar una vista de los datos como " -"prestados para que\n" +"sus datos si la única forma de acceder a cada dato es a través de la recopilación y el\n" +"recogida es responsable de la eliminación de los datos (incluso en los casos de compartir\n" +"propiedad, algún tipo de vista prestada puede ser apropiado). Si una colección posee\n" +"sus datos, por lo general es útil proporcionar una vista de los datos como prestados para que\n" "puede ser referenciado varias veces." #: src\idioms/deref.md:67 #, fuzzy msgid "" "Most smart pointers (e.g., `Foo`) implement `Deref`. However,\n" -"collections will usually dereference to a custom type. `[T]` and `str` have " -"some\n" -"language support, but in the general case, this is not necessary. `Foo` " -"can\n" -"implement `Deref>` where `Bar` is a dynamically sized type " -"and\n" +"collections will usually dereference to a custom type. `[T]` and `str` have some\n" +"language support, but in the general case, this is not necessary. `Foo` can\n" +"implement `Deref>` where `Bar` is a dynamically sized type and\n" "`&Bar` is a borrowed view of the data in `Foo`." msgstr "" -"La mayoría de los punteros inteligentes (por ejemplo, `Foo`) implementan " -"`Deref`. Sin embargo,\n" -"las colecciones por lo general dejarán de hacer referencia a un tipo " -"personalizado. `[T]` y `str` tienen algunos\n" -"soporte de idioma, pero en el caso general, esto no es necesario. `Foo` " -"puede\n" -"implementar `Deref>` donde `Bar` es un tipo de tamaño dinámico " -"y\n" +"La mayoría de los punteros inteligentes (por ejemplo, `Foo`) implementan `Deref`. Sin embargo,\n" +"las colecciones por lo general dejarán de hacer referencia a un tipo personalizado. `[T]` y `str` tienen algunos\n" +"soporte de idioma, pero en el caso general, esto no es necesario. `Foo` puede\n" +"implementar `Deref>` donde `Bar` es un tipo de tamaño dinámico y\n" "`&Bar` es una vista prestada de los datos en `Foo`." #: src\idioms/deref.md:73 #, fuzzy msgid "" -"Commonly, ordered collections will implement `Index` for `Range`s to " -"provide\n" +"Commonly, ordered collections will implement `Index` for `Range`s to provide\n" "slicing syntax. The target will be the borrowed view." msgstr "" -"Comúnmente, las colecciones ordenadas implementarán `Index` para `Range`s " -"para proporcionar\n" +"Comúnmente, las colecciones ordenadas implementarán `Index` para `Range`s para proporcionar\n" "sintaxis de corte. El objetivo será la vista prestada." #: src\idioms/deref.md:78 #, fuzzy msgid "" "- [Deref polymorphism anti-pattern](../anti_patterns/deref.md).\n" -"- [Documentation for `Deref` " -"trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." msgstr "" "- [Antipatrón de polimorfismo de deref](../anti_patterns/deref.md).\n" -"- [Documentación para el rasgo " -"`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentación para el rasgo `Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." #: src\idioms/dtor-finally.md:1 #, fuzzy @@ -1428,16 +1235,12 @@ msgstr "# Finalización en destructores" #: src\idioms/dtor-finally.md:5 #, fuzzy msgid "" -"Rust does not provide the equivalent to `finally` blocks - code that will " -"be\n" -"executed no matter how a function is exited. Instead, an object's destructor " -"can\n" +"Rust does not provide the equivalent to `finally` blocks - code that will be\n" +"executed no matter how a function is exited. Instead, an object's destructor can\n" "be used to run code that must be run before exit." msgstr "" -"Rust no proporciona el equivalente a los bloques `finally` - código que " -"será\n" -"se ejecuta sin importar cómo se sale de una función. En cambio, el " -"destructor de un objeto puede\n" +"Rust no proporciona el equivalente a los bloques `finally` - código que será\n" +"se ejecuta sin importar cómo se sale de una función. En cambio, el destructor de un objeto puede\n" "usarse para ejecutar código que debe ejecutarse antes de salir." #: src\idioms/dtor-finally.md:11 @@ -1467,30 +1270,20 @@ msgstr "" #: src\idioms/dtor-finally.md:34 #, fuzzy msgid "" -"If a function has multiple return points, then executing code on exit " -"becomes\n" -"difficult and repetitive (and thus bug-prone). This is especially the case " -"where\n" +"If a function has multiple return points, then executing code on exit becomes\n" +"difficult and repetitive (and thus bug-prone). This is especially the case where\n" "return is implicit due to a macro. A common case is the `?` operator which\n" -"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used " -"as\n" -"an exception handling mechanism, but unlike Java (which has `finally`), " -"there is\n" +"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used as\n" +"an exception handling mechanism, but unlike Java (which has `finally`), there is\n" "no way to schedule code to run in both the normal and exceptional cases.\n" "Panicking will also exit a function early." msgstr "" -"Si una función tiene varios puntos de retorno, la ejecución del código al " -"salir se vuelve\n" -"difícil y repetitivo (y por lo tanto propenso a errores). Este es " -"especialmente el caso donde\n" -"el retorno es implícito debido a una macro. Un caso común es el operador `?` " -"que\n" -"devuelve si el resultado es `Err`, pero continúa si es `Ok`. `?` se utiliza " -"como\n" -"un mecanismo de manejo de excepciones, pero a diferencia de Java (que tiene " -"`finally`), hay\n" -"no hay forma de programar el código para que se ejecute tanto en casos " -"normales como excepcionales.\n" +"Si una función tiene varios puntos de retorno, la ejecución del código al salir se vuelve\n" +"difícil y repetitivo (y por lo tanto propenso a errores). Este es especialmente el caso donde\n" +"el retorno es implícito debido a una macro. Un caso común es el operador `?` que\n" +"devuelve si el resultado es `Err`, pero continúa si es `Ok`. `?` se utiliza como\n" +"un mecanismo de manejo de excepciones, pero a diferencia de Java (que tiene `finally`), hay\n" +"no hay forma de programar el código para que se ejecute tanto en casos normales como excepcionales.\n" "El pánico también hará que salga de una función antes de tiempo." #: src\idioms/dtor-finally.md:44 @@ -1499,8 +1292,7 @@ msgid "" "Code in destructors will (nearly) always be run - copes with panics, early\n" "returns, etc." msgstr "" -"El código en los destructores (casi) siempre se ejecutará: hace frente a " -"pánicos, temprano\n" +"El código en los destructores (casi) siempre se ejecutará: hace frente a pánicos, temprano\n" "devoluciones, etc" #: src\idioms/dtor-finally.md:49 @@ -1509,87 +1301,61 @@ msgid "" "It is not guaranteed that destructors will run. For example, if there is an\n" "infinite loop in a function or if running a function crashes before exit.\n" "Destructors are also not run in the case of a panic in an already panicking\n" -"thread. Therefore, destructors cannot be relied on as finalizers where it " -"is\n" +"thread. Therefore, destructors cannot be relied on as finalizers where it is\n" "absolutely essential that finalisation happens." msgstr "" "No se garantiza que los destructores funcionen. Por ejemplo, si hay un\n" -"bucle infinito en una función o si la ejecución de una función falla antes " -"de salir.\n" -"Los destructores tampoco se ejecutan en caso de pánico en un país que ya " -"está en pánico.\n" -"hilo. Por lo tanto, no se puede confiar en los destructores como " -"finalizadores donde es\n" +"bucle infinito en una función o si la ejecución de una función falla antes de salir.\n" +"Los destructores tampoco se ejecutan en caso de pánico en un país que ya está en pánico.\n" +"hilo. Por lo tanto, no se puede confiar en los destructores como finalizadores donde es\n" "absolutamente esencial que ocurra la finalización." #: src\idioms/dtor-finally.md:55 #, fuzzy msgid "" -"This pattern introduces some hard to notice, implicit code. Reading a " -"function\n" +"This pattern introduces some hard to notice, implicit code. Reading a function\n" "gives no clear indication of destructors to be run on exit. This can make\n" "debugging tricky." msgstr "" -"Este patrón introduce un código implícito difícil de notar. Lectura de una " -"función\n" -"no da una indicación clara de los destructores que se ejecutarán en la " -"salida. esto puede hacer\n" +"Este patrón introduce un código implícito difícil de notar. Lectura de una función\n" +"no da una indicación clara de los destructores que se ejecutarán en la salida. esto puede hacer\n" "depuración complicada." #: src\idioms/dtor-finally.md:59 #, fuzzy -msgid "" -"Requiring an object and `Drop` impl just for finalisation is heavy on " -"boilerplate." -msgstr "" -"Requerir un objeto y el impl `Drop` solo para la finalización es pesado en " -"el modelo." +msgid "Requiring an object and `Drop` impl just for finalisation is heavy on boilerplate." +msgstr "Requerir un objeto y el impl `Drop` solo para la finalización es pesado en el modelo." #: src\idioms/dtor-finally.md:63 #, fuzzy msgid "" "There is some subtlety about how exactly to store the object used as a\n" -"finalizer. It must be kept alive until the end of the function and must then " -"be\n" -"destroyed. The object must always be a value or uniquely owned pointer " -"(e.g.,\n" -"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer " -"can\n" +"finalizer. It must be kept alive until the end of the function and must then be\n" +"destroyed. The object must always be a value or uniquely owned pointer (e.g.,\n" +"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer can\n" "be kept alive beyond the lifetime of the function. For similar reasons, the\n" "finalizer should not be moved or returned." msgstr "" -"Hay cierta sutileza sobre cómo almacenar exactamente el objeto utilizado " -"como\n" -"finalizador Debe mantenerse vivo hasta el final de la función y luego debe " -"ser\n" -"destruido. El objeto siempre debe ser un valor o un puntero de propiedad " -"única (por ejemplo,\n" -"`Cuadro`). Si se usa un puntero compartido (como `Rc`), entonces el " -"finalizador puede\n" -"mantenerse vivo más allá del tiempo de vida de la función. Por razones " -"similares, el\n" +"Hay cierta sutileza sobre cómo almacenar exactamente el objeto utilizado como\n" +"finalizador Debe mantenerse vivo hasta el final de la función y luego debe ser\n" +"destruido. El objeto siempre debe ser un valor o un puntero de propiedad única (por ejemplo,\n" +"`Cuadro`). Si se usa un puntero compartido (como `Rc`), entonces el finalizador puede\n" +"mantenerse vivo más allá del tiempo de vida de la función. Por razones similares, el\n" "el finalizador no debe moverse ni devolverse." #: src\idioms/dtor-finally.md:70 #, fuzzy msgid "" -"The finalizer must be assigned into a variable, otherwise it will be " -"destroyed\n" -"immediately, rather than when it goes out of scope. The variable name must " -"start\n" -"with `_` if the variable is only used as a finalizer, otherwise the " -"compiler\n" -"will warn that the finalizer is never used. However, do not call the " -"variable\n" +"The finalizer must be assigned into a variable, otherwise it will be destroyed\n" +"immediately, rather than when it goes out of scope. The variable name must start\n" +"with `_` if the variable is only used as a finalizer, otherwise the compiler\n" +"will warn that the finalizer is never used. However, do not call the variable\n" "`_` with no suffix - in that case it will be destroyed immediately." msgstr "" "El finalizador debe asignarse a una variable, de lo contrario, se destruirá\n" -"inmediatamente, en lugar de cuando se sale del alcance. El nombre de la " -"variable debe comenzar\n" -"con `_` si la variable solo se usa como finalizador, de lo contrario, el " -"compilador\n" -"advertirá que el finalizador nunca se utiliza. Sin embargo, no llame a la " -"variable\n" +"inmediatamente, en lugar de cuando se sale del alcance. El nombre de la variable debe comenzar\n" +"con `_` si la variable solo se usa como finalizador, de lo contrario, el compilador\n" +"advertirá que el finalizador nunca se utiliza. Sin embargo, no llame a la variable\n" "`_` sin sufijo - en ese caso será destruido inmediatamente." #: src\idioms/dtor-finally.md:76 @@ -1598,40 +1364,28 @@ msgid "" "In Rust, destructors are run when an object goes out of scope. This happens\n" "whether we reach the end of block, there is an early return, or the program\n" "panics. When panicking, Rust unwinds the stack running destructors for each\n" -"object in each stack frame. So, destructors get called even if the panic " -"happens\n" +"object in each stack frame. So, destructors get called even if the panic happens\n" "in a function being called." msgstr "" -"En Rust, los destructores se ejecutan cuando un objeto queda fuera del " -"alcance. Esto pasa\n" -"ya sea que lleguemos al final del bloque, que haya un regreso anticipado o " -"que el programa\n" -"entra en pánico Cuando entra en pánico, Rust desenrolla la pila ejecutando " -"destructores para cada\n" -"objeto en cada marco de pila. Entonces, se llama a los destructores incluso " -"si ocurre el pánico.\n" +"En Rust, los destructores se ejecutan cuando un objeto queda fuera del alcance. Esto pasa\n" +"ya sea que lleguemos al final del bloque, que haya un regreso anticipado o que el programa\n" +"entra en pánico Cuando entra en pánico, Rust desenrolla la pila ejecutando destructores para cada\n" +"objeto en cada marco de pila. Entonces, se llama a los destructores incluso si ocurre el pánico.\n" "en una función que se está llamando." #: src\idioms/dtor-finally.md:82 #, fuzzy msgid "" -"If a destructor panics while unwinding, there is no good action to take, so " -"Rust\n" -"aborts the thread immediately, without running further destructors. This " -"means\n" -"that destructors are not absolutely guaranteed to run. It also means that " -"you\n" +"If a destructor panics while unwinding, there is no good action to take, so Rust\n" +"aborts the thread immediately, without running further destructors. This means\n" +"that destructors are not absolutely guaranteed to run. It also means that you\n" "must take extra care in your destructors not to panic, since it could leave\n" "resources in an unexpected state." msgstr "" -"Si un destructor entra en pánico mientras se desenrolla, no hay una buena " -"acción que tomar, por lo que Rust\n" -"aborta el subproceso inmediatamente, sin ejecutar más destructores. Esto " -"significa\n" -"que los destructores no están absolutamente garantizados para funcionar. " -"También significa que usted\n" -"debe tener especial cuidado en sus destructores para no entrar en pánico, ya " -"que podría salir\n" +"Si un destructor entra en pánico mientras se desenrolla, no hay una buena acción que tomar, por lo que Rust\n" +"aborta el subproceso inmediatamente, sin ejecutar más destructores. Esto significa\n" +"que los destructores no están absolutamente garantizados para funcionar. También significa que usted\n" +"debe tener especial cuidado en sus destructores para no entrar en pánico, ya que podría salir\n" "recursos en un estado inesperado." #: src\idioms/dtor-finally.md:90 @@ -1642,9 +1396,7 @@ msgstr "[Guardias RAII](../patrones/comportamiento/RAII.md)." #: src\idioms/mem-replace.md:1 #, fuzzy msgid "# `mem::{take(_), replace(_)}` to keep owned values in changed enums" -msgstr "" -"# `mem::{take(_), replace(_)}` para mantener los valores propios en las " -"enumeraciones modificadas" +msgstr "# `mem::{take(_), replace(_)}` para mantener los valores propios en las enumeraciones modificadas" #: src\idioms/mem-replace.md:5 #, fuzzy @@ -1654,8 +1406,7 @@ msgid "" "`MyEnum::A` to a `B` if `x` is zero, while keeping `MyEnum::B` intact." msgstr "" "Digamos que tenemos un `&mut MyEnum` que tiene (al menos) dos variantes,\n" -"`A { nombre: Cadena, x: u8 }` y `B { nombre: Cadena }`. Ahora queremos " -"cambiar\n" +"`A { nombre: Cadena, x: u8 }` y `B { nombre: Cadena }`. Ahora queremos cambiar\n" "`MyEnum::A` a `B` si `x` es cero, manteniendo `MyEnum::B` intacto." #: src\idioms/mem-replace.md:9 @@ -1705,8 +1456,7 @@ msgid "" "fn swizzle(e: &mut MultiVariateEnum) {\n" " use MultiVariateEnum::*;\n" " *e = match e {\n" -" // Ownership rules do not allow taking `name` by value, but we " -"cannot\n" +" // Ownership rules do not allow taking `name` by value, but we cannot\n" " // take the value out of a mutable reference, unless we replace it:\n" " A { name } => B { name: mem::take(name) },\n" " B { name } => A { name: mem::take(name) },\n" @@ -1720,64 +1470,45 @@ msgstr "" #: src\idioms/mem-replace.md:59 #, fuzzy msgid "" -"When working with enums, we may want to change an enum value in place, " -"perhaps\n" +"When working with enums, we may want to change an enum value in place, perhaps\n" "to another variant. This is usually done in two phases to keep the borrow\n" -"checker happy. In the first phase, we observe the existing value and look " -"at\n" -"its parts to decide what to do next. In the second phase we may " -"conditionally\n" +"checker happy. In the first phase, we observe the existing value and look at\n" +"its parts to decide what to do next. In the second phase we may conditionally\n" "change the value (as in the example above)." msgstr "" -"Al trabajar con enumeraciones, es posible que deseemos cambiar un valor de " -"enumeración en su lugar, tal vez\n" -"a otra variante. Esto generalmente se hace en dos fases para mantener el " -"préstamo\n" -"corrector feliz. En la primera fase, observamos el valor existente y " -"miramos\n" -"sus partes para decidir qué hacer a continuación. En la segunda fase podemos " -"condicionalmente\n" +"Al trabajar con enumeraciones, es posible que deseemos cambiar un valor de enumeración en su lugar, tal vez\n" +"a otra variante. Esto generalmente se hace en dos fases para mantener el préstamo\n" +"corrector feliz. En la primera fase, observamos el valor existente y miramos\n" +"sus partes para decidir qué hacer a continuación. En la segunda fase podemos condicionalmente\n" "cambiar el valor (como en el ejemplo anterior)." #: src\idioms/mem-replace.md:65 #, fuzzy msgid "" "The borrow checker won't allow us to take out `name` of the enum (because\n" -"_something_ must be there.) We could of course `.clone()` name and put the " -"clone\n" -"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy " -"the borrow checker](../anti_patterns/borrow_clone.md) anti-pattern. Anyway, " -"we\n" +"_something_ must be there.) We could of course `.clone()` name and put the clone\n" +"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md) " +"anti-pattern. Anyway, we\n" "can avoid the extra allocation by changing `e` with only a mutable borrow." msgstr "" -"El verificador de préstamos no nos permitirá sacar el `nombre` de la " -"enumeración (porque\n" -"_algo_ debe estar allí.) Podríamos, por supuesto, el nombre `.clone()` y " -"poner el clon\n" -"en nuestro `MyEnum::B`, pero eso sería una instancia del antipatrón [Clonar " -"para satisfacer el comprobador de " -"préstamos](../anti_patterns/borrow_clone.md). De todos modos, nosotros\n" -"puede evitar la asignación adicional cambiando `e` con solo un préstamo " -"mutable." +"El verificador de préstamos no nos permitirá sacar el `nombre` de la enumeración (porque\n" +"_algo_ debe estar allí.) Podríamos, por supuesto, el nombre `.clone()` y poner el clon\n" +"en nuestro `MyEnum::B`, pero eso sería una instancia del antipatrón [Clonar para satisfacer el comprobador de préstamos](../" +"anti_patterns/borrow_clone.md). De todos modos, nosotros\n" +"puede evitar la asignación adicional cambiando `e` con solo un préstamo mutable." #: src\idioms/mem-replace.md:70 #, fuzzy msgid "" -"`mem::take` lets us swap out the value, replacing it with it's default " -"value,\n" -"and returning the previous value. For `String`, the default value is an " -"empty\n" +"`mem::take` lets us swap out the value, replacing it with it's default value,\n" +"and returning the previous value. For `String`, the default value is an empty\n" "`String`, which does not need to allocate. As a result, we get the original\n" "`name` _as an owned value_. We can then wrap this in another enum." msgstr "" -"`mem::take` nos permite intercambiar el valor, reemplazándolo con su valor " -"predeterminado,\n" -"y devolviendo el valor anterior. Para `String`, el valor predeterminado es " -"un vacío\n" -"`String`, que no es necesario asignar. Como resultado, obtenemos el " -"original.\n" -"`nombre` _como valor propio_. Luego podemos envolver esto en otra " -"enumeración." +"`mem::take` nos permite intercambiar el valor, reemplazándolo con su valor predeterminado,\n" +"y devolviendo el valor anterior. Para `String`, el valor predeterminado es un vacío\n" +"`String`, que no es necesario asignar. Como resultado, obtenemos el original.\n" +"`nombre` _como valor propio_. Luego podemos envolver esto en otra enumeración." #: src\idioms/mem-replace.md:75 #, fuzzy @@ -1797,19 +1528,14 @@ msgid "" "value with a `None`, `Option`’s `take()` method provides a shorter and\n" "more idiomatic alternative." msgstr "" -"Tenga en cuenta, sin embargo, que si estamos usando una `Opción` y queremos " -"reemplazar su\n" -"valor con `Ninguno`, el método `take()` de `Option` proporciona un método " -"más corto y\n" +"Tenga en cuenta, sin embargo, que si estamos usando una `Opción` y queremos reemplazar su\n" +"valor con `Ninguno`, el método `take()` de `Option` proporciona un método más corto y\n" "alternativa más idiomática." #: src\idioms/mem-replace.md:85 #, fuzzy -msgid "" -"Look ma, no allocation! Also you may feel like Indiana Jones while doing it." -msgstr "" -"¡Mira mamá, no hay asignación! También puedes sentirte como Indiana Jones " -"mientras lo haces." +msgid "Look ma, no allocation! Also you may feel like Indiana Jones while doing it." +msgstr "¡Mira mamá, no hay asignación! También puedes sentirte como Indiana Jones mientras lo haces." #: src\idioms/mem-replace.md:89 #, fuzzy @@ -1820,21 +1546,18 @@ msgid "" "languages." msgstr "" "Esto se pone un poco prolijo. Hacerlo mal repetidamente te hará odiar el\n" -"prestador de cheques. El compilador puede fallar al optimizar el almacén " -"doble,\n" -"lo que resulta en un rendimiento reducido en comparación con lo que haría en " -"un entorno inseguro\n" +"prestador de cheques. El compilador puede fallar al optimizar el almacén doble,\n" +"lo que resulta en un rendimiento reducido en comparación con lo que haría en un entorno inseguro\n" "idiomas" #: src\idioms/mem-replace.md:94 #, fuzzy msgid "" -"Furthermore, the type you are taking needs to implement the [`Default` " -"trait](./default.md). However, if the type you're working with doesn't\n" +"Furthermore, the type you are taking needs to implement the [`Default` trait](./default.md). However, if the type you're working with " +"doesn't\n" "implement this, you can instead use `mem::replace`." msgstr "" -"Además, el tipo que está tomando debe implementar el [rasgo " -"`Predeterminado`] (./default.md). Sin embargo, si el tipo con el que está " +"Además, el tipo que está tomando debe implementar el [rasgo `Predeterminado`] (./default.md). Sin embargo, si el tipo con el que está " "trabajando no\n" "implementar esto, en su lugar puede usar `mem::replace`." @@ -1842,43 +1565,33 @@ msgstr "" #, fuzzy msgid "" "This pattern is only of interest in Rust. In GC'd languages, you'd take the\n" -"reference to the value by default (and the GC would keep track of refs), and " -"in\n" -"other low-level languages like C you'd simply alias the pointer and fix " -"things\n" +"reference to the value by default (and the GC would keep track of refs), and in\n" +"other low-level languages like C you'd simply alias the pointer and fix things\n" "later." msgstr "" "Este patrón solo es de interés en Rust. En los idiomas de GC, tomarías la\n" -"referencia al valor por defecto (y el GC haría un seguimiento de las " -"referencias), y en\n" -"otros lenguajes de bajo nivel como C simplemente haría un alias del puntero " -"y arreglaría las cosas\n" +"referencia al valor por defecto (y el GC haría un seguimiento de las referencias), y en\n" +"otros lenguajes de bajo nivel como C simplemente haría un alias del puntero y arreglaría las cosas\n" "más tarde." #: src\idioms/mem-replace.md:104 #, fuzzy msgid "" -"However, in Rust, we have to do a little more work to do this. An owned " -"value\n" -"may only have one owner, so to take it out, we need to put something back in " -"–\n" +"However, in Rust, we have to do a little more work to do this. An owned value\n" +"may only have one owner, so to take it out, we need to put something back in –\n" "like Indiana Jones, replacing the artifact with a bag of sand." msgstr "" -"Sin embargo, en Rust, tenemos que trabajar un poco más para hacer esto. Un " -"valor propio\n" -"Es posible que solo tenga un propietario, por lo que para sacarlo, debemos " -"volver a colocar algo:\n" +"Sin embargo, en Rust, tenemos que trabajar un poco más para hacer esto. Un valor propio\n" +"Es posible que solo tenga un propietario, por lo que para sacarlo, debemos volver a colocar algo:\n" "como Indiana Jones, reemplazando el artefacto con una bolsa de arena." #: src\idioms/mem-replace.md:110 #, fuzzy msgid "" -"This gets rid of the [Clone to satisfy the borrow " -"checker](../anti_patterns/borrow_clone.md)\n" +"This gets rid of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md)\n" "anti-pattern in a specific case." msgstr "" -"Esto elimina el [Clonar para satisfacer el comprobador de " -"préstamo](../anti_patterns/borrow_clone.md)\n" +"Esto elimina el [Clonar para satisfacer el comprobador de préstamo](../anti_patterns/borrow_clone.md)\n" "anti-patrón en un caso específico." #: src\idioms/on-stack-dyn-dispatch.md:1 @@ -1889,20 +1602,14 @@ msgstr "# Envío dinámico en la pila" #: src\idioms/on-stack-dyn-dispatch.md:5 #, fuzzy msgid "" -"We can dynamically dispatch over multiple values, however, to do so, we " -"need\n" -"to declare multiple variables to bind differently-typed objects. To extend " -"the\n" -"lifetime as necessary, we can use deferred conditional initialization, as " -"seen\n" +"We can dynamically dispatch over multiple values, however, to do so, we need\n" +"to declare multiple variables to bind differently-typed objects. To extend the\n" +"lifetime as necessary, we can use deferred conditional initialization, as seen\n" "below:" msgstr "" -"Podemos despachar dinámicamente sobre múltiples valores, sin embargo, para " -"hacerlo, necesitamos\n" -"para declarar múltiples variables para vincular objetos de diferente tipo. " -"para extender el\n" -"vida útil según sea necesario, podemos usar la inicialización condicional " -"diferida, como se ve\n" +"Podemos despachar dinámicamente sobre múltiples valores, sin embargo, para hacerlo, necesitamos\n" +"para declarar múltiples variables para vincular objetos de diferente tipo. para extender el\n" +"vida útil según sea necesario, podemos usar la inicialización condicional diferida, como se ve\n" "abajo:" #: src\idioms/on-stack-dyn-dispatch.md:12 @@ -1937,33 +1644,24 @@ msgstr "" #, fuzzy msgid "" "Rust monomorphises code by default. This means a copy of the code will be\n" -"generated for each type it is used with and optimized independently. While " -"this\n" -"allows for very fast code on the hot path, it also bloats the code in " -"places\n" -"where performance is not of the essence, thus costing compile time and " -"cache\n" +"generated for each type it is used with and optimized independently. While this\n" +"allows for very fast code on the hot path, it also bloats the code in places\n" +"where performance is not of the essence, thus costing compile time and cache\n" "usage." msgstr "" -"Rust monomorfiza el código por defecto. Esto significa que una copia del " -"código será\n" -"generado para cada tipo con el que se utiliza y optimizado de forma " -"independiente. Mientras esto\n" -"permite un código muy rápido en la ruta activa, también infla el código en " -"algunos lugares\n" -"donde el rendimiento no es esencial, lo que cuesta tiempo de compilación y " -"caché\n" +"Rust monomorfiza el código por defecto. Esto significa que una copia del código será\n" +"generado para cada tipo con el que se utiliza y optimizado de forma independiente. Mientras esto\n" +"permite un código muy rápido en la ruta activa, también infla el código en algunos lugares\n" +"donde el rendimiento no es esencial, lo que cuesta tiempo de compilación y caché\n" "uso." #: src\idioms/on-stack-dyn-dispatch.md:45 #, fuzzy msgid "" -"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly " -"ask\n" +"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly ask\n" "for it." msgstr "" -"Afortunadamente, Rust nos permite usar el envío dinámico, pero tenemos que " -"preguntar explícitamente\n" +"Afortunadamente, Rust nos permite usar el envío dinámico, pero tenemos que preguntar explícitamente\n" "para ello." #: src\idioms/on-stack-dyn-dispatch.md:50 @@ -2000,18 +1698,13 @@ msgstr "" msgid "" "Rust newcomers will usually learn that Rust requires all variables to be\n" "initialized _before use_, so it's easy to overlook the fact that _unused_\n" -"variables may well be uninitialized. Rust works quite hard to ensure that " -"this\n" -"works out fine and only the initialized values are dropped at the end of " -"their\n" +"variables may well be uninitialized. Rust works quite hard to ensure that this\n" +"works out fine and only the initialized values are dropped at the end of their\n" "scope." msgstr "" -"Los recién llegados a Rust generalmente aprenderán que Rust requiere que " -"todas las variables sean\n" -"inicializado _antes de su uso_, por lo que es fácil pasar por alto el hecho " -"de que _unused_\n" -"las variables bien pueden no estar inicializadas. Rust trabaja muy duro para " -"garantizar que esto\n" +"Los recién llegados a Rust generalmente aprenderán que Rust requiere que todas las variables sean\n" +"inicializado _antes de su uso_, por lo que es fácil pasar por alto el hecho de que _unused_\n" +"las variables bien pueden no estar inicializadas. Rust trabaja muy duro para garantizar que esto\n" "funciona bien y solo los valores inicializados se eliminan al final de su\n" "alcance." @@ -2024,40 +1717,30 @@ msgstr "El ejemplo cumple con todas las restricciones que Rust nos impone:" #, fuzzy msgid "" "- All variables are initialized before using (in this case borrowing) them\n" -"- Each variable only holds values of a single type. In our example, `stdin` " -"is\n" -" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut " -"dyn Read`\n" +"- Each variable only holds values of a single type. In our example, `stdin` is\n" +" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut dyn Read`\n" "- Each borrowed value outlives all the references borrowed from it" msgstr "" -"- Todas las variables se inicializan antes de usarlas (en este caso, " -"tomarlas prestadas)\n" -"- Cada variable solo contiene valores de un solo tipo. En nuestro ejemplo, " -"`stdin` es\n" -" de tipo `Stdin`, `file` es de tipo `File` y `readable` es de tipo `&mut " -"dyn Read`\n" +"- Todas las variables se inicializan antes de usarlas (en este caso, tomarlas prestadas)\n" +"- Cada variable solo contiene valores de un solo tipo. En nuestro ejemplo, `stdin` es\n" +" de tipo `Stdin`, `file` es de tipo `File` y `readable` es de tipo `&mut dyn Read`\n" "- Cada valor prestado sobrevive a todas las referencias tomadas de él" #: src\idioms/on-stack-dyn-dispatch.md:85 #, fuzzy msgid "" "- [Finalisation in destructors](dtor-finally.md) and\n" -" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight " -"control over\n" +" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight control over\n" " lifetimes.\n" "- For conditionally filled `Option<&T>`s of (mutable) references, one can\n" -" initialize an `Option` directly and use its [`.as_ref()`] method to get " -"an\n" +" initialize an `Option` directly and use its [`.as_ref()`] method to get an\n" " optional reference." msgstr "" "- [Finalización en destructores](dtor-finally.md) y\n" -" [Guardias RAII](../patterns/behavioural/RAII.md) pueden beneficiarse de un " -"control estricto sobre\n" +" [Guardias RAII](../patterns/behavioural/RAII.md) pueden beneficiarse de un control estricto sobre\n" " vidas\n" -"- Para `Option<&T>`s de referencias (mutables) rellenadas condicionalmente, " -"se puede\n" -" inicialice una `Option` directamente y use su método [`.as_ref()`] para " -"obtener una\n" +"- Para `Option<&T>`s de referencias (mutables) rellenadas condicionalmente, se puede\n" +" inicialice una `Option` directamente y use su método [`.as_ref()`] para obtener una\n" " referencia opcional." #: src\idioms/ffi/intro.md:1 @@ -2073,8 +1756,7 @@ msgid "" "traps for inexperienced users of `unsafe` Rust." msgstr "" "Escribir código FFI es un curso completo en sí mismo.\n" -"Sin embargo, aquí hay varios modismos que pueden actuar como indicadores y " -"evitar\n" +"Sin embargo, aquí hay varios modismos que pueden actuar como indicadores y evitar\n" "trampas para usuarios inexpertos de Rust `inseguro`." #: src\idioms/ffi/intro.md:7 @@ -2092,8 +1774,7 @@ msgid "" "\n" "3. [Passing Strings](./passing-strings.md) to FFI functions" msgstr "" -"1. [Errores idiomáticos](./errors.md) - Manejo de errores con códigos " -"enteros y\n" +"1. [Errores idiomáticos](./errors.md) - Manejo de errores con códigos enteros y\n" " valores de retorno centinela (como punteros `NULL`)\n" "\n" "2. [Accepting Strings](./accepting-strings.md) con código inseguro mínimo\n" @@ -2112,42 +1793,33 @@ msgid "" "However, Rust's type system allows much more rich error information to be\n" "captured and propogated through a full type." msgstr "" -"En idiomas extranjeros como C, los errores se representan mediante códigos " -"de retorno.\n" -"Sin embargo, el sistema de tipos de Rust permite obtener información de " -"error mucho más rica.\n" +"En idiomas extranjeros como C, los errores se representan mediante códigos de retorno.\n" +"Sin embargo, el sistema de tipos de Rust permite obtener información de error mucho más rica.\n" "capturado y propagado a través de un tipo completo." #: src\idioms/ffi/errors.md:9 #, fuzzy msgid "" -"This best practice shows different kinds of error codes, and how to expose " -"them\n" +"This best practice shows different kinds of error codes, and how to expose them\n" "in a usable way:" msgstr "" -"Esta práctica recomendada muestra diferentes tipos de códigos de error y " -"cómo exponerlos\n" +"Esta práctica recomendada muestra diferentes tipos de códigos de error y cómo exponerlos\n" "de una manera utilizable:" #: src\idioms/ffi/errors.md:12 #, fuzzy msgid "" "1. Flat Enums should be converted to integers and returned as codes.\n" -"2. Structured Enums should be converted to an integer code with a string " -"error\n" +"2. Structured Enums should be converted to an integer code with a string error\n" " message for detail.\n" "3. Custom Error Types should become \"transparent\", with a C representation." msgstr "" -"1. Las enumeraciones planas deben convertirse en números enteros y " -"devolverse como códigos.\n" -"2. Las enumeraciones estructuradas deben convertirse a un código entero con " -"un error de cadena\n" +"1. Las enumeraciones planas deben convertirse en números enteros y devolverse como códigos.\n" +"2. Las enumeraciones estructuradas deben convertirse a un código entero con un error de cadena\n" " mensaje para el detalle.\n" -"3. Los tipos de error personalizados deben volverse \"transparentes\", con " -"una representación C." +"3. Los tipos de error personalizados deben volverse \"transparentes\", con una representación C." -#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 -#: src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 +#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 #: src\patterns/ffi/wrappers.md:23 #, fuzzy msgid "## Code Example" @@ -2210,8 +1882,7 @@ msgid "" " ) -> *mut libc::c_char {\n" "\n" " let error: &DatabaseError = unsafe {\n" -" // SAFETY: pointer lifetime is greater than the current stack " -"frame\n" +" // SAFETY: pointer lifetime is greater than the current stack frame\n" " &*e\n" " };\n" "\n" @@ -2230,8 +1901,7 @@ msgid "" " let c_error = unsafe {\n" " // SAFETY: copying error_str to an allocated buffer with a NUL\n" " // character at the end\n" -" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as " -"*mut _;\n" +" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as *mut _;\n" "\n" " if malloc.is_null() {\n" " return std::ptr::null_mut();\n" @@ -2288,12 +1958,10 @@ msgstr "" #: src\idioms/ffi/errors.md:133 #, fuzzy msgid "" -"This ensures that the foreign language has clear access to error " -"information\n" +"This ensures that the foreign language has clear access to error information\n" "while not compromising the Rust code's API at all." msgstr "" -"Esto asegura que el idioma extranjero tenga un acceso claro a la información " -"de error.\n" +"Esto asegura que el idioma extranjero tenga un acceso claro a la información de error.\n" "sin comprometer en absoluto la API del código Rust." #: src\idioms/ffi/errors.md:138 @@ -2302,8 +1970,7 @@ msgid "" "It's a lot of typing, and some types may not be able to be converted easily\n" "to C." msgstr "" -"Es mucho escribir, y es posible que algunos tipos no se puedan convertir " -"fácilmente\n" +"Es mucho escribir, y es posible que algunos tipos no se puedan convertir fácilmente\n" "a c" #: src\idioms/ffi/accepting-strings.md:1 @@ -2314,72 +1981,53 @@ msgstr "# Aceptar cadenas" #: src\idioms/ffi/accepting-strings.md:5 #, fuzzy msgid "" -"When accepting strings via FFI through pointers, there are two principles " -"that\n" +"When accepting strings via FFI through pointers, there are two principles that\n" "should be followed:" msgstr "" -"Al aceptar cadenas a través de FFI a través de punteros, hay dos principios " -"que\n" +"Al aceptar cadenas a través de FFI a través de punteros, hay dos principios que\n" "debe ser seguido:" #: src\idioms/ffi/accepting-strings.md:8 #, fuzzy msgid "" "1. Keep foreign strings \"borrowed\", rather than copying them directly.\n" -"2. Minimize the amount of complexity and `unsafe` code involved in " -"converting\n" +"2. Minimize the amount of complexity and `unsafe` code involved in converting\n" " from a C-style string to native Rust strings." msgstr "" -"1. Mantenga las cadenas extranjeras \"prestadas\", en lugar de copiarlas " -"directamente.\n" -"2. Minimice la cantidad de complejidad y el código \"inseguro\" involucrado " -"en la conversión\n" +"1. Mantenga las cadenas extranjeras \"prestadas\", en lugar de copiarlas directamente.\n" +"2. Minimice la cantidad de complejidad y el código \"inseguro\" involucrado en la conversión\n" " desde una cadena de estilo C hasta cadenas nativas de Rust." #: src\idioms/ffi/accepting-strings.md:14 #, fuzzy -msgid "" -"The strings used in C have different behaviours to those used in Rust, " -"namely:" -msgstr "" -"Las cadenas utilizadas en C tienen comportamientos diferentes a los " -"utilizados en Rust, a saber:" +msgid "The strings used in C have different behaviours to those used in Rust, namely:" +msgstr "Las cadenas utilizadas en C tienen comportamientos diferentes a los utilizados en Rust, a saber:" #: src\idioms/ffi/accepting-strings.md:16 #, fuzzy msgid "" "- C strings are null-terminated while Rust strings store their length\n" -"- C strings can contain any arbitrary non-zero byte while Rust strings must " -"be\n" +"- C strings can contain any arbitrary non-zero byte while Rust strings must be\n" " UTF-8\n" "- C strings are accessed and manipulated using `unsafe` pointer operations\n" " while interactions with Rust strings go through safe methods" msgstr "" -"- Las cadenas C terminan en nulo, mientras que las cadenas Rust almacenan su " -"longitud\n" -"- Las cadenas C pueden contener cualquier byte arbitrario distinto de cero, " -"mientras que las cadenas Rust deben ser\n" +"- Las cadenas C terminan en nulo, mientras que las cadenas Rust almacenan su longitud\n" +"- Las cadenas C pueden contener cualquier byte arbitrario distinto de cero, mientras que las cadenas Rust deben ser\n" " UTF-8\n" -"- Se accede a las cadenas C y se manipulan mediante operaciones de puntero " -"\"no seguras\".\n" -" mientras que las interacciones con cadenas de Rust pasan por métodos " -"seguros" +"- Se accede a las cadenas C y se manipulan mediante operaciones de puntero \"no seguras\".\n" +" mientras que las interacciones con cadenas de Rust pasan por métodos seguros" #: src\idioms/ffi/accepting-strings.md:22 #, fuzzy msgid "" -"The Rust standard library comes with C equivalents of Rust's `String` and " -"`&str`\n" -"called `CString` and `&CStr`, that allow us to avoid a lot of the " -"complexity\n" +"The Rust standard library comes with C equivalents of Rust's `String` and `&str`\n" +"called `CString` and `&CStr`, that allow us to avoid a lot of the complexity\n" "and `unsafe` code involved in converting between C strings and Rust strings." msgstr "" -"La biblioteca estándar de Rust viene con equivalentes en C de `String` y " -"`&str` de Rust\n" -"llamados `CString` y `&CStr`, que nos permiten evitar mucha de la " -"complejidad\n" -"y código 'inseguro' involucrado en la conversión entre cadenas C y cadenas " -"Rust." +"La biblioteca estándar de Rust viene con equivalentes en C de `String` y `&str` de Rust\n" +"llamados `CString` y `&CStr`, que nos permiten evitar mucha de la complejidad\n" +"y código 'inseguro' involucrado en la conversión entre cadenas C y cadenas Rust." #: src\idioms/ffi/accepting-strings.md:26 #, fuzzy @@ -2387,8 +2035,7 @@ msgid "" "The `&CStr` type also allows us to work with borrowed data, meaning passing\n" "strings between Rust and C is a zero-cost operation." msgstr "" -"El tipo `&CStr` también nos permite trabajar con datos prestados, lo que " -"significa pasar\n" +"El tipo `&CStr` también nos permite trabajar con datos prestados, lo que significa pasar\n" "cadenas entre Rust y C es una operación de costo cero." #: src\idioms/ffi/accepting-strings.md:31 @@ -2444,8 +2091,7 @@ msgid "" " reference" msgstr "" "1. El bloque \"inseguro\" es lo más pequeño posible.\n" -"2. El puntero con una vida útil \"sin seguimiento\" se convierte en un " -"puntero compartido \"seguido\"\n" +"2. El puntero con una vida útil \"sin seguimiento\" se convierte en un puntero compartido \"seguido\"\n" " referencia" #: src\idioms/ffi/accepting-strings.md:76 @@ -2460,8 +2106,7 @@ msgid "" "\n" " // other module content\n" "\n" -" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: " -"libc::c_int) {\n" +" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: libc::c_int) {\n" " // DO NOT USE THIS CODE.\n" " // IT IS UGLY, VERBOSE, AND CONTAINS A SUBTLE BUG.\n" "\n" @@ -2507,14 +2152,12 @@ msgstr "Este código es inferior al original en dos aspectos:" #: src\idioms/ffi/accepting-strings.md:122 #, fuzzy msgid "" -"1. There is much more `unsafe` code, and more importantly, more invariants " -"it\n" +"1. There is much more `unsafe` code, and more importantly, more invariants it\n" " must uphold.\n" "2. Due to the extensive arithmetic required, there is a bug in this version\n" " that cases Rust `undefined behaviour`." msgstr "" -"1. Hay mucho más código \"inseguro\" y, lo que es más importante, más " -"invariantes.\n" +"1. Hay mucho más código \"inseguro\" y, lo que es más importante, más invariantes.\n" " debe sostener.\n" "2. Debido a la extensa aritmética requerida, hay un error en esta versión\n" " que casos Rust `comportamiento indefinido`." @@ -2522,29 +2165,23 @@ msgstr "" #: src\idioms/ffi/accepting-strings.md:127 #, fuzzy msgid "" -"The bug here is a simple mistake in pointer arithmetic: the string was " -"copied,\n" +"The bug here is a simple mistake in pointer arithmetic: the string was copied,\n" "all `msg_len` bytes of it. However, the `NUL` terminator at the end was not." msgstr "" -"El error aquí es un simple error en la aritmética de punteros: la cadena fue " -"copiada,\n" -"todos los `msg_len` bytes del mismo. Sin embargo, el terminador `NUL` al " -"final no lo era." +"El error aquí es un simple error en la aritmética de punteros: la cadena fue copiada,\n" +"todos los `msg_len` bytes del mismo. Sin embargo, el terminador `NUL` al final no lo era." #: src\idioms/ffi/accepting-strings.md:130 #, fuzzy msgid "" -"The Vector then had its size _set_ to the length of the _zero padded string_ " -"--\n" +"The Vector then had its size _set_ to the length of the _zero padded string_ --\n" "rather than _resized_ to it, which could have added a zero at the end.\n" "As a result, the last byte in the Vector is uninitialized memory.\n" "When the `CString` is created at the bottom of the block, its read of the\n" "Vector will cause `undefined behaviour`!" msgstr "" -"Luego, el Vector tenía su tamaño _establecido_ en la longitud de la _cadena " -"con relleno cero_ --\n" -"en lugar de _redimensionarlo_, lo que podría haber agregado un cero al " -"final.\n" +"Luego, el Vector tenía su tamaño _establecido_ en la longitud de la _cadena con relleno cero_ --\n" +"en lugar de _redimensionarlo_, lo que podría haber agregado un cero al final.\n" "Como resultado, el último byte del Vector es una memoria no inicializada.\n" "Cuando se crea el `CString` en la parte inferior del bloque, se lee el\n" "¡El vector causará un \"comportamiento indefinido\"!" @@ -2553,8 +2190,7 @@ msgstr "" #, fuzzy msgid "" "Like many such issues, this would be difficult issue to track down.\n" -"Sometimes it would panic because the string was not `UTF-8`, sometimes it " -"would\n" +"Sometimes it would panic because the string was not `UTF-8`, sometimes it would\n" "put a weird character at the end of the string, sometimes it would just\n" "completely crash." msgstr "" @@ -2563,8 +2199,7 @@ msgstr "" "poner un carácter extraño al final de la cadena, a veces simplemente\n" "chocar completamente." -#: src\idioms/ffi/accepting-strings.md:143 -#: src\idioms/ffi/passing-strings.md:105 +#: src\idioms/ffi/accepting-strings.md:143 src\idioms/ffi/passing-strings.md:105 #, fuzzy msgid "None?" msgstr "¿Ninguno?" @@ -2577,8 +2212,7 @@ msgstr "# Cuerdas de paso" #: src\idioms/ffi/passing-strings.md:5 #, fuzzy msgid "" -"When passing strings to FFI functions, there are four principles that should " -"be\n" +"When passing strings to FFI functions, there are four principles that should be\n" "followed:" msgstr "" "Al pasar cadenas a funciones FFI, hay cuatro principios que deben ser\n" @@ -2589,31 +2223,25 @@ msgstr "" msgid "" "1. Make the lifetime of owned strings as long as possible.\n" "2. Minimize `unsafe` code during the conversion.\n" -"3. If the C code can modify the string data, use `Vec` instead of " -"`CString`.\n" +"3. If the C code can modify the string data, use `Vec` instead of `CString`.\n" "4. Unless the Foreign Function API requires it, the ownership of the string\n" " should not transfer to the callee." msgstr "" "1. Haga que la vida útil de las cadenas propias sea lo más larga posible.\n" "2. Minimice el código \"inseguro\" durante la conversión.\n" -"3. Si el código C puede modificar los datos de la cadena, use `Vec` en lugar " -"de `CString`.\n" -"4. A menos que la API de función externa lo requiera, la propiedad de la " -"cadena\n" +"3. Si el código C puede modificar los datos de la cadena, use `Vec` en lugar de `CString`.\n" +"4. A menos que la API de función externa lo requiera, la propiedad de la cadena\n" " no debe transferirse al destinatario." #: src\idioms/ffi/passing-strings.md:16 #, fuzzy msgid "" "Rust has built-in support for C-style strings with its `CString` and `CStr`\n" -"types. However, there are different approaches one can take with strings " -"that\n" +"types. However, there are different approaches one can take with strings that\n" "are being sent to a foreign function call from a Rust function." msgstr "" -"Rust tiene soporte incorporado para cadenas de estilo C con su `CString` y " -"`CStr`\n" -"tipos Sin embargo, hay diferentes enfoques que uno puede tomar con cadenas " -"que\n" +"Rust tiene soporte incorporado para cadenas de estilo C con su `CString` y `CStr`\n" +"tipos Sin embargo, hay diferentes enfoques que uno puede tomar con cadenas que\n" "se envían a una llamada de función externa desde una función de Rust." #: src\idioms/ffi/passing-strings.md:20 @@ -2621,18 +2249,14 @@ msgstr "" msgid "" "The best practice is simple: use `CString` in such a way as to minimize\n" "`unsafe` code. However, a secondary caveat is that\n" -"_the object must live long enough_, meaning the lifetime should be " -"maximized.\n" -"In addition, the documentation explains that \"round-tripping\" a `CString` " -"after\n" +"_the object must live long enough_, meaning the lifetime should be maximized.\n" +"In addition, the documentation explains that \"round-tripping\" a `CString` after\n" "modification is UB, so additional work is necessary in that case." msgstr "" "La mejor práctica es simple: use `CString` de tal manera que minimice\n" "Código `inseguro`. Sin embargo, una advertencia secundaria es que\n" -"_el objeto debe vivir lo suficiente_, lo que significa que la vida útil debe " -"maximizarse.\n" -"Además, la documentación explica que \"viajar de ida y vuelta\" un `CString` " -"después\n" +"_el objeto debe vivir lo suficiente_, lo que significa que la vida útil debe maximizarse.\n" +"Además, la documentación explica que \"viajar de ida y vuelta\" un `CString` después\n" "la modificación es UB, por lo que se necesita trabajo adicional en ese caso." #: src\idioms/ffi/passing-strings.md:28 @@ -2644,8 +2268,7 @@ msgid "" "\n" " extern \"C\" {\n" " fn seterr(message: *const libc::c_char);\n" -" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> " -"libc::c_int;\n" +" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> libc::c_int;\n" " }\n" "\n" " fn report_error_to_ffi>(\n" @@ -2654,8 +2277,7 @@ msgid "" " let c_err = std::ffi::CString::new(err.into())?;\n" "\n" " unsafe {\n" -" // SAFETY: calling an FFI whose documentation says the pointer " -"is\n" +" // SAFETY: calling an FFI whose documentation says the pointer is\n" " // const, so no modification should occur\n" " seterr(c_err.as_ptr());\n" " }\n" @@ -2712,8 +2334,7 @@ msgid "" "\n" " // other module content\n" "\n" -" fn report_error>(err: S) -> Result<(), " -"std::ffi::NulError> {\n" +" fn report_error>(err: S) -> Result<(), std::ffi::NulError> {\n" " unsafe {\n" " // SAFETY: whoops, this contains a dangling pointer!\n" " seterr(std::ffi::CString::new(err.into())?.as_ptr());\n" @@ -2728,34 +2349,25 @@ msgstr "" #, fuzzy msgid "" "This code will result in a dangling pointer, because the lifetime of the\n" -"`CString` is not extended by the pointer creation, unlike if a reference " -"were\n" +"`CString` is not extended by the pointer creation, unlike if a reference were\n" "created." msgstr "" -"Este código dará como resultado un puntero colgante, porque la vida útil " -"del\n" -"'CString' no se extiende por la creación del puntero, a diferencia de si una " -"referencia fuera\n" +"Este código dará como resultado un puntero colgante, porque la vida útil del\n" +"'CString' no se extiende por la creación del puntero, a diferencia de si una referencia fuera\n" "creado." #: src\idioms/ffi/passing-strings.md:98 #, fuzzy msgid "" -"Another issue frequently raised is that the initialization of a 1k vector " -"of\n" +"Another issue frequently raised is that the initialization of a 1k vector of\n" "zeroes is \"slow\". However, recent versions of Rust actually optimize that\n" -"particular macro to a call to `zmalloc`, meaning it is as fast as the " -"operating\n" +"particular macro to a call to `zmalloc`, meaning it is as fast as the operating\n" "system's ability to return zeroed memory (which is quite fast)." msgstr "" -"Otro problema que se plantea con frecuencia es que la inicialización de un " -"vector de 1k de\n" -"ceros es \"lento\". Sin embargo, las versiones recientes de Rust en realidad " -"optimizan eso\n" -"macro particular a una llamada a `zmalloc`, lo que significa que es tan " -"rápido como el operador\n" -"la capacidad del sistema para devolver la memoria puesta a cero (lo cual es " -"bastante rápido)." +"Otro problema que se plantea con frecuencia es que la inicialización de un vector de 1k de\n" +"ceros es \"lento\". Sin embargo, las versiones recientes de Rust en realidad optimizan eso\n" +"macro particular a una llamada a `zmalloc`, lo que significa que es tan rápido como el operador\n" +"la capacidad del sistema para devolver la memoria puesta a cero (lo cual es bastante rápido)." #: src\idioms/option-iter.md:1 #, fuzzy @@ -2773,8 +2385,7 @@ msgstr "" "elemento. En particular, implementa el rasgo `IntoIterator`, y como tal\n" "se puede usar con código genérico que necesita ese tipo." -#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 -#: src\patterns/structural/unsafe-mods.md:22 +#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 src\patterns/structural/unsafe-mods.md:22 #, fuzzy msgid "## Examples" msgstr "## Ejemplos" @@ -2785,8 +2396,7 @@ msgid "" "Since `Option` implements `IntoIterator`, it can be used as an argument to\n" "[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" msgstr "" -"Dado que `Option` implementa `IntoIterator`, se puede usar como argumento " -"para\n" +"Dado que `Option` implementa `IntoIterator`, se puede usar como argumento para\n" "[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" #: src\idioms/option-iter.md:14 @@ -2808,12 +2418,10 @@ msgstr "" #, fuzzy msgid "" "If you need to tack an `Option` to the end of an existing iterator, you can\n" -"pass it to " -"[`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +"pass it to [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" msgstr "" "Si necesita agregar una `Opción` al final de un iterador existente, puede\n" -"páselo a " -"[`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +"páselo a [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" #: src\idioms/option-iter.md:29 msgid "" @@ -2830,71 +2438,53 @@ msgstr "" #: src\idioms/option-iter.md:38 #, fuzzy msgid "" -"Note that if the `Option` is always `Some`, then it is more idiomatic to " -"use\n" +"Note that if the `Option` is always `Some`, then it is more idiomatic to use\n" "[`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) on the\n" "element instead." msgstr "" -"Tenga en cuenta que si la `Opción` siempre es `Algunos`, entonces es más " -"idiomático de usar\n" +"Tenga en cuenta que si la `Opción` siempre es `Algunos`, entonces es más idiomático de usar\n" "[`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) en el\n" "elemento en su lugar." #: src\idioms/option-iter.md:42 #, fuzzy msgid "" -"Also, since `Option` implements `IntoIterator`, it's possible to iterate " -"over\n" -"it using a `for` loop. This is equivalent to matching it with `if let " -"Some(..)`,\n" +"Also, since `Option` implements `IntoIterator`, it's possible to iterate over\n" +"it using a `for` loop. This is equivalent to matching it with `if let Some(..)`,\n" "and in most cases you should prefer the latter." msgstr "" -"Además, dado que `Option` implementa `IntoIterator`, es posible iterar " -"sobre\n" -"usando un bucle `for`. Esto es equivalente a emparejarlo con `if let " -"Some(...)`,\n" +"Además, dado que `Option` implementa `IntoIterator`, es posible iterar sobre\n" +"usando un bucle `for`. Esto es equivalente a emparejarlo con `if let Some(...)`,\n" "y en la mayoría de los casos deberías preferir lo último." #: src\idioms/option-iter.md:48 #, fuzzy msgid "" -"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is " -"an\n" -" iterator which yields exactly one element. It's a more readable " -"alternative to\n" +"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is an\n" +" iterator which yields exactly one element. It's a more readable alternative to\n" " `Some(foo).into_iter()`.\n" "\n" -"- " -"[`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" -" is a version of " -"[`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" is a version of [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" " specialized to mapping functions which return `Option`.\n" "\n" -"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides " -"functions\n" +"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" " for converting an `Option` to a zero- or one-element slice.\n" "\n" -"- [Documentation for " -"`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +"- [Documentation for `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" msgstr "" -"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) es " -"un\n" -" iterador que produce exactamente un elemento. Es una alternativa más " -"legible a\n" +"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) es un\n" +" iterador que produce exactamente un elemento. Es una alternativa más legible a\n" " `Algunos(foo).into_iter()`.\n" "\n" -"- " -"[`Iterador::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" -" es una versión de " -"[`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +"- [`Iterador::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" es una versión de [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" " especializado en funciones de mapeo que devuelven `Opción`.\n" "\n" -"- La caja [`ref_slice`](https://crates.io/crates/ref_slice) proporciona " -"funciones\n" +"- La caja [`ref_slice`](https://crates.io/crates/ref_slice) proporciona funciones\n" " para convertir una `Opción` en una rebanada de cero o un elemento.\n" "\n" -"- [Documentación para " -"`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +"- [Documentación para `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" #: src\idioms/pass-var-to-closure.md:1 #, fuzzy @@ -2905,18 +2495,13 @@ msgstr "# Pasar variables al cierre" #, fuzzy msgid "" "By default, closures capture their environment by borrowing. Or you can use\n" -"`move`-closure to move whole environment. However, often you want to move " -"just\n" -"some variables to closure, give it copy of some data, pass it by reference, " -"or\n" +"`move`-closure to move whole environment. However, often you want to move just\n" +"some variables to closure, give it copy of some data, pass it by reference, or\n" "perform some other transformation." msgstr "" -"De forma predeterminada, los cierres capturan su entorno tomando prestado. O " -"puedes usar\n" -"cierre `mover` para mover todo el entorno. Sin embargo, a menudo desea " -"moverse solo\n" -"algunas variables para el cierre, darle copia de algunos datos, pasarlo por " -"referencia, o\n" +"De forma predeterminada, los cierres capturan su entorno tomando prestado. O puedes usar\n" +"cierre `mover` para mover todo el entorno. Sin embargo, a menudo desea moverse solo\n" +"algunas variables para el cierre, darle copia de algunos datos, pasarlo por referencia, o\n" "realizar alguna otra transformación." #: src\idioms/pass-var-to-closure.md:10 @@ -2973,26 +2558,21 @@ msgstr "" #: src\idioms/pass-var-to-closure.md:50 #, fuzzy msgid "" -"Copied data are grouped together with closure definition, so their purpose " -"is\n" -"more clear, and they will be dropped immediately even if they are not " -"consumed\n" +"Copied data are grouped together with closure definition, so their purpose is\n" +"more clear, and they will be dropped immediately even if they are not consumed\n" "by closure." msgstr "" -"Los datos copiados se agrupan junto con la definición de cierre, por lo que " -"su propósito es\n" +"Los datos copiados se agrupan junto con la definición de cierre, por lo que su propósito es\n" "más claras, y se dejarán caer inmediatamente incluso si no se consumen\n" "por cierre." #: src\idioms/pass-var-to-closure.md:54 #, fuzzy msgid "" -"Closure uses same variable names as surrounding code whether data are copied " -"or\n" +"Closure uses same variable names as surrounding code whether data are copied or\n" "moved." msgstr "" -"El cierre usa los mismos nombres de variables que el código circundante, ya " -"sea que los datos se copien o\n" +"El cierre usa los mismos nombres de variables que el código circundante, ya sea que los datos se copien o\n" "movido." #: src\idioms/pass-var-to-closure.md:59 @@ -3008,16 +2588,12 @@ msgstr "# `#[no_exhaustivo]` y campos privados para extensibilidad" #: src\idioms/priv-extend.md:5 #, fuzzy msgid "" -"A small set of scenarios exist where a library author may want to add " -"public\n" -"fields to a public struct or new variants to an enum without breaking " -"backwards\n" +"A small set of scenarios exist where a library author may want to add public\n" +"fields to a public struct or new variants to an enum without breaking backwards\n" "compatibility." msgstr "" -"Existe un pequeño conjunto de escenarios en los que un autor de la " -"biblioteca puede querer agregar público\n" -"campos a una estructura pública o nuevas variantes a una enumeración sin " -"retroceder\n" +"Existe un pequeño conjunto de escenarios en los que un autor de la biblioteca puede querer agregar público\n" +"campos a una estructura pública o nuevas variantes a una enumeración sin retroceder\n" "compatibilidad." #: src\idioms/priv-extend.md:9 @@ -3029,22 +2605,18 @@ msgstr "Rust ofrece dos soluciones a este problema:" #, fuzzy msgid "" "- Use `#[non_exhaustive]` on `struct`s, `enum`s, and `enum` variants.\n" -" For extensive documentation on all the places where `#[non_exhaustive]` " -"can be\n" -" used, see [the " -"docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +" For extensive documentation on all the places where `#[non_exhaustive]` can be\n" +" used, see [the docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" "\n" "- You may add a private field to a struct to prevent it from being directly\n" " instantiated or matched against (see Alternative)" msgstr "" "- Use `#[non_exhaustive]` en las variantes `struct`s, `enum`s y `enum`.\n" -" Para obtener documentación detallada sobre todos los lugares donde " -"`#[non_exhaustive]` puede ser\n" -" utilizado, consulte [los documentos] " -"(https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +" Para obtener documentación detallada sobre todos los lugares donde `#[non_exhaustive]` puede ser\n" +" utilizado, consulte [los documentos] (https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-" +"attribute).\n" "\n" -"- Puede agregar un campo privado a una estructura para evitar que sea " -"directamente\n" +"- Puede agregar un campo privado a una estructura para evitar que sea directamente\n" " instanciado o comparado con (ver Alternativa)" #: src\idioms/priv-extend.md:20 @@ -3106,45 +2678,33 @@ msgstr "" msgid "" "Adding a field to a struct is a mostly backwards compatible change.\n" "However, if a client uses a pattern to deconstruct a struct instance, they\n" -"might name all the fields in the struct and adding a new one would break " -"that\n" +"might name all the fields in the struct and adding a new one would break that\n" "pattern.\n" -"The client could name some fields and use `..` in the pattern, in which case " -"adding\n" +"The client could name some fields and use `..` in the pattern, in which case adding\n" "another field is backwards compatible.\n" -"Making at least one of the struct's fields private forces clients to use the " -"latter\n" +"Making at least one of the struct's fields private forces clients to use the latter\n" "form of patterns, ensuring that the struct is future-proof." msgstr "" -"Agregar un campo a una estructura es un cambio en su mayoría compatible con " -"versiones anteriores.\n" -"Sin embargo, si un cliente usa un patrón para deconstruir una instancia de " -"estructura,\n" -"podría nombrar todos los campos en la estructura y agregar uno nuevo " -"rompería eso\n" +"Agregar un campo a una estructura es un cambio en su mayoría compatible con versiones anteriores.\n" +"Sin embargo, si un cliente usa un patrón para deconstruir una instancia de estructura,\n" +"podría nombrar todos los campos en la estructura y agregar uno nuevo rompería eso\n" "patrón.\n" -"El cliente podría nombrar algunos campos y usar `..` en el patrón, en cuyo " -"caso agregando\n" +"El cliente podría nombrar algunos campos y usar `..` en el patrón, en cuyo caso agregando\n" "otro campo es compatible con versiones anteriores.\n" -"Hacer que al menos uno de los campos de la estructura sea privado obliga a " -"los clientes a usar este último\n" -"forma de patrones, asegurando que la estructura esté preparada para el " -"futuro." +"Hacer que al menos uno de los campos de la estructura sea privado obliga a los clientes a usar este último\n" +"forma de patrones, asegurando que la estructura esté preparada para el futuro." #: src\idioms/priv-extend.md:71 #, fuzzy msgid "" -"The downside of this approach is that you might need to add an otherwise " -"unneeded\n" +"The downside of this approach is that you might need to add an otherwise unneeded\n" "field to the struct.\n" -"You can use the `()` type so that there is no runtime overhead and prepend " -"`_` to\n" +"You can use the `()` type so that there is no runtime overhead and prepend `_` to\n" "the field name to avoid the unused field warning." msgstr "" "La desventaja de este enfoque es que es posible que deba agregar un\n" "campo a la estructura.\n" -"Puede usar el tipo `()` para que no haya sobrecarga de tiempo de ejecución y " -"anteponer `_` a\n" +"Puede usar el tipo `()` para que no haya sobrecarga de tiempo de ejecución y anteponer `_` a\n" "el nombre del campo para evitar la advertencia de campo no utilizado." #: src\idioms/priv-extend.md:76 @@ -3152,8 +2712,7 @@ msgid "" "```rust\n" "pub struct S {\n" " pub a: i32,\n" -" // Because `b` is private, you cannot match on `S` without using `..` " -"and `S`\n" +" // Because `b` is private, you cannot match on `S` without using `..` and `S`\n" " // cannot be directly instantiated or matched against\n" " _b: ()\n" "}\n" @@ -3163,61 +2722,44 @@ msgstr "" #: src\idioms/priv-extend.md:87 #, fuzzy msgid "" -"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a " -"backwards\n" +"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a backwards\n" "compatible way.\n" -"It will also prevent clients from using the struct constructor, even if all " -"the\n" +"It will also prevent clients from using the struct constructor, even if all the\n" "fields are public.\n" -"This may be helpful, but it's worth considering if you _want_ an additional " -"field\n" -"to be found by clients as a compiler error rather than something that may be " -"silently\n" +"This may be helpful, but it's worth considering if you _want_ an additional field\n" +"to be found by clients as a compiler error rather than something that may be silently\n" "undiscovered." msgstr "" -"En `struct`s, `#[non_exhaustive]` permite agregar campos adicionales al " -"revés\n" +"En `struct`s, `#[non_exhaustive]` permite agregar campos adicionales al revés\n" "forma compatible.\n" -"También evitará que los clientes usen el constructor de estructuras, incluso " -"si todos los\n" +"También evitará que los clientes usen el constructor de estructuras, incluso si todos los\n" "Los campos son públicos.\n" -"Esto puede ser útil, pero vale la pena considerarlo si _quiere_ un campo " -"adicional\n" -"ser encontrado por los clientes como un error del compilador en lugar de " -"algo que puede ser silenciosamente\n" +"Esto puede ser útil, pero vale la pena considerarlo si _quiere_ un campo adicional\n" +"ser encontrado por los clientes como un error del compilador en lugar de algo que puede ser silenciosamente\n" "sin descubrir" #: src\idioms/priv-extend.md:95 #, fuzzy msgid "" "`#[non_exhaustive]` can be applied to enum variants as well.\n" -"A `#[non_exhaustive]` variant behaves in the same way as a " -"`#[non_exhaustive]` struct." +"A `#[non_exhaustive]` variant behaves in the same way as a `#[non_exhaustive]` struct." msgstr "" -"`#[non_exhaustive]` también se puede aplicar a las variantes de " -"enumeración.\n" -"Una variante `#[no_exhaustiva]` se comporta de la misma manera que una " -"estructura `#[no_exhaustiva]`." +"`#[non_exhaustive]` también se puede aplicar a las variantes de enumeración.\n" +"Una variante `#[no_exhaustiva]` se comporta de la misma manera que una estructura `#[no_exhaustiva]`." #: src\idioms/priv-extend.md:98 #, fuzzy msgid "" -"Use this deliberately and with caution: incrementing the major version when " -"adding\n" +"Use this deliberately and with caution: incrementing the major version when adding\n" "fields or variants is often a better option.\n" -"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an " -"external\n" -"resource that may change out-of-sync with your library, but is not a general " -"purpose\n" +"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an external\n" +"resource that may change out-of-sync with your library, but is not a general purpose\n" "tool." msgstr "" -"Use esto deliberadamente y con precaución: incrementando la versión " -"principal al agregar\n" +"Use esto deliberadamente y con precaución: incrementando la versión principal al agregar\n" "campos o variantes suele ser una mejor opción.\n" -"`#[non_exhaustive]` puede ser apropiado en escenarios en los que está " -"modelando un\n" -"recurso que puede cambiar fuera de sincronización con su biblioteca, pero no " -"es un propósito general\n" +"`#[non_exhaustive]` puede ser apropiado en escenarios en los que está modelando un\n" +"recurso que puede cambiar fuera de sincronización con su biblioteca, pero no es un propósito general\n" "herramienta." #: src\idioms/priv-extend.md:104 @@ -3228,43 +2770,36 @@ msgstr "### Desventajas" #: src\idioms/priv-extend.md:106 #, fuzzy msgid "" -"`#[non_exhaustive]` can make your code much less ergonomic to use, " -"especially when\n" +"`#[non_exhaustive]` can make your code much less ergonomic to use, especially when\n" "forced to handle unknown enum variants.\n" -"It should only be used when these sorts of evolutions are required " -"**without**\n" +"It should only be used when these sorts of evolutions are required **without**\n" "incrementing the major version." msgstr "" -"`#[non_exhaustive]` puede hacer que su código sea mucho menos ergonómico de " -"usar, especialmente cuando\n" +"`#[non_exhaustive]` puede hacer que su código sea mucho menos ergonómico de usar, especialmente cuando\n" "forzado a manejar variantes de enumeración desconocidas.\n" "Solo debe usarse cuando se requieren este tipo de evoluciones **sin**\n" "incrementando la versión principal." #: src\idioms/priv-extend.md:111 msgid "" -"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle " -"a\n" +"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle a\n" "wildcard variant.\n" -"If there is no sensible action to take in this case, this may lead to " -"awkward\n" +"If there is no sensible action to take in this case, this may lead to awkward\n" "code and code paths that are only executed in extremely rare circumstances.\n" -"If a client decides to `panic!()` in this scenario, it may have been better " -"to\n" +"If a client decides to `panic!()` in this scenario, it may have been better to\n" "expose this error at compile time.\n" -"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" " -"case;\n" +"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" case;\n" "there is rarely a sensible action to take in this scenario." msgstr "" #: src\idioms/priv-extend.md:122 #, fuzzy msgid "" -"- [RFC introducing #[non_exhaustive] attribute for enums and " -"structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-exhaustive.md)" +"- [RFC introducing #[non_exhaustive] attribute for enums and structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" msgstr "" -"- [RFC presenta el atributo #[no_exhaustivo] para enumeraciones y " -"estructuras](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-exhaustive.md)" +"- [RFC presenta el atributo #[no_exhaustivo] para enumeraciones y estructuras](https://github.com/rust-lang/rfcs/blob/master/text/2008-" +"non-exhaustive.md)" #: src\idioms/rustdoc-init.md:1 #, fuzzy @@ -3274,16 +2809,12 @@ msgstr "# Fácil inicialización de documentos\r" #: src\idioms/rustdoc-init.md:5 #, fuzzy msgid "" -"If a struct takes significant effort to initialize when writing docs, it can " -"be\r\n" -"quicker to wrap your example with a helper function which takes the struct " -"as an\r\n" +"If a struct takes significant effort to initialize when writing docs, it can be\r\n" +"quicker to wrap your example with a helper function which takes the struct as an\r\n" "argument." msgstr "" -"Si una estructura requiere un esfuerzo significativo para inicializarse al " -"escribir documentos, puede ser\r\n" -"más rápido para envolver su ejemplo con una función de ayuda que toma la " -"estructura como una\r\n" +"Si una estructura requiere un esfuerzo significativo para inicializarse al escribir documentos, puede ser\r\n" +"más rápido para envolver su ejemplo con una función de ayuda que toma la estructura como una\r\n" "argumento." #: src\idioms/rustdoc-init.md:9 @@ -3294,12 +2825,10 @@ msgstr "## Motivación\r" #: src\idioms/rustdoc-init.md:11 #, fuzzy msgid "" -"Sometimes there is a struct with multiple or complicated parameters and " -"several\r\n" +"Sometimes there is a struct with multiple or complicated parameters and several\r\n" "methods. Each of these methods should have examples." msgstr "" -"A veces hay una estructura con parámetros múltiples o complicados y " -"varios\r\n" +"A veces hay una estructura con parámetros múltiples o complicados y varios\r\n" "métodos. Cada uno de estos métodos debe tener ejemplos." #: src\idioms/rustdoc-init.md:14 @@ -3322,10 +2851,8 @@ msgid "" " /// ```no_run\r\n" " /// # // Boilerplate are required to get an example working.\r\n" " /// # let stream = TcpStream::connect(\"127.0.0.1:34254\");\r\n" -" /// # let connection = Connection { name: \"foo\".to_owned(), stream " -"};\r\n" -" /// # let request = Request::new(\"RequestId\", RequestType::Get, " -"\"payload\");\r\n" +" /// # let connection = Connection { name: \"foo\".to_owned(), stream };\r\n" +" /// # let request = Request::new(\"RequestId\", RequestType::Get, \"payload\");\r\n" " /// let response = connection.send_request(request);\r\n" " /// assert!(response.is_ok());\r\n" " /// ```\r\n" @@ -3350,14 +2877,11 @@ msgstr "## Ejemplo\r" #, fuzzy msgid "" "Instead of typing all of this boilerplate to create a `Connection` and\r\n" -"`Request`, it is easier to just create a wrapping helper function which " -"takes\r\n" +"`Request`, it is easier to just create a wrapping helper function which takes\r\n" "them as arguments:" msgstr "" -"En lugar de escribir todo este texto repetitivo para crear una `Conexión` " -"y\r\n" -"`Solicitud`, es más fácil simplemente crear una función auxiliar de " -"envoltura que tome\r\n" +"En lugar de escribir todo este texto repetitivo para crear una `Conexión` y\r\n" +"`Solicitud`, es más fácil simplemente crear una función auxiliar de envoltura que tome\r\n" "ellos como argumentos:" #: src\idioms/rustdoc-init.md:51 @@ -3387,8 +2911,7 @@ msgstr "" #: src\idioms/rustdoc-init.md:73 msgid "" -"**Note** in the above example the line `assert!(response.is_ok());` will " -"not\r\n" +"**Note** in the above example the line `assert!(response.is_ok());` will not\r\n" "actually run while testing because it is inside a function which is never\r\n" "invoked." msgstr "" @@ -3411,17 +2934,12 @@ msgstr "## Desventajas\r" #: src\idioms/rustdoc-init.md:83 #, fuzzy msgid "" -"As example is in a function, the code will not be tested. Though it will " -"still be\r\n" -"checked to make sure it compiles when running a `cargo test`. So this " -"pattern is\r\n" -"most useful when you need `no_run`. With this, you do not need to add " -"`no_run`." +"As example is in a function, the code will not be tested. Though it will still be\r\n" +"checked to make sure it compiles when running a `cargo test`. So this pattern is\r\n" +"most useful when you need `no_run`. With this, you do not need to add `no_run`." msgstr "" -"Como el ejemplo está en una función, el código no se probará. Aunque seguirá " -"siendo\r\n" -"verificado para asegurarse de que compila cuando se ejecuta una `prueba de " -"carga`. Así que este patrón es\r\n" +"Como el ejemplo está en una función, el código no se probará. Aunque seguirá siendo\r\n" +"verificado para asegurarse de que compila cuando se ejecuta una `prueba de carga`. Así que este patrón es\r\n" "más útil cuando necesitas `no_run`. Con esto, no necesita agregar `no_run`." #: src\idioms/rustdoc-init.md:87 @@ -3437,20 +2955,14 @@ msgstr "Si no se requieren aserciones, este patrón funciona bien." #: src\idioms/rustdoc-init.md:91 #, fuzzy msgid "" -"If they are, an alternative can be to create a public method to create a " -"helper\r\n" -"instance which is annotated with `#[doc(hidden)]` (so that users won't see " -"it).\r\n" -"Then this method can be called inside of rustdoc because it is part of " -"the\r\n" +"If they are, an alternative can be to create a public method to create a helper\r\n" +"instance which is annotated with `#[doc(hidden)]` (so that users won't see it).\r\n" +"Then this method can be called inside of rustdoc because it is part of the\r\n" "crate's public API." msgstr "" -"Si lo son, una alternativa puede ser crear un método público para crear un " -"ayudante.\r\n" -"instancia que está anotada con `#[doc(hidden)]` (para que los usuarios no la " -"vean).\r\n" -"Entonces este método se puede llamar dentro de rustdoc porque es parte " -"del\r\n" +"Si lo son, una alternativa puede ser crear un método público para crear un ayudante.\r\n" +"instancia que está anotada con `#[doc(hidden)]` (para que los usuarios no la vean).\r\n" +"Entonces este método se puede llamar dentro de rustdoc porque es parte del\r\n" "API pública de crate." #: src\idioms/temporary-mutability.md:1 @@ -3461,23 +2973,18 @@ msgstr "# Mutabilidad temporal" #: src\idioms/temporary-mutability.md:5 #, fuzzy msgid "" -"Often it is necessary to prepare and process some data, but after that data " -"are\n" -"only inspected and never modified. The intention can be made explicit by " -"redefining\n" +"Often it is necessary to prepare and process some data, but after that data are\n" +"only inspected and never modified. The intention can be made explicit by redefining\n" "the mutable variable as immutable." msgstr "" -"A menudo es necesario preparar y procesar algunos datos, pero después de eso " -"los datos son\n" -"solo inspeccionado y nunca modificado. La intención puede hacerse explícita " -"redefiniendo\n" +"A menudo es necesario preparar y procesar algunos datos, pero después de eso los datos son\n" +"solo inspeccionado y nunca modificado. La intención puede hacerse explícita redefiniendo\n" "la variable mutable como inmutable." #: src\idioms/temporary-mutability.md:9 #, fuzzy msgid "" -"It can be done either by processing data within a nested block or by " -"redefining\n" +"It can be done either by processing data within a nested block or by redefining\n" "the variable." msgstr "" "Se puede hacer procesando datos dentro de un bloque anidado o redefiniendo\n" @@ -3524,11 +3031,8 @@ msgstr "" #: src\idioms/temporary-mutability.md:40 #, fuzzy -msgid "" -"Compiler ensures that you don't accidentally mutate data after some point." -msgstr "" -"El compilador garantiza que no mute accidentalmente los datos después de " -"algún momento." +msgid "Compiler ensures that you don't accidentally mutate data after some point." +msgstr "El compilador garantiza que no mute accidentalmente los datos después de algún momento." #: src\idioms/temporary-mutability.md:44 #, fuzzy @@ -3547,12 +3051,10 @@ msgstr "# Devolver argumento consumido en caso de error" #: src\idioms/return-consumed-arg-on-error.md:5 #, fuzzy msgid "" -"If a fallible function consumes (moves) an argument, return that argument " -"back inside\n" +"If a fallible function consumes (moves) an argument, return that argument back inside\n" "an error." msgstr "" -"Si una función falible consume (mueve) un argumento, devuelva ese argumento " -"al interior\n" +"Si una función falible consume (mueve) un argumento, devuelva ese argumento al interior\n" "un error." #: src\idioms/return-consumed-arg-on-error.md:10 @@ -3562,8 +3064,7 @@ msgid "" " println!(\"using {value} in a meaningful way\");\n" " // Simulate non-deterministic fallible action.\n" " use std::time::SystemTime;\n" -" let period = " -"SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" +" let period = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" " if period.subsec_nanos() % 2 == 1 {\n" " Ok(())\n" " } else {\n" @@ -3601,8 +3102,7 @@ msgid "" "is not very efficient." msgstr "" "En caso de error, es posible que desee probar alguna forma alternativa o\n" -"reintentar la acción en caso de función no determinista. Pero si el " -"argumento\n" +"reintentar la acción en caso de función no determinista. Pero si el argumento\n" "siempre se consume, se ve obligado a clonarlo en cada llamada, lo que\n" "no es muy eficiente." @@ -3614,19 +3114,15 @@ msgid "" "is returned.\n" "You can get original vector back using `FromUtf8Error::into_bytes` method." msgstr "" -"La biblioteca estándar utiliza este enfoque en, p. Método " -"`String::from_utf8`.\n" +"La biblioteca estándar utiliza este enfoque en, p. Método `String::from_utf8`.\n" "Cuando se le da un vector que no contiene UTF-8 válido, un `FromUtf8Error`\n" "es regresado.\n" -"Puede recuperar el vector original usando el método " -"`FromUtf8Error::into_bytes`." +"Puede recuperar el vector original usando el método `FromUtf8Error::into_bytes`." #: src\idioms/return-consumed-arg-on-error.md:57 #, fuzzy msgid "Better performance because of moving arguments whenever possible." -msgstr "" -"Mejor rendimiento debido a los argumentos en movimiento siempre que sea " -"posible." +msgstr "Mejor rendimiento debido a los argumentos en movimiento siempre que sea posible." #: src\idioms/return-consumed-arg-on-error.md:61 #, fuzzy @@ -3641,54 +3137,39 @@ msgstr "# Patrones de diseño" #: src\patterns/index.md:3 #, fuzzy msgid "" -"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) " -"are\n" +"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) are\n" "\"general reusable solutions to a commonly occurring problem within a given\n" -"context in software design\". Design patterns are a great way to describe " -"the\n" -"culture of a programming language. Design patterns are very " -"language-specific -\n" +"context in software design\". Design patterns are a great way to describe the\n" +"culture of a programming language. Design patterns are very language-specific -\n" "what is a pattern in one language may be unnecessary in another due to a\n" "language feature, or impossible to express due to a missing feature." msgstr "" -"[Patrones de diseño](https://en.wikipedia.org/wiki/Software_design_pattern) " -"son\n" -"\"soluciones generales reutilizables para un problema común dentro de un " -"determinado\n" -"contexto en el diseño de software\". Los patrones de diseño son una " -"excelente manera de describir el\n" -"cultura de un lenguaje de programación. Los patrones de diseño son muy " -"específicos del idioma:\n" +"[Patrones de diseño](https://en.wikipedia.org/wiki/Software_design_pattern) son\n" +"\"soluciones generales reutilizables para un problema común dentro de un determinado\n" +"contexto en el diseño de software\". Los patrones de diseño son una excelente manera de describir el\n" +"cultura de un lenguaje de programación. Los patrones de diseño son muy específicos del idioma:\n" "lo que es un patrón en un idioma puede ser innecesario en otro debido a una\n" -"característica del idioma, o imposible de expresar debido a la falta de una " -"característica." +"característica del idioma, o imposible de expresar debido a la falta de una característica." #: src\patterns/index.md:10 #, fuzzy msgid "" "If overused, design patterns can add unnecessary complexity to programs.\n" -"However, they are a great way to share intermediate and advanced level " -"knowledge\n" +"However, they are a great way to share intermediate and advanced level knowledge\n" "about a programming language." msgstr "" -"Si se usan en exceso, los patrones de diseño pueden agregar una complejidad " -"innecesaria a los programas.\n" -"Sin embargo, son una excelente manera de compartir conocimientos de nivel " -"intermedio y avanzado.\n" +"Si se usan en exceso, los patrones de diseño pueden agregar una complejidad innecesaria a los programas.\n" +"Sin embargo, son una excelente manera de compartir conocimientos de nivel intermedio y avanzado.\n" "sobre un lenguaje de programación." #: src\patterns/index.md:16 #, fuzzy msgid "" -"Rust has many unique features. These features give us great benefit by " -"removing\n" -"whole classes of problems. Some of them are also patterns that are _unique_ " -"to Rust." +"Rust has many unique features. These features give us great benefit by removing\n" +"whole classes of problems. Some of them are also patterns that are _unique_ to Rust." msgstr "" -"Rust tiene muchas características únicas. Estas características nos brindan " -"un gran beneficio al eliminar\n" -"Clases enteras de problemas. Algunos de ellos también son patrones que son " -"_exclusivos_ de Rust." +"Rust tiene muchas características únicas. Estas características nos brindan un gran beneficio al eliminar\n" +"Clases enteras de problemas. Algunos de ellos también son patrones que son _exclusivos_ de Rust." #: src\patterns/index.md:19 #, fuzzy @@ -3702,8 +3183,7 @@ msgid "" "It's a vital software design principle to apply as you write code." msgstr "" "YAGNI es un acrónimo que significa `No lo vas a necesitar'.\n" -"Es un principio vital de diseño de software para aplicar mientras escribe " -"código." +"Es un principio vital de diseño de software para aplicar mientras escribe código." #: src\patterns/index.md:24 #, fuzzy @@ -3713,19 +3193,13 @@ msgstr "> El mejor código que jamás escribí fue código que nunca escribí." #: src\patterns/index.md:26 #, fuzzy msgid "" -"If we apply YAGNI to design patterns, we see that the features of Rust allow " -"us to\n" -"throw out many patterns. For instance, there is no need for the [strategy " -"pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"in Rust because we can just use " -"[traits](https://doc.rust-lang.org/book/traits.html)." +"If we apply YAGNI to design patterns, we see that the features of Rust allow us to\n" +"throw out many patterns. For instance, there is no need for the [strategy pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"in Rust because we can just use [traits](https://doc.rust-lang.org/book/traits.html)." msgstr "" -"Si aplicamos YAGNI a los patrones de diseño, vemos que las características " -"de Rust nos permiten\n" -"tirar muchos patrones. Por ejemplo, no es necesario el [patrón de " -"estrategia] (https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"en Rust porque solo podemos usar " -"[traits](https://doc.rust-lang.org/book/traits.html)." +"Si aplicamos YAGNI a los patrones de diseño, vemos que las características de Rust nos permiten\n" +"tirar muchos patrones. Por ejemplo, no es necesario el [patrón de estrategia] (https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"en Rust porque solo podemos usar [traits](https://doc.rust-lang.org/book/traits.html)." #: src\patterns/behavioural/intro.md:1 #, fuzzy @@ -3740,15 +3214,11 @@ msgstr "De [Wikipedia](https://en.wikipedia.org/wiki/Behavioral_pattern):" #: src\patterns/behavioural/intro.md:5 #, fuzzy msgid "" -"> Design patterns that identify common communication patterns among " -"objects.\n" -"> By doing so, these patterns increase flexibility in carrying out " -"communication." +"> Design patterns that identify common communication patterns among objects.\n" +"> By doing so, these patterns increase flexibility in carrying out communication." msgstr "" -"> Patrones de diseño que identifican patrones de comunicación comunes entre " -"objetos.\n" -"> Al hacerlo, estos patrones aumentan la flexibilidad en la realización de " -"la comunicación." +"> Patrones de diseño que identifican patrones de comunicación comunes entre objetos.\n" +"> Al hacerlo, estos patrones aumentan la flexibilidad en la realización de la comunicación." #: src\patterns/behavioural/command.md:1 #, fuzzy @@ -3758,8 +3228,7 @@ msgstr "# Dominio" #: src\patterns/behavioural/command.md:5 #, fuzzy msgid "" -"The basic idea of the Command pattern is to separate out actions into its " -"own\n" +"The basic idea of the Command pattern is to separate out actions into its own\n" "objects and pass them as parameters." msgstr "" "La idea básica del patrón Comando es separar las acciones en sus propias\n" @@ -3768,52 +3237,35 @@ msgstr "" #: src\patterns/behavioural/command.md:10 #, fuzzy msgid "" -"Suppose we have a sequence of actions or transactions encapsulated as " -"objects.\n" -"We want these actions or commands to be executed or invoked in some order " -"later\n" -"at different time. These commands may also be triggered as a result of some " -"event.\n" +"Suppose we have a sequence of actions or transactions encapsulated as objects.\n" +"We want these actions or commands to be executed or invoked in some order later\n" +"at different time. These commands may also be triggered as a result of some event.\n" "For example, when a user pushes a button, or on arrival of a data packet.\n" "In addition, these commands might be undoable. This may come in useful for\n" -"operations of an editor. We might want to store logs of executed commands so " -"that\n" +"operations of an editor. We might want to store logs of executed commands so that\n" "we could reapply the changes later if the system crashes." msgstr "" -"Supongamos que tenemos una secuencia de acciones o transacciones " -"encapsuladas como objetos.\n" -"Queremos que estas acciones o comandos se ejecuten o invoquen en algún orden " -"más adelante\n" -"en tiempo diferente. Estos comandos también pueden activarse como resultado " -"de algún evento.\n" -"Por ejemplo, cuando un usuario presiona un botón o cuando llega un paquete " -"de datos.\n" +"Supongamos que tenemos una secuencia de acciones o transacciones encapsuladas como objetos.\n" +"Queremos que estas acciones o comandos se ejecuten o invoquen en algún orden más adelante\n" +"en tiempo diferente. Estos comandos también pueden activarse como resultado de algún evento.\n" +"Por ejemplo, cuando un usuario presiona un botón o cuando llega un paquete de datos.\n" "Además, estos comandos se pueden deshacer. Esto puede ser útil para\n" -"operaciones de un editor. Podríamos querer almacenar registros de comandos " -"ejecutados para que\n" +"operaciones de un editor. Podríamos querer almacenar registros de comandos ejecutados para que\n" "podríamos volver a aplicar los cambios más tarde si el sistema falla." #: src\patterns/behavioural/command.md:20 #, fuzzy msgid "" -"Define two database operations `create table` and `add field`. Each of " -"these\n" -"operations is a command which knows how to undo the command, e.g., `drop " -"table`\n" -"and `remove field`. When a user invokes a database migration operation then " -"each\n" -"command is executed in the defined order, and when the user invokes the " -"rollback\n" +"Define two database operations `create table` and `add field`. Each of these\n" +"operations is a command which knows how to undo the command, e.g., `drop table`\n" +"and `remove field`. When a user invokes a database migration operation then each\n" +"command is executed in the defined order, and when the user invokes the rollback\n" "operation then the whole set of commands is invoked in reverse order." msgstr "" -"Defina dos operaciones de base de datos `crear tabla` y `agregar campo`. " -"Cada uno de estos\n" -"operaciones es un comando que sabe cómo deshacer el comando, por ejemplo, " -"`drop table`\n" -"y `eliminar campo`. Cuando un usuario invoca una operación de migración de " -"base de datos, cada\n" -"el comando se ejecuta en el orden definido, y cuando el usuario invoca la " -"reversión\n" +"Defina dos operaciones de base de datos `crear tabla` y `agregar campo`. Cada uno de estos\n" +"operaciones es un comando que sabe cómo deshacer el comando, por ejemplo, `drop table`\n" +"y `eliminar campo`. Cuando un usuario invoca una operación de migración de base de datos, cada\n" +"el comando se ejecuta en el orden definido, y cuando el usuario invoca la reversión\n" "operación, entonces todo el conjunto de comandos se invoca en orden inverso." #: src\patterns/behavioural/command.md:26 @@ -3828,8 +3280,7 @@ msgid "" "`execute` and `rollback`. All command `structs` must implement this trait." msgstr "" "Definimos un rasgo común que encapsula nuestro comando con dos operaciones\n" -"`ejecutar` y `retroceder`. Todas las `estructuras` de comando deben " -"implementar este rasgo." +"`ejecutar` y `retroceder`. Todas las `estructuras` de comando deben implementar este rasgo." #: src\patterns/behavioural/command.md:31 msgid "" @@ -3907,18 +3358,14 @@ msgstr "## Enfoque: uso de punteros de función" #, fuzzy msgid "" "We could follow another approach by creating each individual command as\n" -"a different function and store function pointers to invoke these functions " -"later\n" -"at a different time. Since function pointers implement all three traits " -"`Fn`,\n" +"a different function and store function pointers to invoke these functions later\n" +"at a different time. Since function pointers implement all three traits `Fn`,\n" "`FnMut`, and `FnOnce` we could as well pass and store closures instead of\n" "function pointers." msgstr "" "Podríamos seguir otro enfoque creando cada comando individual como\n" -"una función diferente y almacenar punteros de función para invocar estas " -"funciones más tarde\n" -"en un momento diferente. Dado que los punteros de función implementan los " -"tres rasgos `Fn`,\n" +"una función diferente y almacenar punteros de función para invocar estas funciones más tarde\n" +"en un momento diferente. Dado que los punteros de función implementan los tres rasgos `Fn`,\n" "`FnMut` y `FnOnce` también podríamos pasar y almacenar cierres en lugar de\n" "punteros de función." @@ -3964,8 +3411,7 @@ msgid "" "\n" "fn main() {\n" " let mut schema = Schema::new();\n" -" schema.add_migration(|| \"create table\".to_string(), || \"drop " -"table\".to_string());\n" +" schema.add_migration(|| \"create table\".to_string(), || \"drop table\".to_string());\n" " schema.add_migration(add_field, remove_field);\n" " assert_eq!(vec![\"create table\", \"add field\"], schema.execute());\n" " assert_eq!(vec![\"remove field\", \"drop table\"], schema.rollback());\n" @@ -3984,8 +3430,7 @@ msgid "" "Finally, instead of defining a common command trait we could store\n" "each command implementing the `Fn` trait separately in vectors." msgstr "" -"Finalmente, en lugar de definir un rasgo de comando común, podríamos " -"almacenar\n" +"Finalmente, en lugar de definir un rasgo de comando común, podríamos almacenar\n" "cada comando implementa el rasgo `Fn` por separado en vectores." #: src\patterns/behavioural/command.md:155 @@ -4042,61 +3487,47 @@ msgstr "" #: src\patterns/behavioural/command.md:205 #, fuzzy msgid "" -"If our commands are small and may be defined as functions or passed as a " -"closure\n" +"If our commands are small and may be defined as functions or passed as a closure\n" "then using function pointers might be preferable since it does not exploit\n" -"dynamic dispatch. But if our command is a whole struct with a bunch of " -"functions\n" +"dynamic dispatch. But if our command is a whole struct with a bunch of functions\n" "and variables defined as seperated module then using trait objects would be\n" -"more suitable. A case of application can be found in " -"[`actix`](https://actix.rs/),\n" +"more suitable. A case of application can be found in [`actix`](https://actix.rs/),\n" "which uses trait objects when it registers a handler function for routes.\n" -"In case of using `Fn` trait objects we can create and use commands in the " -"same\n" +"In case of using `Fn` trait objects we can create and use commands in the same\n" "way as we used in case of function pointers." msgstr "" -"Si nuestros comandos son pequeños y pueden definirse como funciones o " -"pasarse como cierre\n" +"Si nuestros comandos son pequeños y pueden definirse como funciones o pasarse como cierre\n" "entonces podría ser preferible usar punteros de función, ya que no explota\n" -"despacho dinámico. Pero si nuestro comando es una estructura completa con un " -"montón de funciones\n" -"y variables definidas como módulo separado, entonces usar objetos de rasgos " -"sería\n" -"mas apropiado. Se puede encontrar un caso de aplicación en " -"[`actix`](https://actix.rs/),\n" -"que usa objetos de rasgos cuando registra una función de controlador para " -"rutas.\n" -"En caso de usar objetos de rasgo `Fn` podemos crear y usar comandos en el " -"mismo\n" +"despacho dinámico. Pero si nuestro comando es una estructura completa con un montón de funciones\n" +"y variables definidas como módulo separado, entonces usar objetos de rasgos sería\n" +"mas apropiado. Se puede encontrar un caso de aplicación en [`actix`](https://actix.rs/),\n" +"que usa objetos de rasgos cuando registra una función de controlador para rutas.\n" +"En caso de usar objetos de rasgo `Fn` podemos crear y usar comandos en el mismo\n" "tal como lo usamos en el caso de los punteros de función." #: src\patterns/behavioural/command.md:214 #, fuzzy msgid "" "As performance, there is always a trade-off between performance and code\n" -"simplicity and organisation. Static dispatch gives faster performance, " -"while\n" +"simplicity and organisation. Static dispatch gives faster performance, while\n" "dynamic dispatch provides flexibility when we structure our application." msgstr "" -"Como rendimiento, siempre hay una compensación entre el rendimiento y el " -"código.\n" -"sencillez y organización. El despacho estático proporciona un rendimiento " -"más rápido, mientras que\n" -"El despacho dinámico proporciona flexibilidad cuando estructuramos nuestra " -"aplicación." +"Como rendimiento, siempre hay una compensación entre el rendimiento y el código.\n" +"sencillez y organización. El despacho estático proporciona un rendimiento más rápido, mientras que\n" +"El despacho dinámico proporciona flexibilidad cuando estructuramos nuestra aplicación." #: src\patterns/behavioural/command.md:220 #, fuzzy msgid "" "- [Command pattern](https://en.wikipedia.org/wiki/Command_pattern)\n" "\n" -"- [Another example for the `command` " -"pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-rust)" +"- [Another example for the `command` pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-" +"pattern-rust)" msgstr "" "- [Patrón de comando](https://en.wikipedia.org/wiki/Command_pattern)\n" "\n" -"- [Otro ejemplo del patrón " -"`comando`](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-rust)" +"- [Otro ejemplo del patrón `comando`](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-" +"rust)" #: src\patterns/behavioural/interpreter.md:1 #, fuzzy @@ -4106,20 +3537,14 @@ msgstr "# Intérprete" #: src\patterns/behavioural/interpreter.md:5 #, fuzzy msgid "" -"If a problem occurs very often and requires long and repetitive steps to " -"solve\n" -"it, then the problem instances might be expressed in a simple language and " -"an\n" -"interpreter object could solve it by interpreting the sentences written in " -"this\n" +"If a problem occurs very often and requires long and repetitive steps to solve\n" +"it, then the problem instances might be expressed in a simple language and an\n" +"interpreter object could solve it by interpreting the sentences written in this\n" "simple language." msgstr "" -"Si un problema ocurre con mucha frecuencia y requiere pasos largos y " -"repetitivos para resolverlo\n" -"entonces las instancias del problema podrían expresarse en un lenguaje " -"simple y un\n" -"El objeto intérprete podría resolverlo interpretando las oraciones escritas " -"en este\n" +"Si un problema ocurre con mucha frecuencia y requiere pasos largos y repetitivos para resolverlo\n" +"entonces las instancias del problema podrían expresarse en un lenguaje simple y un\n" +"El objeto intérprete podría resolverlo interpretando las oraciones escritas en este\n" "lenguaje sencillo" #: src\patterns/behavioural/interpreter.md:10 @@ -4130,33 +3555,26 @@ msgstr "Básicamente, para cualquier tipo de problema definimos:" #: src\patterns/behavioural/interpreter.md:12 #, fuzzy msgid "" -"- A [domain specific " -"language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- A [domain specific language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" "- A grammar for this language,\n" "- An interpreter that solves the problem instances." msgstr "" -"- Un [idioma específico del " -"dominio](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- Un [idioma específico del dominio](https://en.wikipedia.org/wiki/Domain-specific_language),\n" "- Una gramática para este idioma,\n" "- Un intérprete que resuelve las instancias del problema." #: src\patterns/behavioural/interpreter.md:18 #, fuzzy msgid "" -"Our goal is to translate simple mathematical expressions into postfix " -"expressions\n" -"(or [Reverse Polish " -"notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Our goal is to translate simple mathematical expressions into postfix expressions\n" +"(or [Reverse Polish notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" "For simplicity, our expressions consist of ten digits `0`, ..., `9` and two\n" "operations `+`, `-`. For example, the expression `2 + 4` is translated into\n" "`2 4 +`." msgstr "" -"Nuestro objetivo es traducir expresiones matemáticas simples en expresiones " -"postfix\n" -"(o [notación polaca " -"inversa](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" -"Para simplificar, nuestras expresiones constan de diez dígitos `0`, ..., `9` " -"y dos\n" +"Nuestro objetivo es traducir expresiones matemáticas simples en expresiones postfix\n" +"(o [notación polaca inversa](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Para simplificar, nuestras expresiones constan de diez dígitos `0`, ..., `9` y dos\n" "operaciones `+`, `-`. Por ejemplo, la expresión `2 + 4` se traduce a\n" "`2 4 +`." @@ -4168,16 +3586,12 @@ msgstr "## Gramática libre de contexto para nuestro problema" #: src\patterns/behavioural/interpreter.md:26 #, fuzzy msgid "" -"Our task is translating infix expressions into postfix ones. Let's define a " -"context\n" -"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and " -"`-`,\n" +"Our task is translating infix expressions into postfix ones. Let's define a context\n" +"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and `-`,\n" "where:" msgstr "" -"Nuestra tarea es traducir expresiones infijas a postfijas. Definamos un " -"contexto\n" -"gramática libre para un conjunto de expresiones infijas sobre `0`, ..., `9`, " -"`+` y `-`,\n" +"Nuestra tarea es traducir expresiones infijas a postfijas. Definamos un contexto\n" +"gramática libre para un conjunto de expresiones infijas sobre `0`, ..., `9`, `+` y `-`,\n" "dónde:" #: src\patterns/behavioural/interpreter.md:30 @@ -4206,20 +3620,16 @@ msgstr "" #: src\patterns/behavioural/interpreter.md:42 #, fuzzy msgid "" -"**NOTE:** This grammar should be further transformed depending on what we " -"are going\n" -"to do with it. For example, we might need to remove left recursion. For " -"more\n" -"details please see [Compilers: Principles,Techniques, and " -"Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools)\n" +"**NOTE:** This grammar should be further transformed depending on what we are going\n" +"to do with it. For example, we might need to remove left recursion. For more\n" +"details please see [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques," +"_and_Tools)\n" "(aka Dragon Book)." msgstr "" -"**NOTA:** Esta gramática debe transformarse aún más dependiendo de lo que " -"estemos haciendo\n" -"hacer con eso Por ejemplo, es posible que necesitemos eliminar la " -"recursividad por la izquierda. Para más\n" -"detalles, consulte [Compiladores: principios, técnicas y herramientas] " -"(https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools)\n" +"**NOTA:** Esta gramática debe transformarse aún más dependiendo de lo que estemos haciendo\n" +"hacer con eso Por ejemplo, es posible que necesitemos eliminar la recursividad por la izquierda. Para más\n" +"detalles, consulte [Compiladores: principios, técnicas y herramientas] (https://en.wikipedia.org/wiki/Compilers:_Principles," +"_Techniques,_and_Tools)\n" "(también conocido como Libro del Dragón)." #: src\patterns/behavioural/interpreter.md:47 @@ -4230,16 +3640,12 @@ msgstr "## Solución" #: src\patterns/behavioural/interpreter.md:49 #, fuzzy msgid "" -"We simply implement a recursive descent parser. For simplicity's sake, the " -"code\n" -"panics when an expression is syntactically wrong (for example `2-34` or " -"`2+5-`\n" +"We simply implement a recursive descent parser. For simplicity's sake, the code\n" +"panics when an expression is syntactically wrong (for example `2-34` or `2+5-`\n" "are wrong according to the grammar definition)." msgstr "" -"Simplemente implementamos un analizador de descenso recursivo. En aras de la " -"simplicidad, el código\n" -"entra en pánico cuando una expresión es sintácticamente incorrecta (por " -"ejemplo, `2-34` o `2+5-`\n" +"Simplemente implementamos un analizador de descenso recursivo. En aras de la simplicidad, el código\n" +"entra en pánico cuando una expresión es sintácticamente incorrecta (por ejemplo, `2-34` o `2+5-`\n" "están mal según la definición gramatical)." #: src\patterns/behavioural/interpreter.md:53 @@ -4298,28 +3704,18 @@ msgstr "" #: src\patterns/behavioural/interpreter.md:105 #, fuzzy msgid "" -"There may be a wrong perception that the Interpreter design pattern is about " -"design\n" -"grammars for formal languages and implementation of parsers for these " -"grammars.\n" -"In fact, this pattern is about expressing problem instances in a more " -"specific\n" -"way and implementing functions/classes/structs that solve these problem " -"instances.\n" -"Rust language has `macro_rules!` that allow us to define special syntax and " -"rules\n" +"There may be a wrong perception that the Interpreter design pattern is about design\n" +"grammars for formal languages and implementation of parsers for these grammars.\n" +"In fact, this pattern is about expressing problem instances in a more specific\n" +"way and implementing functions/classes/structs that solve these problem instances.\n" +"Rust language has `macro_rules!` that allow us to define special syntax and rules\n" "on how to expand this syntax into source code." msgstr "" -"Puede haber una percepción errónea de que el patrón de diseño del Intérprete " -"se trata de diseño\n" -"gramáticas para lenguajes formales e implementación de analizadores para " -"estas gramáticas.\n" -"De hecho, este patrón se trata de expresar instancias de problemas en una " -"forma más específica.\n" -"e implementando funciones/clases/estructuras que resuelven estas instancias " -"de problemas.\n" -"El lenguaje Rust tiene `macro_rules!` que nos permiten definir sintaxis y " -"reglas especiales\n" +"Puede haber una percepción errónea de que el patrón de diseño del Intérprete se trata de diseño\n" +"gramáticas para lenguajes formales e implementación de analizadores para estas gramáticas.\n" +"De hecho, este patrón se trata de expresar instancias de problemas en una forma más específica.\n" +"e implementando funciones/clases/estructuras que resuelven estas instancias de problemas.\n" +"El lenguaje Rust tiene `macro_rules!` que nos permiten definir sintaxis y reglas especiales\n" "sobre cómo expandir esta sintaxis en el código fuente." #: src\patterns/behavioural/interpreter.md:112 @@ -4327,19 +3723,14 @@ msgstr "" msgid "" "In the following example we create a simple `macro_rules!` that computes\n" "[Euclidean length](https://en.wikipedia.org/wiki/Euclidean_distance) of `n`\n" -"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and " -"more\n" -"efficient than packing `x,1,2` into a `Vec` and calling a function " -"computing\n" +"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and more\n" +"efficient than packing `x,1,2` into a `Vec` and calling a function computing\n" "the length." msgstr "" "En el siguiente ejemplo, creamos un `macro_rules!` simple que calcula\n" -"[Longitud euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance) de " -"`n`\n" -"vectores dimensionales. Escribir `norma!(x,1,2)` podría ser más fácil de " -"expresar y más\n" -"más eficiente que empaquetar `x,1,2` en un `Vec` y llamar a una función " -"informática\n" +"[Longitud euclidiana](https://en.wikipedia.org/wiki/Euclidean_distance) de `n`\n" +"vectores dimensionales. Escribir `norma!(x,1,2)` podría ser más fácil de expresar y más\n" +"más eficiente que empaquetar `x,1,2` en un `Vec` y llamar a una función informática\n" "la longitud." #: src\patterns/behavioural/interpreter.md:118 @@ -4373,13 +3764,11 @@ msgstr "" #, fuzzy msgid "" "- [Interpreter pattern](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" -"- [Context free " -"grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [Context free grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" "- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" msgstr "" "- [Patrón de intérprete](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" -"- [Gramática libre de " -"contexto](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [Gramática libre de contexto](https://en.wikipedia.org/wiki/Context-free_grammar)\n" "- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" #: src\patterns/behavioural/newtype.md:1 @@ -4394,45 +3783,36 @@ msgid "" "enforce some behaviour at compile time when using only type aliases would\n" "not be enough?" msgstr "" -"¿Qué pasa si en algunos casos queremos que un tipo se comporte de manera " -"similar a otro tipo o\n" -"hacer cumplir algún comportamiento en tiempo de compilación cuando usar solo " -"alias de tipo sería\n" +"¿Qué pasa si en algunos casos queremos que un tipo se comporte de manera similar a otro tipo o\n" +"hacer cumplir algún comportamiento en tiempo de compilación cuando usar solo alias de tipo sería\n" "no ser suficiente?" #: src\patterns/behavioural/newtype.md:7 #, fuzzy msgid "" -"For example, if we want to create a custom `Display` implementation for " -"`String`\n" +"For example, if we want to create a custom `Display` implementation for `String`\n" "due to security considerations (e.g. passwords)." msgstr "" -"Por ejemplo, si queremos crear una implementación `Display` personalizada " -"para `String`\n" +"Por ejemplo, si queremos crear una implementación `Display` personalizada para `String`\n" "debido a consideraciones de seguridad (por ejemplo, contraseñas)." #: src\patterns/behavioural/newtype.md:10 #, fuzzy msgid "" -"For such cases we could use the `Newtype` pattern to provide **type " -"safety**\n" +"For such cases we could use the `Newtype` pattern to provide **type safety**\n" "and **encapsulation**." msgstr "" -"Para tales casos, podríamos usar el patrón `Newtype` para proporcionar " -"**seguridad de tipo**\n" +"Para tales casos, podríamos usar el patrón `Newtype` para proporcionar **seguridad de tipo**\n" "y **encapsulación**." #: src\patterns/behavioural/newtype.md:15 #, fuzzy msgid "" -"Use a tuple struct with a single field to make an opaque wrapper for a " -"type.\n" +"Use a tuple struct with a single field to make an opaque wrapper for a type.\n" "This creates a new type, rather than an alias to a type (`type` items)." msgstr "" -"Use una estructura de tupla con un solo campo para crear un contenedor opaco " -"para un tipo.\n" -"Esto crea un nuevo tipo, en lugar de un alias para un tipo (elementos " -"`tipo`)." +"Use una estructura de tupla con un solo campo para crear un contenedor opaco para un tipo.\n" +"Esto crea un nuevo tipo, en lugar de un alias para un tipo (elementos `tipo`)." #: src\patterns/behavioural/newtype.md:20 msgid "" @@ -4477,18 +3857,13 @@ msgstr "" #, fuzzy msgid "" "The primary motivation for newtypes is abstraction. It allows you to share\n" -"implementation details between types while precisely controlling the " -"interface.\n" -"By using a newtype rather than exposing the implementation type as part of " -"an\n" +"implementation details between types while precisely controlling the interface.\n" +"By using a newtype rather than exposing the implementation type as part of an\n" "API, it allows you to change implementation backwards compatibly." msgstr "" -"La principal motivación para los nuevos tipos es la abstracción. Te permite " -"compartir\n" -"detalles de implementación entre tipos mientras controla con precisión la " -"interfaz.\n" -"Al usar un nuevo tipo en lugar de exponer el tipo de implementación como " -"parte de un\n" +"La principal motivación para los nuevos tipos es la abstracción. Te permite compartir\n" +"detalles de implementación entre tipos mientras controla con precisión la interfaz.\n" +"Al usar un nuevo tipo en lugar de exponer el tipo de implementación como parte de un\n" "API, le permite cambiar la implementación de manera retrocompatible." #: src\patterns/behavioural/newtype.md:63 @@ -4497,88 +3872,69 @@ msgid "" "Newtypes can be used for distinguishing units, e.g., wrapping `f64` to give\n" "distinguishable `Miles` and `Kilometres`." msgstr "" -"Los tipos nuevos se pueden usar para distinguir unidades, por ejemplo, " -"envolviendo `f64` para dar\n" +"Los tipos nuevos se pueden usar para distinguir unidades, por ejemplo, envolviendo `f64` para dar\n" "distinguibles `Millas` y `Kilómetros`." #: src\patterns/behavioural/newtype.md:68 #, fuzzy msgid "" "The wrapped and wrapper types are not type compatible (as opposed to using\n" -"`type`), so users of the newtype will never 'confuse' the wrapped and " -"wrapper\n" +"`type`), so users of the newtype will never 'confuse' the wrapped and wrapper\n" "types." msgstr "" "Los tipos wrapper y wrapper no son compatibles (a diferencia de usar\n" -"`tipo`), por lo que los usuarios del nuevo tipo nunca 'confundirán' el " -"envuelto y el envoltorio\n" +"`tipo`), por lo que los usuarios del nuevo tipo nunca 'confundirán' el envuelto y el envoltorio\n" "tipos" #: src\patterns/behavioural/newtype.md:72 #, fuzzy msgid "Newtypes are a zero-cost abstraction - there is no runtime overhead." -msgstr "" -"Los tipos nuevos son una abstracción de costo cero: no hay sobrecarga de " -"tiempo de ejecución." +msgstr "Los tipos nuevos son una abstracción de costo cero: no hay sobrecarga de tiempo de ejecución." #: src\patterns/behavioural/newtype.md:74 #, fuzzy msgid "" -"The privacy system ensures that users cannot access the wrapped type (if " -"the\n" +"The privacy system ensures that users cannot access the wrapped type (if the\n" "field is private, which it is by default)." msgstr "" -"El sistema de privacidad garantiza que los usuarios no puedan acceder al " -"tipo envuelto (si el\n" +"El sistema de privacidad garantiza que los usuarios no puedan acceder al tipo envuelto (si el\n" "el campo es privado, que es por defecto)." #: src\patterns/behavioural/newtype.md:79 #, fuzzy msgid "" -"The downside of newtypes (especially compared with type aliases), is that " -"there\n" -"is no special language support. This means there can be _a lot_ of " -"boilerplate.\n" +"The downside of newtypes (especially compared with type aliases), is that there\n" +"is no special language support. This means there can be _a lot_ of boilerplate.\n" "You need a 'pass through' method for every method you want to expose on the\n" -"wrapped type, and an impl for every trait you want to also be implemented " -"for\n" +"wrapped type, and an impl for every trait you want to also be implemented for\n" "the wrapper type." msgstr "" -"La desventaja de los nuevos tipos (especialmente en comparación con los " -"alias de tipo) es que no\n" -"no hay soporte de idioma especial. Esto significa que puede haber _mucho_ " -"repetitivo.\n" -"Necesita un método de 'paso a través' para cada método que desee exponer en " -"el\n" +"La desventaja de los nuevos tipos (especialmente en comparación con los alias de tipo) es que no\n" +"no hay soporte de idioma especial. Esto significa que puede haber _mucho_ repetitivo.\n" +"Necesita un método de 'paso a través' para cada método que desee exponer en el\n" "tipo envuelto, y un impl para cada rasgo que desea implementar también para\n" "el tipo de envoltura." #: src\patterns/behavioural/newtype.md:87 #, fuzzy msgid "" -"Newtypes are very common in Rust code. Abstraction or representing units are " -"the\n" +"Newtypes are very common in Rust code. Abstraction or representing units are the\n" "most common uses, but they can be used for other reasons:" msgstr "" -"Los tipos nuevos son muy comunes en el código de Rust. Las unidades de " -"abstracción o representación son las\n" +"Los tipos nuevos son muy comunes en el código de Rust. Las unidades de abstracción o representación son las\n" "usos más comunes, pero pueden ser utilizados por otras razones:" #: src\patterns/behavioural/newtype.md:90 #, fuzzy msgid "" -"- restricting functionality (reduce the functions exposed or traits " -"implemented),\n" +"- restricting functionality (reduce the functions exposed or traits implemented),\n" "- making a type with copy semantics have move semantics,\n" -"- abstraction by providing a more concrete type and thus hiding internal " -"types,\n" +"- abstraction by providing a more concrete type and thus hiding internal types,\n" " e.g.," msgstr "" -"- restringir la funcionalidad (reducir las funciones expuestas o los rasgos " -"implementados),\n" +"- restringir la funcionalidad (reducir las funciones expuestas o los rasgos implementados),\n" "- hacer que un tipo con semántica de copia tenga semántica de movimiento,\n" -"- abstracción proporcionando un tipo más concreto y ocultando así los tipos " -"internos,\n" +"- abstracción proporcionando un tipo más concreto y ocultando así los tipos internos,\n" " p.ej.," #: src\patterns/behavioural/newtype.md:95 @@ -4591,47 +3947,34 @@ msgstr "" #: src\patterns/behavioural/newtype.md:99 #, fuzzy msgid "" -"Here, `Bar` might be some public, generic type and `T1` and `T2` are some " -"internal\n" -"types. Users of our module shouldn't know that we implement `Foo` by using a " -"`Bar`,\n" -"but what we're really hiding here is the types `T1` and `T2`, and how they " -"are used\n" +"Here, `Bar` might be some public, generic type and `T1` and `T2` are some internal\n" +"types. Users of our module shouldn't know that we implement `Foo` by using a `Bar`,\n" +"but what we're really hiding here is the types `T1` and `T2`, and how they are used\n" "with `Bar`." msgstr "" -"Aquí, 'Bar' podría ser un tipo genérico público y 'T1' y 'T2' son algunos " -"internos.\n" -"tipos Los usuarios de nuestro módulo no deberían saber que implementamos " -"`Foo` usando una `Bar`,\n" -"pero lo que realmente estamos ocultando aquí son los tipos `T1` y `T2`, y " -"cómo se usan\n" +"Aquí, 'Bar' podría ser un tipo genérico público y 'T1' y 'T2' son algunos internos.\n" +"tipos Los usuarios de nuestro módulo no deberían saber que implementamos `Foo` usando una `Bar`,\n" +"pero lo que realmente estamos ocultando aquí son los tipos `T1` y `T2`, y cómo se usan\n" "con `Barra`." #: src\patterns/behavioural/newtype.md:106 #, fuzzy msgid "" -"- [Advanced Types in the " -"book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-type-safety-and-abstraction)\n" +"- [Advanced Types in the book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-" +"for-type-safety-and-abstraction)\n" "- [Newtypes in Haskell](https://wiki.haskell.org/Newtype)\n" -"- [Type " -"aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" -"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving " -"many\n" +"- [Type aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving many\n" " builtin traits on newtypes.\n" -"- [The Newtype Pattern In " -"Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +"- [The Newtype Pattern In Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" msgstr "" -"- [Tipos avanzados en el " -"libro](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-type-safety " -"-y-abstracción)\n" +"- [Tipos avanzados en el libro](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-" +"for-type-safety -y-abstracción)\n" "- [Nuevos tipos en Haskell](https://wiki.haskell.org/Newtype)\n" -"- [Escriba " -"alias](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" -"- [derive_more](https://crates.io/crates/derive_more), una caja para derivar " -"muchos\n" +"- [Escriba alias](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), una caja para derivar muchos\n" " rasgos incorporados en newtypes.\n" -"- [El patrón Newtype en " -"Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +"- [El patrón Newtype en Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" #: src\patterns/behavioural/RAII.md:1 #, fuzzy @@ -4641,36 +3984,25 @@ msgstr "# RAII con guardias" #: src\patterns/behavioural/RAII.md:5 #, fuzzy msgid "" -"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" " -"which is a\n" -"terrible name. The essence of the pattern is that resource initialisation is " -"done\n" -"in the constructor of an object and finalisation in the destructor. This " -"pattern\n" -"is extended in Rust by using a RAII object as a guard of some resource and " -"relying\n" -"on the type system to ensure that access is always mediated by the guard " -"object." -msgstr "" -"[RAII][wikipedia] significa \"Adquisición de recursos es inicialización\", " -"que es una\n" -"terrible nombre La esencia del patrón es que la inicialización de recursos " -"se realiza\n" +"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" which is a\n" +"terrible name. The essence of the pattern is that resource initialisation is done\n" +"in the constructor of an object and finalisation in the destructor. This pattern\n" +"is extended in Rust by using a RAII object as a guard of some resource and relying\n" +"on the type system to ensure that access is always mediated by the guard object." +msgstr "" +"[RAII][wikipedia] significa \"Adquisición de recursos es inicialización\", que es una\n" +"terrible nombre La esencia del patrón es que la inicialización de recursos se realiza\n" "en el constructor de un objeto y finalización en el destructor. este patrón\n" -"se extiende en Rust usando un objeto RAII como guardián de algún recurso y " -"confiando\n" -"en el sistema de tipos para garantizar que el acceso siempre esté mediado " -"por el objeto guardián." +"se extiende en Rust usando un objeto RAII como guardián de algún recurso y confiando\n" +"en el sistema de tipos para garantizar que el acceso siempre esté mediado por el objeto guardián." #: src\patterns/behavioural/RAII.md:13 #, fuzzy msgid "" -"Mutex guards are the classic example of this pattern from the std library " -"(this\n" +"Mutex guards are the classic example of this pattern from the std library (this\n" "is a simplified version of the real implementation):" msgstr "" -"Los protectores Mutex son el ejemplo clásico de este patrón de la biblioteca " -"estándar (este\n" +"Los protectores Mutex son el ejemplo clásico de este patrón de la biblioteca estándar (este\n" "es una versión simplificada de la implementación real):" #: src\patterns/behavioural/RAII.md:16 @@ -4724,12 +4056,10 @@ msgid "" "fn baz(x: Mutex) {\n" " let xx = x.lock();\n" " xx.foo(); // foo is a method on Foo.\n" -" // The borrow checker ensures we can't store a reference to the " -"underlying\n" +" // The borrow checker ensures we can't store a reference to the underlying\n" " // Foo which will outlive the guard xx.\n" "\n" -" // x is unlocked when we exit this function and xx's destructor is " -"executed.\n" +" // x is unlocked when we exit this function and xx's destructor is executed.\n" "}\n" "```" msgstr "" @@ -4738,64 +4068,49 @@ msgstr "" #, fuzzy msgid "" "Where a resource must be finalised after use, RAII can be used to do this\n" -"finalisation. If it is an error to access that resource after finalisation, " -"then\n" +"finalisation. If it is an error to access that resource after finalisation, then\n" "this pattern can be used to prevent such errors." msgstr "" -"Cuando un recurso debe finalizarse después de su uso, se puede usar RAII " -"para hacer esto\n" -"finalización Si es un error acceder a ese recurso después de la " -"finalización, entonces\n" +"Cuando un recurso debe finalizarse después de su uso, se puede usar RAII para hacer esto\n" +"finalización Si es un error acceder a ese recurso después de la finalización, entonces\n" "este patrón se puede utilizar para evitar tales errores." #: src\patterns/behavioural/RAII.md:80 #, fuzzy msgid "" -"Prevents errors where a resource is not finalised and where a resource is " -"used\n" +"Prevents errors where a resource is not finalised and where a resource is used\n" "after finalisation." msgstr "" -"Previene errores donde un recurso no está finalizado y donde se usa un " -"recurso\n" +"Previene errores donde un recurso no está finalizado y donde se usa un recurso\n" "después de la finalización." #: src\patterns/behavioural/RAII.md:85 #, fuzzy msgid "" "RAII is a useful pattern for ensuring resources are properly deallocated or\n" -"finalised. We can make use of the borrow checker in Rust to statically " -"prevent\n" +"finalised. We can make use of the borrow checker in Rust to statically prevent\n" "errors stemming from using resources after finalisation takes place." msgstr "" "RAII es un patrón útil para garantizar que los recursos se desasignen o\n" -"finalizado. Podemos hacer uso del verificador de préstamos en Rust para " -"evitar estáticamente\n" +"finalizado. Podemos hacer uso del verificador de préstamos en Rust para evitar estáticamente\n" "errores derivados del uso de recursos después de la finalización." #: src\patterns/behavioural/RAII.md:89 #, fuzzy msgid "" -"The core aim of the borrow checker is to ensure that references to data do " -"not\n" +"The core aim of the borrow checker is to ensure that references to data do not\n" "outlive that data. The RAII guard pattern works because the guard object\n" "contains a reference to the underlying resource and only exposes such\n" -"references. Rust ensures that the guard cannot outlive the underlying " -"resource\n" -"and that references to the resource mediated by the guard cannot outlive " -"the\n" -"guard. To see how this works it is helpful to examine the signature of " -"`deref`\n" +"references. Rust ensures that the guard cannot outlive the underlying resource\n" +"and that references to the resource mediated by the guard cannot outlive the\n" +"guard. To see how this works it is helpful to examine the signature of `deref`\n" "without lifetime elision:" msgstr "" -"El objetivo principal del verificador de préstamos es garantizar que las " -"referencias a los datos no\n" -"sobrevivir a esos datos. El patrón de protección RAII funciona porque el " -"objeto de protección\n" +"El objetivo principal del verificador de préstamos es garantizar que las referencias a los datos no\n" +"sobrevivir a esos datos. El patrón de protección RAII funciona porque el objeto de protección\n" "contiene una referencia al recurso subyacente y solo expone tal\n" -"referencias Rust asegura que el guardia no puede sobrevivir al recurso " -"subyacente\n" -"y que las referencias al recurso mediado por la guardia no pueden sobrevivir " -"al\n" +"referencias Rust asegura que el guardia no puede sobrevivir al recurso subyacente\n" +"y que las referencias al recurso mediado por la guardia no pueden sobrevivir al\n" "guardia. Para ver cómo funciona esto, es útil examinar la firma de `deref`\n" "sin elisión de por vida:" @@ -4811,31 +4126,23 @@ msgstr "" #: src\patterns/behavioural/RAII.md:103 #, fuzzy msgid "" -"The returned reference to the resource has the same lifetime as `self` " -"(`'a`).\n" -"The borrow checker therefore ensures that the lifetime of the reference to " -"`T`\n" +"The returned reference to the resource has the same lifetime as `self` (`'a`).\n" +"The borrow checker therefore ensures that the lifetime of the reference to `T`\n" "is shorter than the lifetime of `self`." msgstr "" -"La referencia devuelta al recurso tiene la misma duración que `self` " -"(`'a`).\n" -"Por lo tanto, el verificador de préstamos garantiza que la vida útil de la " -"referencia a `T`\n" +"La referencia devuelta al recurso tiene la misma duración que `self` (`'a`).\n" +"Por lo tanto, el verificador de préstamos garantiza que la vida útil de la referencia a `T`\n" "es más corto que el tiempo de vida de `sí mismo`." #: src\patterns/behavioural/RAII.md:107 #, fuzzy msgid "" -"Note that implementing `Deref` is not a core part of this pattern, it only " -"makes\n" -"using the guard object more ergonomic. Implementing a `get` method on the " -"guard\n" +"Note that implementing `Deref` is not a core part of this pattern, it only makes\n" +"using the guard object more ergonomic. Implementing a `get` method on the guard\n" "works just as well." msgstr "" -"Tenga en cuenta que la implementación de `Deref` no es una parte central de " -"este patrón, solo hace\n" -"utilizando el objeto de guardia más ergonómico. Implementando un método " -"`get` en el guardia\n" +"Tenga en cuenta que la implementación de `Deref` no es una parte central de este patrón, solo hace\n" +"utilizando el objeto de guardia más ergonómico. Implementando un método `get` en el guardia\n" "funciona igual de bien." #: src\patterns/behavioural/RAII.md:113 @@ -4846,23 +4153,19 @@ msgstr "[Finalización en idioma de destructores](../../idioms/dtor-finally.md)" #: src\patterns/behavioural/RAII.md:115 #, fuzzy msgid "" -"RAII is a common pattern in C++: " -"[cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"RAII is a common pattern in C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" "[wikipedia][wikipedia]." msgstr "" -"RAII es un patrón común en C++: " -"[cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"RAII es un patrón común en C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" "[wikipedia][wikipedia]." #: src\patterns/behavioural/RAII.md:120 #, fuzzy msgid "" -"[Style guide " -"entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"[Style guide entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" "(currently just a placeholder)." msgstr "" -"[Entrada de guía de " -"estilo](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"[Entrada de guía de estilo](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" "(actualmente solo un marcador de posición)." #: src\patterns/behavioural/strategy.md:1 @@ -4873,94 +4176,68 @@ msgstr "# Estrategia (también conocida como Política)" #: src\patterns/behavioural/strategy.md:5 #, fuzzy msgid "" -"The [Strategy design " -"pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"The [Strategy design pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" "is a technique that enables separation of concerns.\n" -"It also allows to decouple software modules through [Dependency " -"Inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +"It also allows to decouple software modules through [Dependency Inversion](https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." msgstr "" -"El [patrón de diseño de estrategia] " -"(https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"El [patrón de diseño de estrategia] (https://en.wikipedia.org/wiki/Strategy_pattern)\n" "es una técnica que permite la separación de preocupaciones.\n" -"También permite desacoplar módulos de software a través de [Inversión de " -"dependencia] (https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +"También permite desacoplar módulos de software a través de [Inversión de dependencia] (https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." #: src\patterns/behavioural/strategy.md:9 #, fuzzy msgid "" -"The basic idea behind the Strategy pattern is that, given an algorithm " -"solving\n" -"a particular problem, we define only the skeleton of the algorithm at an " -"abstract\n" -"level, and we separate the specific algorithm’s implementation into " -"different parts." +"The basic idea behind the Strategy pattern is that, given an algorithm solving\n" +"a particular problem, we define only the skeleton of the algorithm at an abstract\n" +"level, and we separate the specific algorithm’s implementation into different parts." msgstr "" -"La idea básica detrás del patrón de estrategia es que, dado un algoritmo que " -"resuelve\n" -"un problema particular, definimos solo el esqueleto del algoritmo en un " -"resumen\n" -"nivel, y separamos la implementación del algoritmo específico en diferentes " -"partes." +"La idea básica detrás del patrón de estrategia es que, dado un algoritmo que resuelve\n" +"un problema particular, definimos solo el esqueleto del algoritmo en un resumen\n" +"nivel, y separamos la implementación del algoritmo específico en diferentes partes." #: src\patterns/behavioural/strategy.md:13 #, fuzzy msgid "" -"In this way, a client using the algorithm may choose a specific " -"implementation,\n" -"while the general algorithm workflow remains the same. In other words, the " -"abstract\n" -"specification of the class does not depend on the specific implementation of " -"the\n" -"derived class, but specific implementation must adhere to the abstract " -"specification.\n" +"In this way, a client using the algorithm may choose a specific implementation,\n" +"while the general algorithm workflow remains the same. In other words, the abstract\n" +"specification of the class does not depend on the specific implementation of the\n" +"derived class, but specific implementation must adhere to the abstract specification.\n" "This is why we call it \"Dependency Inversion\"." msgstr "" -"De esta forma, un cliente que utilice el algoritmo puede elegir una " -"implementación específica,\n" -"mientras que el flujo de trabajo general del algoritmo sigue siendo el " -"mismo. En otras palabras, el resumen\n" +"De esta forma, un cliente que utilice el algoritmo puede elegir una implementación específica,\n" +"mientras que el flujo de trabajo general del algoritmo sigue siendo el mismo. En otras palabras, el resumen\n" "especificación de la clase no depende de la implementación específica de la\n" -"clase derivada, pero la implementación específica debe adherirse a la " -"especificación abstracta.\n" +"clase derivada, pero la implementación específica debe adherirse a la especificación abstracta.\n" "Es por eso que lo llamamos \"Inversión de Dependencia\"." #: src\patterns/behavioural/strategy.md:21 #, fuzzy msgid "" "Imagine we are working on a project that generates reports every month.\n" -"We need the reports to be generated in different formats (strategies), " -"e.g.,\n" +"We need the reports to be generated in different formats (strategies), e.g.,\n" "in `JSON` or `Plain Text` formats.\n" -"But things vary over time, and we don't know what kind of requirement we may " -"get\n" -"in the future. For example, we may need to generate our report in a " -"completely new\n" +"But things vary over time, and we don't know what kind of requirement we may get\n" +"in the future. For example, we may need to generate our report in a completely new\n" "format, or just modify one of the existing formats." msgstr "" -"Imagina que estamos trabajando en un proyecto que genera informes todos los " -"meses.\n" -"Necesitamos que los informes se generen en diferentes formatos " -"(estrategias), por ejemplo,\n" +"Imagina que estamos trabajando en un proyecto que genera informes todos los meses.\n" +"Necesitamos que los informes se generen en diferentes formatos (estrategias), por ejemplo,\n" "en formatos `JSON` o `Plain Text`.\n" -"Pero las cosas varían con el tiempo, y no sabemos qué tipo de requisito " -"podemos obtener\n" -"en el futuro. Por ejemplo, es posible que necesitemos generar nuestro " -"informe en un formato completamente nuevo.\n" +"Pero las cosas varían con el tiempo, y no sabemos qué tipo de requisito podemos obtener\n" +"en el futuro. Por ejemplo, es posible que necesitemos generar nuestro informe en un formato completamente nuevo.\n" "formato, o simplemente modificar uno de los formatos existentes." #: src\patterns/behavioural/strategy.md:30 #, fuzzy msgid "" -"In this example our invariants (or abstractions) are `Context`, " -"`Formatter`,\n" -"and `Report`, while `Text` and `Json` are our strategy structs. These " -"strategies\n" +"In this example our invariants (or abstractions) are `Context`, `Formatter`,\n" +"and `Report`, while `Text` and `Json` are our strategy structs. These strategies\n" "have to implement the `Formatter` trait." msgstr "" -"En este ejemplo, nuestras invariantes (o abstracciones) son `Context`, " -"`Formatter`,\n" -"y `Report`, mientras que `Text` y `Json` son nuestras estructuras de " -"estrategia. Estas estrategias\n" +"En este ejemplo, nuestras invariantes (o abstracciones) son `Context`, `Formatter`,\n" +"y `Report`, mientras que `Text` y `Json` son nuestras estructuras de estrategia. Estas estrategias\n" "tiene que implementar el rasgo `Formatter`." #: src\patterns/behavioural/strategy.md:34 @@ -4977,8 +4254,7 @@ msgid "" "struct Report;\n" "\n" "impl Report {\n" -" // Write should be used but we kept it as String to ignore error " -"handling\n" +" // Write should be used but we kept it as String to ignore error handling\n" " fn generate(g: T, s: &mut String) {\n" " // backend operations...\n" " let mut data = HashMap::new();\n" @@ -4993,8 +4269,7 @@ msgid "" "impl Formatter for Text {\n" " fn format(&self, data: &Data, buf: &mut String) {\n" " for (k, v) in data {\n" -" let entry = format!(\"{} {}\\n" -"\", k, v);\n" +" let entry = format!(\"{} {}\\n\", k, v);\n" " buf.push_str(&entry);\n" " }\n" " }\n" @@ -5033,38 +4308,28 @@ msgstr "" #: src\patterns/behavioural/strategy.md:98 #, fuzzy msgid "" -"The main advantage is separation of concerns. For example, in this case " -"`Report`\n" +"The main advantage is separation of concerns. For example, in this case `Report`\n" "does not know anything about specific implementations of `Json` and `Text`,\n" -"whereas the output implementations does not care about how data is " -"preprocessed,\n" -"stored, and fetched. The only thing they have to know is context and a " -"specific\n" +"whereas the output implementations does not care about how data is preprocessed,\n" +"stored, and fetched. The only thing they have to know is context and a specific\n" "trait and method to implement, i.e,`Formatter` and `run`." msgstr "" -"La principal ventaja es la separación de preocupaciones. Por ejemplo, en " -"este caso `Informe`\n" +"La principal ventaja es la separación de preocupaciones. Por ejemplo, en este caso `Informe`\n" "no sabe nada sobre implementaciones específicas de `Json` y `Text`,\n" -"mientras que las implementaciones de salida no se preocupan por cómo se " -"preprocesan los datos,\n" -"almacenado y obtenido. Lo único que tienen que saber es el contexto y una " -"determinada\n" +"mientras que las implementaciones de salida no se preocupan por cómo se preprocesan los datos,\n" +"almacenado y obtenido. Lo único que tienen que saber es el contexto y una determinada\n" "rasgo y método a implementar, es decir, `Formatter` y `run`." #: src\patterns/behavioural/strategy.md:106 #, fuzzy msgid "" -"For each strategy there must be implemented at least one module, so number " -"of modules\n" -"increases with number of strategies. If there are many strategies to choose " -"from\n" +"For each strategy there must be implemented at least one module, so number of modules\n" +"increases with number of strategies. If there are many strategies to choose from\n" "then users have to know how strategies differ from one another." msgstr "" -"Para cada estrategia debe implementarse al menos un módulo, por lo que el " -"número de módulos\n" +"Para cada estrategia debe implementarse al menos un módulo, por lo que el número de módulos\n" "aumenta con el número de estrategias. Si hay muchas estrategias para elegir\n" -"luego los usuarios tienen que saber en qué se diferencian las estrategias " -"entre sí." +"luego los usuarios tienen que saber en qué se diferencian las estrategias entre sí." #: src\patterns/behavioural/strategy.md:112 #, fuzzy @@ -5072,71 +4337,51 @@ msgid "" "In the previous example all strategies are implemented in a single file.\n" "Ways of providing different strategies includes:" msgstr "" -"En el ejemplo anterior todas las estrategias se implementan en un solo " -"archivo.\n" +"En el ejemplo anterior todas las estrategias se implementan en un solo archivo.\n" "Las formas de proporcionar diferentes estrategias incluyen:" #: src\patterns/behavioural/strategy.md:115 #, fuzzy msgid "" -"- All in one file (as shown in this example, similar to being separated as " -"modules)\n" -"- Separated as modules, E.g. `formatter::json` module, `formatter::text` " -"module\n" +"- All in one file (as shown in this example, similar to being separated as modules)\n" +"- Separated as modules, E.g. `formatter::json` module, `formatter::text` module\n" "- Use compiler feature flags, E.g. `json` feature, `text` feature\n" "- Separated as crates, E.g. `json` crate, `text` crate" msgstr "" -"- Todo en un archivo (como se muestra en este ejemplo, similar a estar " -"separados como módulos)\n" -"- Separados como módulos, p. módulo `formateador::json`, módulo " -"`formateador::texto`\n" -"- Use indicadores de características del compilador, p. función `json`, " -"función `texto`\n" +"- Todo en un archivo (como se muestra en este ejemplo, similar a estar separados como módulos)\n" +"- Separados como módulos, p. módulo `formateador::json`, módulo `formateador::texto`\n" +"- Use indicadores de características del compilador, p. función `json`, función `texto`\n" "- Separados como cajas, p. caja `json`, caja `texto`" #: src\patterns/behavioural/strategy.md:120 #, fuzzy msgid "" -"Serde crate is a good example of the `Strategy` pattern in action. Serde " -"allows\n" -"[full customization](https://serde.rs/custom-serialization.html) of the " -"serialization\n" -"behavior by manually implementing `Serialize` and `Deserialize` traits for " -"our\n" -"type. For example, we could easily swap `serde_json` with `serde_cbor` since " -"they\n" -"expose similar methods. Having this makes the helper crate `serde_transcode` " -"much\n" +"Serde crate is a good example of the `Strategy` pattern in action. Serde allows\n" +"[full customization](https://serde.rs/custom-serialization.html) of the serialization\n" +"behavior by manually implementing `Serialize` and `Deserialize` traits for our\n" +"type. For example, we could easily swap `serde_json` with `serde_cbor` since they\n" +"expose similar methods. Having this makes the helper crate `serde_transcode` much\n" "more useful and ergonomic." msgstr "" -"Serde crate es un buen ejemplo del patrón 'Estrategia' en acción. Serde " -"permite\n" -"[personalización completa](https://serde.rs/custom-serialization.html) de la " -"serialización\n" -"comportamiento implementando manualmente `Serialize` y `Deserialize` rasgos " -"para nuestro\n" -"tipo. Por ejemplo, podríamos intercambiar fácilmente `serde_json` con " -"`serde_cbor` ya que\n" -"exponer métodos similares. Tener esto hace que el asistente cree " -"`serde_transcode` mucho\n" +"Serde crate es un buen ejemplo del patrón 'Estrategia' en acción. Serde permite\n" +"[personalización completa](https://serde.rs/custom-serialization.html) de la serialización\n" +"comportamiento implementando manualmente `Serialize` y `Deserialize` rasgos para nuestro\n" +"tipo. Por ejemplo, podríamos intercambiar fácilmente `serde_json` con `serde_cbor` ya que\n" +"exponer métodos similares. Tener esto hace que el asistente cree `serde_transcode` mucho\n" "más útil y ergonómico." #: src\patterns/behavioural/strategy.md:127 #, fuzzy -msgid "" -"However, we don't need to use traits in order to design this pattern in Rust." -msgstr "" -"Sin embargo, no necesitamos usar rasgos para diseñar este patrón en Rust." +msgid "However, we don't need to use traits in order to design this pattern in Rust." +msgstr "Sin embargo, no necesitamos usar rasgos para diseñar este patrón en Rust." #: src\patterns/behavioural/strategy.md:129 #, fuzzy msgid "" -"The following toy example demonstrates the idea of the Strategy pattern " -"using Rust\n" +"The following toy example demonstrates the idea of the Strategy pattern using Rust\n" "`closures`:" msgstr "" -"El siguiente ejemplo de juguete demuestra la idea del patrón de estrategia " -"usando Rust\n" +"El siguiente ejemplo de juguete demuestra la idea del patrón de estrategia usando Rust\n" "`cierres`:" #: src\patterns/behavioural/strategy.md:132 @@ -5194,16 +4439,12 @@ msgstr "" #, fuzzy msgid "" "- [Strategy Pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"- [Dependency " -"Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" -"- [Policy Based " -"Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +"- [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Policy Based Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" msgstr "" "- [Patrón de estrategia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"- [Inyección de " -"dependencia](https://en.wikipedia.org/wiki/Dependency_injection)\n" -"- [Diseño basado en políticas] " -"(https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +"- [Inyección de dependencia](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Diseño basado en políticas] (https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" #: src\patterns/behavioural/visitor.md:1 #, fuzzy @@ -5214,8 +4455,7 @@ msgstr "# Visitante" #, fuzzy msgid "" "A visitor encapsulates an algorithm that operates over a heterogeneous\n" -"collection of objects. It allows multiple different algorithms to be " -"written\n" +"collection of objects. It allows multiple different algorithms to be written\n" "over the same data without having to modify the data (or their primary\n" "behaviour)." msgstr "" @@ -5268,8 +4508,7 @@ msgid "" "use visit::*;\n" "use ast::*;\n" "\n" -"// An example concrete implementation - walks the AST interpreting it as " -"code.\n" +"// An example concrete implementation - walks the AST interpreting it as code.\n" "struct Interpreter;\n" "impl Visitor for Interpreter {\n" " fn visit_name(&mut self, n: &Name) -> i64 { panic!() }\n" @@ -5283,10 +4522,8 @@ msgid "" " fn visit_expr(&mut self, e: &Expr) -> i64 {\n" " match *e {\n" " Expr::IntLit(n) => n,\n" -" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + " -"self.visit_expr(rhs),\n" -" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - " -"self.visit_expr(rhs),\n" +" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + self.visit_expr(rhs),\n" +" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - self.visit_expr(rhs),\n" " }\n" " }\n" "}\n" @@ -5296,51 +4533,38 @@ msgstr "" #: src\patterns/behavioural/visitor.md:69 #, fuzzy msgid "" -"One could implement further visitors, for example a type checker, without " -"having\n" +"One could implement further visitors, for example a type checker, without having\n" "to modify the AST data." msgstr "" -"Se podrían implementar más visitantes, por ejemplo, un verificador de tipos, " -"sin tener\n" +"Se podrían implementar más visitantes, por ejemplo, un verificador de tipos, sin tener\n" "para modificar los datos AST." #: src\patterns/behavioural/visitor.md:74 #, fuzzy msgid "" -"The visitor pattern is useful anywhere that you want to apply an algorithm " -"to\n" -"heterogeneous data. If data is homogeneous, you can use an iterator-like " -"pattern.\n" -"Using a visitor object (rather than a functional approach) allows the " -"visitor to\n" +"The visitor pattern is useful anywhere that you want to apply an algorithm to\n" +"heterogeneous data. If data is homogeneous, you can use an iterator-like pattern.\n" +"Using a visitor object (rather than a functional approach) allows the visitor to\n" "be stateful and thus communicate information between nodes." msgstr "" -"El patrón de visitante es útil en cualquier lugar al que desee aplicar un " -"algoritmo\n" -"datos heterogéneos. Si los datos son homogéneos, puede usar un patrón " -"similar a un iterador.\n" -"El uso de un objeto de visitante (en lugar de un enfoque funcional) le " -"permite al visitante\n" +"El patrón de visitante es útil en cualquier lugar al que desee aplicar un algoritmo\n" +"datos heterogéneos. Si los datos son homogéneos, puede usar un patrón similar a un iterador.\n" +"El uso de un objeto de visitante (en lugar de un enfoque funcional) le permite al visitante\n" "tener estado y así comunicar información entre nodos." #: src\patterns/behavioural/visitor.md:81 #, fuzzy msgid "" "It is common for the `visit_*` methods to return void (as opposed to in the\n" -"example). In that case it is possible to factor out the traversal code and " -"share\n" -"it between algorithms (and also to provide noop default methods). In Rust, " -"the\n" +"example). In that case it is possible to factor out the traversal code and share\n" +"it between algorithms (and also to provide noop default methods). In Rust, the\n" "common way to do this is to provide `walk_*` functions for each datum. For\n" "example," msgstr "" "Es común que los métodos `visit_*` devuelvan void (a diferencia del método\n" -"ejemplo). En ese caso, es posible factorizar el código transversal y " -"compartir\n" -"entre algoritmos (y también para proporcionar métodos predeterminados de " -"noop). En óxido, el\n" -"La forma común de hacer esto es proporcionar funciones `walk_*` para cada " -"dato. Para\n" +"ejemplo). En ese caso, es posible factorizar el código transversal y compartir\n" +"entre algoritmos (y también para proporcionar métodos predeterminados de noop). En óxido, el\n" +"La forma común de hacer esto es proporcionar funciones `walk_*` para cada dato. Para\n" "ejemplo," #: src\patterns/behavioural/visitor.md:87 @@ -5365,19 +4589,16 @@ msgstr "" #: src\patterns/behavioural/visitor.md:103 #, fuzzy msgid "" -"In other languages (e.g., Java) it is common for data to have an `accept` " -"method\n" +"In other languages (e.g., Java) it is common for data to have an `accept` method\n" "which performs the same duty." msgstr "" -"En otros lenguajes (por ejemplo, Java) es común que los datos tengan un " -"método `aceptar`\n" +"En otros lenguajes (por ejemplo, Java) es común que los datos tengan un método `aceptar`\n" "que cumple el mismo deber." #: src\patterns/behavioural/visitor.md:108 #, fuzzy msgid "The visitor pattern is a common pattern in most OO languages." -msgstr "" -"El patrón de visitante es un patrón común en la mayoría de los lenguajes OO." +msgstr "El patrón de visitante es un patrón común en la mayoría de los lenguajes OO." #: src\patterns/behavioural/visitor.md:110 #, fuzzy @@ -5387,12 +4608,10 @@ msgstr "[Artículo de Wikipedia](https://en.wikipedia.org/wiki/Visitor_pattern)" #: src\patterns/behavioural/visitor.md:112 #, fuzzy msgid "" -"The [fold](../creational/fold.md) pattern is similar to visitor but " -"produces\n" +"The [fold](../creational/fold.md) pattern is similar to visitor but produces\n" "a new version of the visited data structure." msgstr "" -"El patrón [fold](../creational/fold.md) es similar al visitante pero " -"produce\n" +"El patrón [fold](../creational/fold.md) es similar al visitante pero produce\n" "una nueva versión de la estructura de datos visitada." #: src\patterns/creational/intro.md:1 @@ -5408,22 +4627,15 @@ msgstr "De [Wikipedia](https://en.wikipedia.org/wiki/Creational_pattern):" #: src\patterns/creational/intro.md:5 #, fuzzy msgid "" -"> Design patterns that deal with object creation mechanisms, trying to " -"create objects\n" -"> in a manner suitable to the situation. The basic form of object creation " -"could\n" -"> result in design problems or in added complexity to the design. Creational " -"design\n" +"> Design patterns that deal with object creation mechanisms, trying to create objects\n" +"> in a manner suitable to the situation. The basic form of object creation could\n" +"> result in design problems or in added complexity to the design. Creational design\n" "> patterns solve this problem by somehow controlling this object creation." msgstr "" -"> Patrones de diseño que se ocupan de los mecanismos de creación de objetos, " -"tratando de crear objetos\n" -"> de una manera adecuada a la situación. La forma básica de creación de " -"objetos podría\n" -"> resultar en problemas de diseño o en complejidad adicional al diseño. " -"diseño creacional\n" -"> los patrones resuelven este problema controlando de alguna manera la " -"creación de este objeto." +"> Patrones de diseño que se ocupan de los mecanismos de creación de objetos, tratando de crear objetos\n" +"> de una manera adecuada a la situación. La forma básica de creación de objetos podría\n" +"> resultar en problemas de diseño o en complejidad adicional al diseño. diseño creacional\n" +"> los patrones resuelven este problema controlando de alguna manera la creación de este objeto." #: src\patterns/creational/builder.md:1 #, fuzzy @@ -5466,19 +4678,16 @@ msgid "" " }\n" "\n" " pub fn name(mut self, bar: String) -> FooBuilder {\n" -" // Set the name on the builder itself, and return the builder by " -"value.\n" +" // Set the name on the builder itself, and return the builder by value.\n" " self.bar = bar;\n" " self\n" " }\n" "\n" " // If we can get away with not consuming the Builder here, that is an\n" -" // advantage. It means we can use the FooBuilder as a template for " -"constructing\n" +" // advantage. It means we can use the FooBuilder as a template for constructing\n" " // many Foos.\n" " pub fn build(self) -> Foo {\n" -" // Create a Foo from the FooBuilder, applying all settings in " -"FooBuilder\n" +" // Create a Foo from the FooBuilder, applying all settings in FooBuilder\n" " // to Foo.\n" " Foo { bar: self.bar }\n" " }\n" @@ -5489,8 +4698,7 @@ msgid "" " let foo = Foo {\n" " bar: String::from(\"Y\"),\n" " };\n" -" let foo_from_builder: Foo = " -"FooBuilder::new().name(String::from(\"Y\")).build();\n" +" let foo_from_builder: Foo = FooBuilder::new().name(String::from(\"Y\")).build();\n" " assert_eq!(foo, foo_from_builder);\n" "}\n" "```" @@ -5517,81 +4725,57 @@ msgstr "Evita la proliferación de constructores." #: src\patterns/creational/builder.md:74 #, fuzzy -msgid "" -"Can be used for one-liner initialisation as well as more complex " -"construction." -msgstr "" -"Se puede utilizar para la inicialización de una sola línea, así como para " -"construcciones más complejas." +msgid "Can be used for one-liner initialisation as well as more complex construction." +msgstr "Se puede utilizar para la inicialización de una sola línea, así como para construcciones más complejas." #: src\patterns/creational/builder.md:78 #, fuzzy msgid "" -"More complex than creating a struct object directly, or a simple " -"constructor\n" +"More complex than creating a struct object directly, or a simple constructor\n" "function." msgstr "" -"Más complejo que crear un objeto de estructura directamente o un constructor " -"simple\n" +"Más complejo que crear un objeto de estructura directamente o un constructor simple\n" "función." #: src\patterns/creational/builder.md:83 #, fuzzy msgid "" -"This pattern is seen more frequently in Rust (and for simpler objects) than " -"in\n" -"many other languages because Rust lacks overloading. Since you can only have " -"a\n" -"single method with a given name, having multiple constructors is less nice " -"in\n" +"This pattern is seen more frequently in Rust (and for simpler objects) than in\n" +"many other languages because Rust lacks overloading. Since you can only have a\n" +"single method with a given name, having multiple constructors is less nice in\n" "Rust than in C++, Java, or others." msgstr "" -"Este patrón se ve con más frecuencia en Rust (y para objetos más simples) " -"que en\n" -"muchos otros lenguajes porque Rust carece de sobrecarga. Ya que solo puedes " -"tener un\n" -"método único con un nombre dado, tener múltiples constructores es menos " -"agradable en\n" +"Este patrón se ve con más frecuencia en Rust (y para objetos más simples) que en\n" +"muchos otros lenguajes porque Rust carece de sobrecarga. Ya que solo puedes tener un\n" +"método único con un nombre dado, tener múltiples constructores es menos agradable en\n" "Rust que en C++, Java u otros." #: src\patterns/creational/builder.md:88 #, fuzzy msgid "" -"This pattern is often used where the builder object is useful in its own " -"right,\n" +"This pattern is often used where the builder object is useful in its own right,\n" "rather than being just a builder. For example, see\n" "[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" -"is a builder for " -"[`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" -"(a process). In these cases, the `T` and `TBuilder` naming pattern is not " -"used." +"is a builder for [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(a process). In these cases, the `T` and `TBuilder` naming pattern is not used." msgstr "" -"Este patrón se usa a menudo cuando el objeto constructor es útil por derecho " -"propio,\n" +"Este patrón se usa a menudo cuando el objeto constructor es útil por derecho propio,\n" "en lugar de ser sólo un constructor. Por ejemplo, ver\n" "[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" -"es un constructor para " -"[`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" -"(un proceso). En estos casos, no se utiliza el patrón de nomenclatura `T` y " -"`TBuilder`." +"es un constructor para [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(un proceso). En estos casos, no se utiliza el patrón de nomenclatura `T` y `TBuilder`." #: src\patterns/creational/builder.md:94 #, fuzzy msgid "" -"The example takes and returns the builder by value. It is often more " -"ergonomic\n" -"(and more efficient) to take and return the builder as a mutable reference. " -"The\n" -"borrow checker makes this work naturally. This approach has the advantage " -"that\n" +"The example takes and returns the builder by value. It is often more ergonomic\n" +"(and more efficient) to take and return the builder as a mutable reference. The\n" +"borrow checker makes this work naturally. This approach has the advantage that\n" "one can write code like" msgstr "" -"El ejemplo toma y devuelve el constructor por valor. A menudo es más " -"ergonómico.\n" -"(y más eficiente) para tomar y devolver el constructor como una referencia " -"mutable. El\n" -"El verificador de préstamos hace que esto funcione de forma natural. Este " -"enfoque tiene la ventaja de que\n" +"El ejemplo toma y devuelve el constructor por valor. A menudo es más ergonómico.\n" +"(y más eficiente) para tomar y devolver el constructor como una referencia mutable. El\n" +"El verificador de préstamos hace que esto funcione de forma natural. Este enfoque tiene la ventaja de que\n" "uno puede escribir código como" #: src\patterns/creational/builder.md:99 @@ -5612,29 +4796,23 @@ msgstr "así como el estilo `FooBuilder::new().a().b().build()`." #: src\patterns/creational/builder.md:110 #, fuzzy msgid "" -"- [Description in the style " -"guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" -"- [derive_builder](https://crates.io/crates/derive_builder), a crate for " -"automatically\n" +"- [Description in the style guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/" +"builders.html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), a crate for automatically\n" " implementing this pattern while avoiding the boilerplate.\n" -"- [Constructor pattern](../../idioms/ctor.md) for when construction is " -"simpler.\n" -"- [Builder pattern " -"(wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" -"- [Construction of complex " -"values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder)" -msgstr "" -"- [Descripción en la guía de " -"estilo](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" -"- [derive_builder](https://crates.io/crates/derive_builder), una caja para " -"automáticamente\n" +"- [Constructor pattern](../../idioms/ctor.md) for when construction is simpler.\n" +"- [Builder pattern (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Construction of complex values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety." +"html#c-builder)" +msgstr "" +"- [Descripción en la guía de estilo](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/" +"builders.html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), una caja para automáticamente\n" " implementar este patrón mientras se evita el repetitivo.\n" -"- [Patrón de constructor](../../idioms/ctor.md) para cuando la construcción " -"es más sencilla.\n" -"- [Patrón de constructor " -"(wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" -"- [Construcción de valores " -"complejos](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder)" +"- [Patrón de constructor](../../idioms/ctor.md) para cuando la construcción es más sencilla.\n" +"- [Patrón de constructor (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Construcción de valores complejos](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-" +"safety.html#c-builder)" #: src\patterns/creational/fold.md:1 #, fuzzy @@ -5644,27 +4822,22 @@ msgstr "# Doblar" #: src\patterns/creational/fold.md:5 #, fuzzy msgid "" -"Run an algorithm over each item in a collection of data to create a new " -"item,\n" +"Run an algorithm over each item in a collection of data to create a new item,\n" "thus creating a whole new collection." msgstr "" -"Ejecute un algoritmo sobre cada elemento en una colección de datos para " -"crear un nuevo elemento,\n" +"Ejecute un algoritmo sobre cada elemento en una colección de datos para crear un nuevo elemento,\n" "creando así una colección completamente nueva." #: src\patterns/creational/fold.md:8 #, fuzzy msgid "" "The etymology here is unclear to me. The terms 'fold' and 'folder' are used\n" -"in the Rust compiler, although it appears to me to be more like a map than " -"a\n" +"in the Rust compiler, although it appears to me to be more like a map than a\n" "fold in the usual sense. See the discussion below for more details." msgstr "" -"La etimología aquí no está clara para mí. Los términos 'doblar' y 'carpeta' " -"se utilizan\n" +"La etimología aquí no está clara para mí. Los términos 'doblar' y 'carpeta' se utilizan\n" "en el compilador de Rust, aunque me parece más un mapa que un\n" -"doblar en el sentido habitual. Consulte la discusión a continuación para " -"obtener más detalles." +"doblar en el sentido habitual. Consulte la discusión a continuación para obtener más detalles." #: src\patterns/creational/fold.md:14 msgid "" @@ -5692,16 +4865,14 @@ msgid "" " use ast::*;\n" "\n" " pub trait Folder {\n" -" // A leaf node just returns the node itself. In some cases, we can " -"do this\n" +" // A leaf node just returns the node itself. In some cases, we can do this\n" " // to inner nodes too.\n" " fn fold_name(&mut self, n: Box) -> Box { n }\n" " // Create a new inner node by folding its children.\n" " fn fold_stmt(&mut self, s: Box) -> Box {\n" " match *s {\n" " Stmt::Expr(e) => Box::new(Stmt::Expr(self.fold_expr(e))),\n" -" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), " -"self.fold_expr(e))),\n" +" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), self.fold_expr(e))),\n" " }\n" " }\n" " fn fold_expr(&mut self, e: Box) -> Box { ... }\n" @@ -5725,120 +4896,89 @@ msgstr "" #: src\patterns/creational/fold.md:65 #, fuzzy msgid "" -"The result of running the `Renamer` on an AST is a new AST identical to the " -"old\n" -"one, but with every name changed to `foo`. A real life folder might have " -"some\n" +"The result of running the `Renamer` on an AST is a new AST identical to the old\n" +"one, but with every name changed to `foo`. A real life folder might have some\n" "state preserved between nodes in the struct itself." msgstr "" -"El resultado de ejecutar `Renamer` en un AST es un nuevo AST idéntico al " -"antiguo\n" -"one, pero con todos los nombres cambiados a `foo`. Una carpeta de la vida " -"real podría tener algunos\n" +"El resultado de ejecutar `Renamer` en un AST es un nuevo AST idéntico al antiguo\n" +"one, pero con todos los nombres cambiados a `foo`. Una carpeta de la vida real podría tener algunos\n" "estado preservado entre nodos en la estructura misma." #: src\patterns/creational/fold.md:69 #, fuzzy msgid "" "A folder can also be defined to map one data structure to a different (but\n" -"usually similar) data structure. For example, we could fold an AST into a " -"HIR\n" +"usually similar) data structure. For example, we could fold an AST into a HIR\n" "tree (HIR stands for high-level intermediate representation)." msgstr "" -"También se puede definir una carpeta para asignar una estructura de datos a " -"otra diferente (pero\n" -"generalmente similar) estructura de datos. Por ejemplo, podríamos convertir " -"un AST en un HIR\n" +"También se puede definir una carpeta para asignar una estructura de datos a otra diferente (pero\n" +"generalmente similar) estructura de datos. Por ejemplo, podríamos convertir un AST en un HIR\n" "árbol (HIR significa representación intermedia de alto nivel)." #: src\patterns/creational/fold.md:75 #, fuzzy msgid "" -"It is common to want to map a data structure by performing some operation " -"on\n" -"each node in the structure. For simple operations on simple data " -"structures,\n" -"this can be done using `Iterator::map`. For more complex operations, " -"perhaps\n" -"where earlier nodes can affect the operation on later nodes, or where " -"iteration\n" +"It is common to want to map a data structure by performing some operation on\n" +"each node in the structure. For simple operations on simple data structures,\n" +"this can be done using `Iterator::map`. For more complex operations, perhaps\n" +"where earlier nodes can affect the operation on later nodes, or where iteration\n" "over the data structure is non-trivial, using the fold pattern is more\n" "appropriate." msgstr "" -"Es común querer mapear una estructura de datos realizando alguna operación " -"en\n" -"cada nodo de la estructura. Para operaciones simples en estructuras de datos " -"simples,\n" -"esto se puede hacer usando `Iterator::map`. Para operaciones más complejas, " -"tal vez\n" -"donde los nodos anteriores pueden afectar la operación en nodos posteriores, " -"o donde la iteración\n" -"sobre la estructura de datos no es trivial, usar el patrón de plegado es " -"más\n" +"Es común querer mapear una estructura de datos realizando alguna operación en\n" +"cada nodo de la estructura. Para operaciones simples en estructuras de datos simples,\n" +"esto se puede hacer usando `Iterator::map`. Para operaciones más complejas, tal vez\n" +"donde los nodos anteriores pueden afectar la operación en nodos posteriores, o donde la iteración\n" +"sobre la estructura de datos no es trivial, usar el patrón de plegado es más\n" "adecuado." #: src\patterns/creational/fold.md:82 #, fuzzy msgid "" -"Like the visitor pattern, the fold pattern allows us to separate traversal " -"of a\n" +"Like the visitor pattern, the fold pattern allows us to separate traversal of a\n" "data structure from the operations performed to each node." msgstr "" -"Al igual que el patrón de visitante, el patrón de plegado nos permite " -"separar el recorrido de un\n" +"Al igual que el patrón de visitante, el patrón de plegado nos permite separar el recorrido de un\n" "estructura de datos de las operaciones realizadas a cada nodo." #: src\patterns/creational/fold.md:87 #, fuzzy msgid "" -"Mapping data structures in this fashion is common in functional languages. " -"In OO\n" -"languages, it would be more common to mutate the data structure in place. " -"The\n" +"Mapping data structures in this fashion is common in functional languages. In OO\n" +"languages, it would be more common to mutate the data structure in place. The\n" "'functional' approach is common in Rust, mostly due to the preference for\n" -"immutability. Using fresh data structures, rather than mutating old ones, " -"makes\n" +"immutability. Using fresh data structures, rather than mutating old ones, makes\n" "reasoning about the code easier in most circumstances." msgstr "" -"Mapear estructuras de datos de esta manera es común en lenguajes " -"funcionales. en OO\n" +"Mapear estructuras de datos de esta manera es común en lenguajes funcionales. en OO\n" "idiomas, sería más común mutar la estructura de datos en su lugar. El\n" -"El enfoque 'funcional' es común en Rust, principalmente debido a la " -"preferencia por\n" -"inmutabilidad. El uso de estructuras de datos nuevas, en lugar de mutar las " -"antiguas, hace\n" +"El enfoque 'funcional' es común en Rust, principalmente debido a la preferencia por\n" +"inmutabilidad. El uso de estructuras de datos nuevas, en lugar de mutar las antiguas, hace\n" "razonar sobre el código es más fácil en la mayoría de las circunstancias." #: src\patterns/creational/fold.md:93 #, fuzzy msgid "" -"The trade-off between efficiency and reusability can be tweaked by changing " -"how\n" +"The trade-off between efficiency and reusability can be tweaked by changing how\n" "nodes are accepted by the `fold_*` methods." msgstr "" -"La compensación entre la eficiencia y la reutilización se puede ajustar " -"cambiando cómo\n" +"La compensación entre la eficiencia y la reutilización se puede ajustar cambiando cómo\n" "los nodos son aceptados por los métodos `fold_*`." #: src\patterns/creational/fold.md:96 #, fuzzy msgid "" -"In the above example we operate on `Box` pointers. Since these own their " -"data\n" -"exclusively, the original copy of the data structure cannot be re-used. On " -"the\n" +"In the above example we operate on `Box` pointers. Since these own their data\n" +"exclusively, the original copy of the data structure cannot be re-used. On the\n" "other hand if a node is not changed, reusing it is very efficient." msgstr "" -"En el ejemplo anterior, operamos con punteros `Box`. Ya que estos son dueños " -"de sus datos\n" -"exclusivamente, la copia original de la estructura de datos no puede ser " -"reutilizada. Sobre el\n" +"En el ejemplo anterior, operamos con punteros `Box`. Ya que estos son dueños de sus datos\n" +"exclusivamente, la copia original de la estructura de datos no puede ser reutilizada. Sobre el\n" "Por otro lado, si un nodo no se cambia, reutilizarlo es muy eficiente." #: src\patterns/creational/fold.md:100 msgid "" -"If we were to operate on borrowed references, the original data structure " -"can be\n" +"If we were to operate on borrowed references, the original data structure can be\n" "reused; however, a node must be cloned even if unchanged, which can be\n" "expensive." msgstr "" @@ -5846,66 +4986,49 @@ msgstr "" #: src\patterns/creational/fold.md:104 #, fuzzy msgid "" -"Using a reference counted pointer gives the best of both worlds - we can " -"reuse\n" -"the original data structure, and we don't need to clone unchanged nodes. " -"However,\n" +"Using a reference counted pointer gives the best of both worlds - we can reuse\n" +"the original data structure, and we don't need to clone unchanged nodes. However,\n" "they are less ergonomic to use and mean that the data structures cannot be\n" "mutable." msgstr "" -"El uso de un puntero contado de referencia ofrece lo mejor de ambos mundos: " -"podemos reutilizar\n" -"la estructura de datos original, y no necesitamos clonar nodos sin cambios. " -"Sin embargo,\n" -"son menos ergonómicos de usar y significan que las estructuras de datos no " -"pueden ser\n" +"El uso de un puntero contado de referencia ofrece lo mejor de ambos mundos: podemos reutilizar\n" +"la estructura de datos original, y no necesitamos clonar nodos sin cambios. Sin embargo,\n" +"son menos ergonómicos de usar y significan que las estructuras de datos no pueden ser\n" "mudable." #: src\patterns/creational/fold.md:111 #, fuzzy msgid "" "Iterators have a `fold` method, however this folds a data structure into a\n" -"value, rather than into a new data structure. An iterator's `map` is more " -"like\n" +"value, rather than into a new data structure. An iterator's `map` is more like\n" "this fold pattern." msgstr "" -"Los iteradores tienen un método `doblar`, sin embargo, este dobla una " -"estructura de datos en una\n" -"valor, en lugar de en una nueva estructura de datos. El `mapa` de un " -"iterador es más como\n" +"Los iteradores tienen un método `doblar`, sin embargo, este dobla una estructura de datos en una\n" +"valor, en lugar de en una nueva estructura de datos. El `mapa` de un iterador es más como\n" "este patrón de plegado." #: src\patterns/creational/fold.md:115 #, fuzzy msgid "" "In other languages, fold is usually used in the sense of Rust's iterators,\n" -"rather than this pattern. Some functional languages have powerful constructs " -"for\n" +"rather than this pattern. Some functional languages have powerful constructs for\n" "performing flexible maps over data structures." msgstr "" -"En otros lenguajes, fold se usa generalmente en el sentido de los iteradores " -"de Rust,\n" -"en lugar de este patrón. Algunos lenguajes funcionales tienen poderosas " -"construcciones para\n" +"En otros lenguajes, fold se usa generalmente en el sentido de los iteradores de Rust,\n" +"en lugar de este patrón. Algunos lenguajes funcionales tienen poderosas construcciones para\n" "realizar mapas flexibles sobre estructuras de datos." #: src\patterns/creational/fold.md:119 #, fuzzy msgid "" -"The [visitor](../behavioural/visitor.md) pattern is closely related to " -"fold.\n" -"They share the concept of walking a data structure performing an operation " -"on\n" -"each node. However, the visitor does not create a new data structure nor " -"consume\n" +"The [visitor](../behavioural/visitor.md) pattern is closely related to fold.\n" +"They share the concept of walking a data structure performing an operation on\n" +"each node. However, the visitor does not create a new data structure nor consume\n" "the old one." msgstr "" -"El patrón [visitante](../behavioural/visitor.md) está estrechamente " -"relacionado con el pliegue.\n" -"Comparten el concepto de recorrer una estructura de datos realizando una " -"operación sobre\n" -"cada nodo. Sin embargo, el visitante no crea una nueva estructura de datos " -"ni consume\n" +"El patrón [visitante](../behavioural/visitor.md) está estrechamente relacionado con el pliegue.\n" +"Comparten el concepto de recorrer una estructura de datos realizando una operación sobre\n" +"cada nodo. Sin embargo, el visitante no crea una nueva estructura de datos ni consume\n" "el viejo." #: src\patterns/structural/intro.md:1 @@ -5921,12 +5044,10 @@ msgstr "De [Wikipedia](https://en.wikipedia.org/wiki/Structural_pattern):" #: src\patterns/structural/intro.md:5 #, fuzzy msgid "" -"> Design patterns that ease the design by identifying a simple way to " -"realize relationships\n" +"> Design patterns that ease the design by identifying a simple way to realize relationships\n" "> among entities." msgstr "" -"> Patrones de diseño que facilitan el diseño al identificar una forma " -"sencilla de realizar relaciones\n" +"> Patrones de diseño que facilitan el diseño al identificar una forma sencilla de realizar relaciones\n" "> entre entidades." #: src\patterns/structural/compose-structs.md:1 @@ -5942,26 +5063,18 @@ msgstr "TODO - este no es un nombre muy ágil" #: src\patterns/structural/compose-structs.md:7 #, fuzzy msgid "" -"Sometimes a large struct will cause issues with the borrow checker - " -"although\n" -"fields can be borrowed independently, sometimes the whole struct ends up " -"being\n" -"used at once, preventing other uses. A solution might be to decompose the " -"struct\n" +"Sometimes a large struct will cause issues with the borrow checker - although\n" +"fields can be borrowed independently, sometimes the whole struct ends up being\n" +"used at once, preventing other uses. A solution might be to decompose the struct\n" "into several smaller structs. Then compose these together into the original\n" "struct. Then each struct can be borrowed separately and have more flexible\n" "behaviour." msgstr "" -"A veces, una estructura grande causará problemas con el verificador de " -"préstamos, aunque\n" -"los campos se pueden tomar prestados de forma independiente, a veces toda la " -"estructura termina siendo\n" -"utilizados de una sola vez, impidiendo otros usos. Una solución podría ser " -"descomponer la estructura\n" -"en varias estructuras más pequeñas. Luego componga estos juntos en el " -"original\n" -"estructura Luego, cada estructura se puede tomar prestada por separado y " -"tener más flexibilidad\n" +"A veces, una estructura grande causará problemas con el verificador de préstamos, aunque\n" +"los campos se pueden tomar prestados de forma independiente, a veces toda la estructura termina siendo\n" +"utilizados de una sola vez, impidiendo otros usos. Una solución podría ser descomponer la estructura\n" +"en varias estructuras más pequeñas. Luego componga estos juntos en el original\n" +"estructura Luego, cada estructura se puede tomar prestada por separado y tener más flexibilidad\n" "comportamiento." #: src\patterns/structural/compose-structs.md:14 @@ -5970,19 +5083,16 @@ msgid "" "This will often lead to a better design in other ways: applying this design\n" "pattern often reveals smaller units of functionality." msgstr "" -"Esto a menudo conducirá a un mejor diseño de otras maneras: aplicar este " -"diseño\n" +"Esto a menudo conducirá a un mejor diseño de otras maneras: aplicar este diseño\n" "patrón a menudo revela unidades más pequeñas de funcionalidad." #: src\patterns/structural/compose-structs.md:19 #, fuzzy msgid "" -"Here is a contrived example of where the borrow checker foils us in our plan " -"to\n" +"Here is a contrived example of where the borrow checker foils us in our plan to\n" "use a struct:" msgstr "" -"Aquí hay un ejemplo artificial de dónde el verificador de préstamos nos " -"frustra en nuestro plan para\n" +"Aquí hay un ejemplo artificial de dónde el verificador de préstamos nos frustra en nuestro plan para\n" "usar una estructura:" #: src\patterns/structural/compose-structs.md:22 @@ -5998,12 +5108,10 @@ msgid "" "fn bar(a: &mut A) -> u32 { a.f1 + a.f3 }\n" "\n" "fn baz(a: &mut A) {\n" -" // The later usage of x causes a to be borrowed for the rest of the " -"function.\n" +" // The later usage of x causes a to be borrowed for the rest of the function.\n" " let x = foo(a);\n" " // Borrow checker error:\n" -" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than " -"once\n" +" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than once\n" " // at a time\n" " println!(\"{}\", x);\n" "}\n" @@ -6013,12 +5121,10 @@ msgstr "" #: src\patterns/structural/compose-structs.md:42 #, fuzzy msgid "" -"We can apply this design pattern and refactor `A` into two smaller structs, " -"thus\n" +"We can apply this design pattern and refactor `A` into two smaller structs, thus\n" "solving the borrow checking issue:" msgstr "" -"Podemos aplicar este patrón de diseño y refactorizar `A` en dos estructuras " -"más pequeñas, por lo tanto\n" +"Podemos aplicar este patrón de diseño y refactorizar `A` en dos estructuras más pequeñas, por lo tanto\n" "resolviendo el problema de verificación de préstamo:" #: src\patterns/structural/compose-structs.md:45 @@ -6073,52 +5179,38 @@ msgstr "Conduce a un código más detallado." #: src\patterns/structural/compose-structs.md:85 #, fuzzy msgid "" -"Sometimes, the smaller structs are not good abstractions, and so we end up " -"with\n" -"a worse design. That is probably a 'code smell', indicating that the " -"program\n" +"Sometimes, the smaller structs are not good abstractions, and so we end up with\n" +"a worse design. That is probably a 'code smell', indicating that the program\n" "should be refactored in some way." msgstr "" -"A veces, las estructuras más pequeñas no son buenas abstracciones, por lo " -"que terminamos con\n" -"un diseño peor. Eso es probablemente un 'olor a código', lo que indica que " -"el programa\n" +"A veces, las estructuras más pequeñas no son buenas abstracciones, por lo que terminamos con\n" +"un diseño peor. Eso es probablemente un 'olor a código', lo que indica que el programa\n" "debe ser refactorizado de alguna manera." #: src\patterns/structural/compose-structs.md:91 #, fuzzy msgid "" -"This pattern is not required in languages that don't have a borrow checker, " -"so\n" -"in that sense is unique to Rust. However, making smaller units of " -"functionality\n" +"This pattern is not required in languages that don't have a borrow checker, so\n" +"in that sense is unique to Rust. However, making smaller units of functionality\n" "often leads to cleaner code: a widely acknowledged principle of software\n" "engineering, independent of the language." msgstr "" -"Este patrón no es necesario en los idiomas que no tienen un verificador de " -"préstamos, por lo que\n" -"en ese sentido es exclusivo de Rust. Sin embargo, hacer unidades más " -"pequeñas de funcionalidad\n" -"a menudo conduce a un código más limpio: un principio de software " -"ampliamente reconocido\n" +"Este patrón no es necesario en los idiomas que no tienen un verificador de préstamos, por lo que\n" +"en ese sentido es exclusivo de Rust. Sin embargo, hacer unidades más pequeñas de funcionalidad\n" +"a menudo conduce a un código más limpio: un principio de software ampliamente reconocido\n" "ingeniería, independiente del idioma." #: src\patterns/structural/compose-structs.md:96 #, fuzzy msgid "" "This pattern relies on Rust's borrow checker to be able to borrow fields\n" -"independently of each other. In the example, the borrow checker knows that " -"`a.b`\n" -"and `a.c` are distinct and can be borrowed independently, it does not try " -"to\n" +"independently of each other. In the example, the borrow checker knows that `a.b`\n" +"and `a.c` are distinct and can be borrowed independently, it does not try to\n" "borrow all of `a`, which would make this pattern useless." msgstr "" -"Este patrón se basa en el verificador de préstamos de Rust para poder tomar " -"prestados campos.\n" -"independientemente unos de otros. En el ejemplo, el verificador de préstamos " -"sabe que `a.b`\n" -"y `a.c` son distintos y se pueden tomar prestados de forma independiente, no " -"intenta\n" +"Este patrón se basa en el verificador de préstamos de Rust para poder tomar prestados campos.\n" +"independientemente unos de otros. En el ejemplo, el verificador de préstamos sabe que `a.b`\n" +"y `a.c` son distintos y se pueden tomar prestados de forma independiente, no intenta\n" "toma prestada toda `a`, lo que haría que este patrón fuera inútil." #: src\patterns/structural/small-crates.md:1 @@ -6134,121 +5226,89 @@ msgstr "Prefiere cajas pequeñas que hacen una sola cosa bien." #: src\patterns/structural/small-crates.md:7 #, fuzzy msgid "" -"Cargo and crates.io make it easy to add third-party libraries, much more so " -"than\n" -"in say C or C++. Moreover, since packages on crates.io cannot be edited or " -"removed\n" -"after publication, any build that works now should continue to work in the " -"future.\n" -"We should take advantage of this tooling, and use smaller, more fine-grained " -"dependencies." -msgstr "" -"Cargo y crates.io facilitan la adición de bibliotecas de terceros, mucho más " -"que\n" -"en decir C o C++. Además, dado que los paquetes en crates.io no se pueden " -"editar ni eliminar\n" -"después de la publicación, cualquier compilación que funcione ahora debería " -"continuar funcionando en el futuro.\n" -"Deberíamos aprovechar esta herramienta y usar dependencias más pequeñas y " -"detalladas." +"Cargo and crates.io make it easy to add third-party libraries, much more so than\n" +"in say C or C++. Moreover, since packages on crates.io cannot be edited or removed\n" +"after publication, any build that works now should continue to work in the future.\n" +"We should take advantage of this tooling, and use smaller, more fine-grained dependencies." +msgstr "" +"Cargo y crates.io facilitan la adición de bibliotecas de terceros, mucho más que\n" +"en decir C o C++. Además, dado que los paquetes en crates.io no se pueden editar ni eliminar\n" +"después de la publicación, cualquier compilación que funcione ahora debería continuar funcionando en el futuro.\n" +"Deberíamos aprovechar esta herramienta y usar dependencias más pequeñas y detalladas." #: src\patterns/structural/small-crates.md:14 #, fuzzy msgid "" "- Small crates are easier to understand, and encourage more modular code.\n" "- Crates allow for re-using code between projects.\n" -" For example, the `url` crate was developed as part of the Servo browser " -"engine,\n" +" For example, the `url` crate was developed as part of the Servo browser engine,\n" " but has since found wide use outside the project.\n" "- Since the compilation unit\n" -" of Rust is the crate, splitting a project into multiple crates can allow " -"more of\n" +" of Rust is the crate, splitting a project into multiple crates can allow more of\n" " the code to be built in parallel." msgstr "" -"- Las cajas pequeñas son más fáciles de entender y fomentan un código más " -"modular.\n" +"- Las cajas pequeñas son más fáciles de entender y fomentan un código más modular.\n" "- Las cajas permiten reutilizar código entre proyectos.\n" -" Por ejemplo, la caja `url` se desarrolló como parte del motor del " -"navegador Servo,\n" +" Por ejemplo, la caja `url` se desarrolló como parte del motor del navegador Servo,\n" " pero desde entonces ha encontrado un amplio uso fuera del proyecto.\n" "- Desde la unidad de compilación\n" -" de Rust es la caja, dividir un proyecto en varias cajas puede permitir más " -"de\n" +" de Rust es la caja, dividir un proyecto en varias cajas puede permitir más de\n" " el código que se construirá en paralelo." #: src\patterns/structural/small-crates.md:24 #, fuzzy msgid "" -"- This can lead to \"dependency hell\", when a project depends on multiple " -"conflicting\n" -" versions of a crate at the same time. For example, the `url` crate has " -"both versions\n" -" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` " -"are\n" -" different types, an HTTP client that uses `url:0.5` would not accept `Url` " -"values\n" +"- This can lead to \"dependency hell\", when a project depends on multiple conflicting\n" +" versions of a crate at the same time. For example, the `url` crate has both versions\n" +" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` are\n" +" different types, an HTTP client that uses `url:0.5` would not accept `Url` values\n" " from a web scraper that uses `url:1.0`.\n" -"- Packages on crates.io are not curated. A crate may be poorly written, " -"have\n" +"- Packages on crates.io are not curated. A crate may be poorly written, have\n" " unhelpful documentation, or be outright malicious.\n" -"- Two small crates may be less optimized than one large one, since the " -"compiler\n" +"- Two small crates may be less optimized than one large one, since the compiler\n" " does not perform link-time optimization (LTO) by default." msgstr "" -"- Esto puede conducir al \"infierno de la dependencia\", cuando un proyecto " -"depende de múltiples conflictos\n" -" versiones de una caja al mismo tiempo. Por ejemplo, la caja `url` tiene " -"ambas versiones\n" +"- Esto puede conducir al \"infierno de la dependencia\", cuando un proyecto depende de múltiples conflictos\n" +" versiones de una caja al mismo tiempo. Por ejemplo, la caja `url` tiene ambas versiones\n" " 1.0 y 0.5. Dado que la `Url` de `url:1.0` y la `Url` de `url:0.5` son\n" -" diferentes tipos, un cliente HTTP que usa `url:0.5` no aceptaría valores " -"`Url`\n" +" diferentes tipos, un cliente HTTP que usa `url:0.5` no aceptaría valores `Url`\n" " de un web scraper que usa `url:1.0`.\n" -"- Los paquetes en crates.io no están curados. Una caja puede estar mal " -"escrita, tener\n" +"- Los paquetes en crates.io no están curados. Una caja puede estar mal escrita, tener\n" " documentación poco útil, o ser totalmente malicioso.\n" -"- Dos cajas pequeñas pueden estar menos optimizadas que una grande, ya que " -"el compilador\n" -" no realiza la optimización del tiempo de enlace (LTO) de forma " -"predeterminada." +"- Dos cajas pequeñas pueden estar menos optimizadas que una grande, ya que el compilador\n" +" no realiza la optimización del tiempo de enlace (LTO) de forma predeterminada." #: src\patterns/structural/small-crates.md:36 #, fuzzy msgid "" -"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides " -"functions\n" +"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" "for converting `&T` to `&[T]`." msgstr "" -"El cajón [`ref_slice`](https://crates.io/crates/ref_slice) proporciona " -"funciones\n" +"El cajón [`ref_slice`](https://crates.io/crates/ref_slice) proporciona funciones\n" "para convertir `&T` a `&[T]`." #: src\patterns/structural/small-crates.md:39 #, fuzzy msgid "" -"The [`url`](https://crates.io/crates/url) crate provides tools for working " -"with\n" +"The [`url`](https://crates.io/crates/url) crate provides tools for working with\n" "URLs." msgstr "" -"El cajón [`url`](https://crates.io/crates/url) proporciona herramientas para " -"trabajar con\n" +"El cajón [`url`](https://crates.io/crates/url) proporciona herramientas para trabajar con\n" "URL." #: src\patterns/structural/small-crates.md:42 #, fuzzy msgid "" -"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a " -"function to\n" +"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a function to\n" "query the number of CPUs on a machine." msgstr "" -"El cajón [`num_cpus`](https://crates.io/crates/num_cpus) proporciona una " -"función para\n" +"El cajón [`num_cpus`](https://crates.io/crates/num_cpus) proporciona una función para\n" "consultar el número de CPU en una máquina." #: src\patterns/structural/small-crates.md:47 #, fuzzy msgid "- [crates.io: The Rust community crate host](https://crates.io/)" -msgstr "" -"- [crates.io: El host de cajas de la comunidad de Rust](https://crates.io/)" +msgstr "- [crates.io: El host de cajas de la comunidad de Rust](https://crates.io/)" #: src\patterns/structural/unsafe-mods.md:1 #, fuzzy @@ -6258,39 +5318,27 @@ msgstr "# Contener la inseguridad en pequeños módulos" #: src\patterns/structural/unsafe-mods.md:5 #, fuzzy msgid "" -"If you have `unsafe` code, create the smallest possible module that can " -"uphold\n" -"the needed invariants to build a minimal safe interface upon the unsafety. " -"Embed\n" -"this into a larger module that contains only safe code and presents an " -"ergonomic\n" -"interface. Note that the outer module can contain unsafe functions and " -"methods\n" -"that call directly into the unsafe code. Users may use this to gain speed " -"benefits." -msgstr "" -"Si tiene un código \"inseguro\", cree el módulo más pequeño posible que " -"pueda mantener\n" -"las invariantes necesarias para construir una interfaz segura mínima sobre " -"la inseguridad. Empotrar\n" -"esto en un módulo más grande que contiene solo código seguro y presenta un " -"diseño ergonómico\n" -"interfaz. Tenga en cuenta que el módulo externo puede contener funciones y " -"métodos no seguros\n" -"que llaman directamente al código no seguro. Los usuarios pueden usar esto " -"para obtener beneficios de velocidad." +"If you have `unsafe` code, create the smallest possible module that can uphold\n" +"the needed invariants to build a minimal safe interface upon the unsafety. Embed\n" +"this into a larger module that contains only safe code and presents an ergonomic\n" +"interface. Note that the outer module can contain unsafe functions and methods\n" +"that call directly into the unsafe code. Users may use this to gain speed benefits." +msgstr "" +"Si tiene un código \"inseguro\", cree el módulo más pequeño posible que pueda mantener\n" +"las invariantes necesarias para construir una interfaz segura mínima sobre la inseguridad. Empotrar\n" +"esto en un módulo más grande que contiene solo código seguro y presenta un diseño ergonómico\n" +"interfaz. Tenga en cuenta que el módulo externo puede contener funciones y métodos no seguros\n" +"que llaman directamente al código no seguro. Los usuarios pueden usar esto para obtener beneficios de velocidad." #: src\patterns/structural/unsafe-mods.md:13 #, fuzzy msgid "" "- This restricts the unsafe code that must be audited\n" -"- Writing the outer module is much easier, since you can count on the " -"guarantees\n" +"- Writing the outer module is much easier, since you can count on the guarantees\n" " of the inner module" msgstr "" "- Esto restringe el código inseguro que debe ser auditado\n" -"- Escribir el módulo exterior es mucho más fácil, ya que puedes contar con " -"las garantías\n" +"- Escribir el módulo exterior es mucho más fácil, ya que puedes contar con las garantías\n" " del módulo interior" #: src\patterns/structural/unsafe-mods.md:19 @@ -6305,39 +5353,26 @@ msgstr "" #: src\patterns/structural/unsafe-mods.md:24 #, fuzzy msgid "" -"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe " -"operations\n" +"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe operations\n" " in submodules, presenting a safe interface to users.\n" -"- `std`'s `String` class is a wrapper over `Vec` with the added " -"invariant\n" -" that the contents must be valid UTF-8. The operations on `String` ensure " -"this\n" +"- `std`'s `String` class is a wrapper over `Vec` with the added invariant\n" +" that the contents must be valid UTF-8. The operations on `String` ensure this\n" " behavior.\n" -" However, users have the option of using an `unsafe` method to create a " -"`String`,\n" -" in which case the onus is on them to guarantee the validity of the " -"contents." +" However, users have the option of using an `unsafe` method to create a `String`,\n" +" in which case the onus is on them to guarantee the validity of the contents." msgstr "" -"- La caja [`toolshed`](https://docs.rs/toolshed) contiene sus operaciones " -"inseguras\n" +"- La caja [`toolshed`](https://docs.rs/toolshed) contiene sus operaciones inseguras\n" " en submódulos, presentando una interfaz segura para los usuarios.\n" -"- La clase `String` de `std` es un contenedor sobre `Vec` con el " -"invariante agregado\n" -" que el contenido debe ser UTF-8 válido. Las operaciones en `String` " -"aseguran esto\n" +"- La clase `String` de `std` es un contenedor sobre `Vec` con el invariante agregado\n" +" que el contenido debe ser UTF-8 válido. Las operaciones en `String` aseguran esto\n" " comportamiento.\n" -" Sin embargo, los usuarios tienen la opción de usar un método \"no seguro\" " -"para crear una \"Cadena\",\n" +" Sin embargo, los usuarios tienen la opción de usar un método \"no seguro\" para crear una \"Cadena\",\n" " en cuyo caso corresponde a ellos garantizar la vigencia de los contenidos." #: src\patterns/structural/unsafe-mods.md:34 #, fuzzy -msgid "" -"- [Ralf Jung's Blog about invariants in unsafe " -"code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" -msgstr "" -"- [Blog de Ralf Jung sobre invariantes en código no " -"seguro](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgid "- [Ralf Jung's Blog about invariants in unsafe code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgstr "- [Blog de Ralf Jung sobre invariantes en código no seguro](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" #: src\patterns/ffi/intro.md:1 #, fuzzy @@ -6348,38 +5383,31 @@ msgstr "# Patrones FFI" #, fuzzy msgid "" "Writing FFI code is an entire course in itself.\n" -"However, there are several idioms here that can act as pointers, and avoid " -"traps\n" +"However, there are several idioms here that can act as pointers, and avoid traps\n" "for inexperienced users of unsafe Rust." msgstr "" "Escribir código FFI es un curso completo en sí mismo.\n" -"Sin embargo, aquí hay varios modismos que pueden actuar como indicadores y " -"evitar trampas.\n" +"Sin embargo, aquí hay varios modismos que pueden actuar como indicadores y evitar trampas.\n" "para usuarios inexpertos de Rust inseguro." #: src\patterns/ffi/intro.md:7 #, fuzzy msgid "This section contains design patterns that may be useful when doing FFI." -msgstr "" -"Esta sección contiene patrones de diseño que pueden ser útiles al hacer FFI." +msgstr "Esta sección contiene patrones de diseño que pueden ser útiles al hacer FFI." #: src\patterns/ffi/intro.md:9 #, fuzzy msgid "" -"1. [Object-Based API](./export.md) design that has good memory safety " -"characteristics,\n" +"1. [Object-Based API](./export.md) design that has good memory safety characteristics,\n" " and a clean boundary of what is safe and what is unsafe\n" "\n" -"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust " -"types\n" +"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust types\n" " together into an opaque \"object\"" msgstr "" -"1. Diseño de [API basada en objetos] (./export.md) que tiene buenas " -"características de seguridad de memoria,\n" +"1. Diseño de [API basada en objetos] (./export.md) que tiene buenas características de seguridad de memoria,\n" " y un límite limpio de lo que es seguro y lo que es inseguro\n" "\n" -"2. [Consolidación de tipos en envoltorios] (./wrappers.md) - agrupa varios " -"tipos de Rust\n" +"2. [Consolidación de tipos en envoltorios] (./wrappers.md) - agrupa varios tipos de Rust\n" " juntos en un \"objeto\" opaco" #: src\patterns/ffi/export.md:1 @@ -6390,147 +5418,113 @@ msgstr "# API basadas en objetos" #: src\patterns/ffi/export.md:5 #, fuzzy msgid "" -"When designing APIs in Rust which are exposed to other languages, there are " -"some\n" +"When designing APIs in Rust which are exposed to other languages, there are some\n" "important design principles which are contrary to normal Rust API design:" msgstr "" "Al diseñar API en Rust que están expuestas a otros lenguajes, hay algunos\n" -"principios de diseño importantes que son contrarios al diseño normal de la " -"API de Rust:" +"principios de diseño importantes que son contrarios al diseño normal de la API de Rust:" #: src\patterns/ffi/export.md:8 #, fuzzy msgid "" "1. All Encapsulated types should be _owned_ by Rust, _managed_ by the user,\n" " and _opaque_.\n" -"2. All Transactional data types should be _owned_ by the user, and " -"_transparent_.\n" +"2. All Transactional data types should be _owned_ by the user, and _transparent_.\n" "3. All library behavior should be functions acting upon Encapsulated types.\n" -"4. All library behavior should be encapsulated into types not based on " -"structure,\n" +"4. All library behavior should be encapsulated into types not based on structure,\n" " but _provenance/lifetime_." msgstr "" -"1. Todos los tipos encapsulados deben ser _propiedad_ de Rust, " -"_administrados_ por el usuario,\n" +"1. Todos los tipos encapsulados deben ser _propiedad_ de Rust, _administrados_ por el usuario,\n" " y _opaco_.\n" -"2. Todos los tipos de datos transaccionales deben ser _propiedad_ del " -"usuario y _transparentes_.\n" -"3. Todo el comportamiento de la biblioteca debe ser funciones que actúen " -"sobre tipos encapsulados.\n" -"4. Todo el comportamiento de la biblioteca debe encapsularse en tipos que no " -"se basen en la estructura,\n" +"2. Todos los tipos de datos transaccionales deben ser _propiedad_ del usuario y _transparentes_.\n" +"3. Todo el comportamiento de la biblioteca debe ser funciones que actúen sobre tipos encapsulados.\n" +"4. Todo el comportamiento de la biblioteca debe encapsularse en tipos que no se basen en la estructura,\n" " pero _procedencia/tiempo de vida_." #: src\patterns/ffi/export.md:17 #, fuzzy msgid "" "Rust has built-in FFI support to other languages.\n" -"It does this by providing a way for crate authors to provide C-compatible " -"APIs\n" +"It does this by providing a way for crate authors to provide C-compatible APIs\n" "through different ABIs (though that is unimportant to this practice)." msgstr "" "Rust tiene soporte FFI integrado para otros idiomas.\n" -"Lo hace al proporcionar una forma para que los autores de cajas proporcionen " -"API compatibles con C\n" +"Lo hace al proporcionar una forma para que los autores de cajas proporcionen API compatibles con C\n" "a través de diferentes ABI (aunque eso no es importante para esta práctica)." #: src\patterns/ffi/export.md:21 #, fuzzy msgid "" -"Well-designed Rust FFI follows C API design principles, while compromising " -"the\n" -"design in Rust as little as possible. There are three goals with any foreign " -"API:" +"Well-designed Rust FFI follows C API design principles, while compromising the\n" +"design in Rust as little as possible. There are three goals with any foreign API:" msgstr "" -"Rust FFI bien diseñado sigue los principios de diseño de C API, al tiempo " -"que compromete la\n" -"diseño en Rust lo menos posible. Hay tres objetivos con cualquier API " -"extranjera:" +"Rust FFI bien diseñado sigue los principios de diseño de C API, al tiempo que compromete la\n" +"diseño en Rust lo menos posible. Hay tres objetivos con cualquier API extranjera:" #: src\patterns/ffi/export.md:24 #, fuzzy msgid "" "1. Make it easy to use in the target language.\n" -"2. Avoid the API dictating internal unsafety on the Rust side as much as " -"possible.\n" -"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as " -"small\n" +"2. Avoid the API dictating internal unsafety on the Rust side as much as possible.\n" +"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as small\n" " as possible." msgstr "" "1. Facilite su uso en el idioma de destino.\n" -"2. Evite que la API dicte inseguridad interna en el lado de Rust tanto como " -"sea posible.\n" -"3. Mantenga el potencial de inseguridad de la memoria y el \"comportamiento " -"indefinido\" de Rust como pequeño\n" +"2. Evite que la API dicte inseguridad interna en el lado de Rust tanto como sea posible.\n" +"3. Mantenga el potencial de inseguridad de la memoria y el \"comportamiento indefinido\" de Rust como pequeño\n" " como sea posible." #: src\patterns/ffi/export.md:29 #, fuzzy msgid "" -"Rust code must trust the memory safety of the foreign language beyond a " -"certain\n" -"point. However, every bit of `unsafe` code on the Rust side is an " -"opportunity for\n" +"Rust code must trust the memory safety of the foreign language beyond a certain\n" +"point. However, every bit of `unsafe` code on the Rust side is an opportunity for\n" "bugs, or to exacerbate `undefined behaviour`." msgstr "" -"El código Rust debe confiar en la seguridad de la memoria del idioma " -"extranjero más allá de cierto\n" -"punto. Sin embargo, cada fragmento de código \"inseguro\" en el lado de Rust " -"es una oportunidad para\n" +"El código Rust debe confiar en la seguridad de la memoria del idioma extranjero más allá de cierto\n" +"punto. Sin embargo, cada fragmento de código \"inseguro\" en el lado de Rust es una oportunidad para\n" "errores, o para exacerbar el \"comportamiento indefinido\"." #: src\patterns/ffi/export.md:33 #, fuzzy msgid "" -"For example, if a pointer provenance is wrong, that may be a segfault due " -"to\n" -"invalid memory access. But if it is manipulated by unsafe code, it could " -"become\n" +"For example, if a pointer provenance is wrong, that may be a segfault due to\n" +"invalid memory access. But if it is manipulated by unsafe code, it could become\n" "full-blown heap corruption." msgstr "" -"Por ejemplo, si la procedencia de un puntero es incorrecta, eso puede ser un " -"error de segmentación debido a\n" -"acceso a memoria inválido. Pero si es manipulado por un código no seguro, " -"podría volverse\n" +"Por ejemplo, si la procedencia de un puntero es incorrecta, eso puede ser un error de segmentación debido a\n" +"acceso a memoria inválido. Pero si es manipulado por un código no seguro, podría volverse\n" "corrupción del montón en toda regla." #: src\patterns/ffi/export.md:37 #, fuzzy msgid "" -"The Object-Based API design allows for writing shims that have good memory " -"safety\n" +"The Object-Based API design allows for writing shims that have good memory safety\n" "characteristics, and a clean boundary of what is safe and what is `unsafe`." msgstr "" -"El diseño de la API basada en objetos permite escribir correcciones que " -"tienen buena seguridad de memoria\n" -"características, y un límite claro de lo que es seguro y lo que es " -"\"inseguro\"." +"El diseño de la API basada en objetos permite escribir correcciones que tienen buena seguridad de memoria\n" +"características, y un límite claro de lo que es seguro y lo que es \"inseguro\"." #: src\patterns/ffi/export.md:42 #, fuzzy msgid "" -"The POSIX standard defines the API to access an on-file database, known as " -"[DBM](https://web.archive.org/web/20210105035602/https://www.mankier.com/0p/ndbm.h).\n" +"The POSIX standard defines the API to access an on-file database, known as [DBM](https://web.archive.org/web/20210105035602/https://" +"www.mankier.com/0p/ndbm.h).\n" "It is an excellent example of an \"object-based\" API." msgstr "" -"El estándar POSIX define la API para acceder a una base de datos en archivo, " -"conocida como " -"[DBM](https://web.archive.org/web/20210105035602/https://www.mankier.com/0p/ndbm.h) " -".\n" +"El estándar POSIX define la API para acceder a una base de datos en archivo, conocida como [DBM](https://web.archive.org/" +"web/20210105035602/https://www.mankier.com/0p/ndbm.h) .\n" "Es un excelente ejemplo de una API \"basada en objetos\"." #: src\patterns/ffi/export.md:45 #, fuzzy msgid "" -"Here is the definition in C, which hopefully should be easy to read for " -"those\n" +"Here is the definition in C, which hopefully should be easy to read for those\n" "involved in FFI. The commentary below should help explain it for those who\n" "miss the subtleties." msgstr "" -"Aquí está la definición en C, que con suerte debería ser fácil de leer para " -"aquellos\n" -"involucrados en FFI. El comentario a continuación debería ayudar a " -"explicarlo para aquellos que\n" +"Aquí está la definición en C, que con suerte debería ser fácil de leer para aquellos\n" +"involucrados en FFI. El comentario a continuación debería ayudar a explicarlo para aquellos que\n" "perder las sutilezas." #: src\patterns/ffi/export.md:49 @@ -6560,26 +5554,21 @@ msgstr "Esta API define dos tipos: `DBM` y `datum`." #, fuzzy msgid "" "The `DBM` type was called an \"encapsulated\" type above.\n" -"It is designed to contain internal state, and acts as an entry point for " -"the\n" +"It is designed to contain internal state, and acts as an entry point for the\n" "library's behavior." msgstr "" "El tipo `DBM` se denominó tipo \"encapsulado\" anteriormente.\n" -"Está diseñado para contener el estado interno y actúa como un punto de " -"entrada para el\n" +"Está diseñado para contener el estado interno y actúa como un punto de entrada para el\n" "comportamiento de la biblioteca." #: src\patterns/ffi/export.md:70 #, fuzzy msgid "" -"It is completely opaque to the user, who cannot create a `DBM` themselves " -"since\n" -"they don't know its size or layout. Instead, they must call `dbm_open`, and " -"that\n" +"It is completely opaque to the user, who cannot create a `DBM` themselves since\n" +"they don't know its size or layout. Instead, they must call `dbm_open`, and that\n" "only gives them _a pointer to one_." msgstr "" -"Es completamente opaco para el usuario, que no puede crear un 'DBM' por sí " -"mismo ya que\n" +"Es completamente opaco para el usuario, que no puede crear un 'DBM' por sí mismo ya que\n" "no saben su tamaño o diseño. En su lugar, deben llamar a `dbm_open`, y eso\n" "solo les da _un puntero a uno_." @@ -6587,48 +5576,36 @@ msgstr "" #, fuzzy msgid "" "This means all `DBM`s are \"owned\" by the library in a Rust sense.\n" -"The internal state of unknown size is kept in memory controlled by the " -"library,\n" -"not the user. The user can only manage its life cycle with `open` and " -"`close`,\n" +"The internal state of unknown size is kept in memory controlled by the library,\n" +"not the user. The user can only manage its life cycle with `open` and `close`,\n" "and perform operations on it with the other functions." msgstr "" -"Esto significa que todos los 'DBM' son \"propiedad\" de la biblioteca en el " -"sentido de Rust.\n" -"El estado interno de tamaño desconocido se mantiene en la memoria controlada " -"por la biblioteca,\n" -"no el usuario. El usuario solo puede gestionar su ciclo de vida con `abrir` " -"y `cerrar`,\n" +"Esto significa que todos los 'DBM' son \"propiedad\" de la biblioteca en el sentido de Rust.\n" +"El estado interno de tamaño desconocido se mantiene en la memoria controlada por la biblioteca,\n" +"no el usuario. El usuario solo puede gestionar su ciclo de vida con `abrir` y `cerrar`,\n" "y realizar operaciones en él con las otras funciones." #: src\patterns/ffi/export.md:79 #, fuzzy msgid "" "The `datum` type was called a \"transactional\" type above.\n" -"It is designed to facilitate the exchange of information between the library " -"and\n" +"It is designed to facilitate the exchange of information between the library and\n" "its user." msgstr "" "El tipo `datum` se denominó tipo \"transaccional\" anteriormente.\n" -"Está diseñado para facilitar el intercambio de información entre la " -"biblioteca y\n" +"Está diseñado para facilitar el intercambio de información entre la biblioteca y\n" "su usuario." #: src\patterns/ffi/export.md:83 #, fuzzy msgid "" -"The database is designed to store \"unstructured data\", with no pre-defined " -"length\n" -"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a " -"bunch\n" -"of bytes, and a count of how many there are. The main difference is that " -"there is\n" +"The database is designed to store \"unstructured data\", with no pre-defined length\n" +"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a bunch\n" +"of bytes, and a count of how many there are. The main difference is that there is\n" "no type information, which is what `void` indicates." msgstr "" -"La base de datos está diseñada para almacenar \"datos no estructurados\", " -"sin longitud predefinida\n" -"o significado. Como resultado, el `dato` es el equivalente en C de una " -"rebanada de Rust: un montón\n" +"La base de datos está diseñada para almacenar \"datos no estructurados\", sin longitud predefinida\n" +"o significado. Como resultado, el `dato` es el equivalente en C de una rebanada de Rust: un montón\n" "de bytes, y un recuento de cuántos hay. La principal diferencia es que hay\n" "sin información de tipo, que es lo que indica `void`." @@ -6637,29 +5614,23 @@ msgstr "" msgid "" "Keep in mind that this header is written from the library's point of view.\n" "The user likely has some type they are using, which has a known size.\n" -"But the library does not care, and by the rules of C casting, any type " -"behind a\n" +"But the library does not care, and by the rules of C casting, any type behind a\n" "pointer can be cast to `void`." msgstr "" -"Tenga en cuenta que este encabezado está escrito desde el punto de vista de " -"la biblioteca.\n" -"Es probable que el usuario tenga algún tipo que esté usando, que tenga un " -"tamaño conocido.\n" -"Pero a la biblioteca no le importa, y según las reglas de conversión de C, " -"cualquier tipo detrás de un\n" +"Tenga en cuenta que este encabezado está escrito desde el punto de vista de la biblioteca.\n" +"Es probable que el usuario tenga algún tipo que esté usando, que tenga un tamaño conocido.\n" +"Pero a la biblioteca no le importa, y según las reglas de conversión de C, cualquier tipo detrás de un\n" "el puntero se puede convertir en `void`." #: src\patterns/ffi/export.md:93 #, fuzzy msgid "" -"As noted earlier, this type is _transparent_ to the user. But also, this " -"type is\n" +"As noted earlier, this type is _transparent_ to the user. But also, this type is\n" "_owned_ by the user.\n" "This has subtle ramifications, due to that pointer inside it.\n" "The question is, who owns the memory that pointer points to?" msgstr "" -"Como se señaló anteriormente, este tipo es _transparente_ para el usuario. " -"Pero también, este tipo es\n" +"Como se señaló anteriormente, este tipo es _transparente_ para el usuario. Pero también, este tipo es\n" "_propiedad_ del usuario.\n" "Esto tiene ramificaciones sutiles, debido a ese puntero en su interior.\n" "La pregunta es, ¿quién posee la memoria a la que apunta el puntero?" @@ -6668,20 +5639,15 @@ msgstr "" #, fuzzy msgid "" "The answer for best memory safety is, \"the user\".\n" -"But in cases such as retrieving a value, the user does not know how to " -"allocate\n" -"it correctly (since they don't know how long the value is). In this case, " -"the library\n" -"code is expected to use the heap that the user has access to -- such as the " -"C library\n" +"But in cases such as retrieving a value, the user does not know how to allocate\n" +"it correctly (since they don't know how long the value is). In this case, the library\n" +"code is expected to use the heap that the user has access to -- such as the C library\n" "`malloc` and `free` -- and then _transfer ownership_ in the Rust sense." msgstr "" "La respuesta para la mejor seguridad de la memoria es \"el usuario\".\n" "Pero en casos como recuperar un valor, el usuario no sabe cómo asignar\n" -"correctamente (ya que no saben cuánto tiempo es el valor). En este caso, la " -"biblioteca.\n" -"Se espera que el código use el montón al que el usuario tiene acceso, como " -"la biblioteca C.\n" +"correctamente (ya que no saben cuánto tiempo es el valor). En este caso, la biblioteca.\n" +"Se espera que el código use el montón al que el usuario tiene acceso, como la biblioteca C.\n" "`malloc` y `free` -- y luego _transferir propiedad_ en el sentido de Rust." #: src\patterns/ffi/export.md:104 @@ -6689,78 +5655,60 @@ msgstr "" msgid "" "This may all seem speculative, but this is what a pointer means in C.\n" "It means the same thing as Rust: \"user defined lifetime.\"\n" -"The user of the library needs to read the documentation in order to use it " -"correctly.\n" -"That said, there are some decisions that have fewer or greater consequences " -"if users\n" -"do it wrong. Minimizing those are what this best practice is about, and the " -"key\n" +"The user of the library needs to read the documentation in order to use it correctly.\n" +"That said, there are some decisions that have fewer or greater consequences if users\n" +"do it wrong. Minimizing those are what this best practice is about, and the key\n" "is to _transfer ownership of everything that is transparent_." msgstr "" -"Todo esto puede parecer especulativo, pero esto es lo que significa un " -"puntero en C.\n" +"Todo esto puede parecer especulativo, pero esto es lo que significa un puntero en C.\n" "Significa lo mismo que Rust: \"vida útil definida por el usuario\".\n" -"El usuario de la biblioteca necesita leer la documentación para utilizarla " -"correctamente.\n" -"Dicho esto, hay algunas decisiones que tienen menos o mayores consecuencias " -"si los usuarios\n" -"hazlo mal Minimizarlos es de lo que se trata esta mejor práctica, y la " -"clave\n" +"El usuario de la biblioteca necesita leer la documentación para utilizarla correctamente.\n" +"Dicho esto, hay algunas decisiones que tienen menos o mayores consecuencias si los usuarios\n" +"hazlo mal Minimizarlos es de lo que se trata esta mejor práctica, y la clave\n" "es _transferir la propiedad de todo lo que es transparente_." #: src\patterns/ffi/export.md:113 #, fuzzy msgid "" -"This minimizes the number of memory safety guarantees the user must uphold " -"to a\n" +"This minimizes the number of memory safety guarantees the user must uphold to a\n" "relatively small number:" msgstr "" -"Esto minimiza el número de garantías de seguridad de la memoria que el " -"usuario debe mantener a un nivel\n" +"Esto minimiza el número de garantías de seguridad de la memoria que el usuario debe mantener a un nivel\n" "número relativamente pequeño:" #: src\patterns/ffi/export.md:116 #, fuzzy msgid "" -"1. Do not call any function with a pointer not returned by `dbm_open` " -"(invalid\n" +"1. Do not call any function with a pointer not returned by `dbm_open` (invalid\n" " access or corruption).\n" "2. Do not call any function on a pointer after close (use after free).\n" -"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of " -"memory\n" +"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of memory\n" " at the advertised length." msgstr "" -"1. No llame a ninguna función con un puntero no devuelto por `dbm_open` " -"(inválido\n" +"1. No llame a ninguna función con un puntero no devuelto por `dbm_open` (inválido\n" " acceso o corrupción).\n" -"2. No llame a ninguna función en un puntero después de cerrar (usar después " -"de liberar).\n" -"3. El `dptr` en cualquier `datum` debe ser `NULL`, o apuntar a una porción " -"válida de memoria\n" +"2. No llame a ninguna función en un puntero después de cerrar (usar después de liberar).\n" +"3. El `dptr` en cualquier `datum` debe ser `NULL`, o apuntar a una porción válida de memoria\n" " en la longitud anunciada." #: src\patterns/ffi/export.md:122 #, fuzzy msgid "" "In addition, it avoids a lot of pointer provenance issues.\n" -"To understand why, let us consider an alternative in some depth: key " -"iteration." +"To understand why, let us consider an alternative in some depth: key iteration." msgstr "" "Además, evita muchos problemas de procedencia de punteros.\n" -"Para entender por qué, consideremos una alternativa con cierta profundidad: " -"iteración clave." +"Para entender por qué, consideremos una alternativa con cierta profundidad: iteración clave." #: src\patterns/ffi/export.md:125 #, fuzzy msgid "" "Rust is well known for its iterators.\n" -"When implementing one, the programmer makes a separate type with a bounded " -"lifetime\n" +"When implementing one, the programmer makes a separate type with a bounded lifetime\n" "to its owner, and implements the `Iterator` trait." msgstr "" "Rust es bien conocido por sus iteradores.\n" -"Al implementar uno, el programador crea un tipo separado con una vida útil " -"limitada\n" +"Al implementar uno, el programador crea un tipo separado con una vida útil limitada\n" "a su propietario, e implementa el rasgo `Iterator`." #: src\patterns/ffi/export.md:129 @@ -6801,21 +5749,18 @@ msgid "" "```rust,ignore\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_new(owner: *const Dbm) -> *mut DbmKeysIter {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_next(\n" " iter: *mut DbmKeysIter,\n" " key_out: *const datum\n" ") -> libc::c_int {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_del(*mut DbmKeysIter) {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "```" msgstr "" @@ -6823,28 +5768,20 @@ msgstr "" #: src\patterns/ffi/export.md:168 #, fuzzy msgid "" -"This API loses a key piece of information: the lifetime of the iterator must " -"not\n" -"exceed the lifetime of the `Dbm` object that owns it. A user of the library " -"could\n" -"use it in a way which causes the iterator to outlive the data it is " -"iterating on,\n" +"This API loses a key piece of information: the lifetime of the iterator must not\n" +"exceed the lifetime of the `Dbm` object that owns it. A user of the library could\n" +"use it in a way which causes the iterator to outlive the data it is iterating on,\n" "resulting in reading uninitialized memory." msgstr "" -"Esta API pierde una pieza clave de información: la vida útil del iterador no " -"debe\n" -"exceda la vida útil del objeto `Dbm` que lo posee. Un usuario de la " -"biblioteca podría\n" -"úselo de una manera que haga que el iterador sobreviva a los datos en los " -"que está iterando,\n" +"Esta API pierde una pieza clave de información: la vida útil del iterador no debe\n" +"exceda la vida útil del objeto `Dbm` que lo posee. Un usuario de la biblioteca podría\n" +"úselo de una manera que haga que el iterador sobreviva a los datos en los que está iterando,\n" "resultando en la lectura de la memoria no inicializada." #: src\patterns/ffi/export.md:173 #, fuzzy -msgid "" -"This example written in C contains a bug that will be explained afterwards:" -msgstr "" -"Este ejemplo escrito en C contiene un error que se explicará más adelante:" +msgid "This example written in C contains a bug that will be explained afterwards:" +msgstr "Este ejemplo escrito en C contiene un error que se explicará más adelante:" #: src\patterns/ffi/export.md:175 msgid "" @@ -6860,8 +5797,7 @@ msgid "" " }\n" "\n" " int l;\n" -" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated " -"by -1\n" +" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated by -1\n" " free(key.dptr);\n" " len += key.dsize;\n" " if (l == 0) { // end of the iterator\n" @@ -6883,85 +5819,63 @@ msgid "" "This bug is a classic. Here's what happens when the iterator returns the\n" "end-of-iteration marker:" msgstr "" -"Este error es un clásico. Esto es lo que sucede cuando el iterador devuelve " -"el\n" +"Este error es un clásico. Esto es lo que sucede cuando el iterador devuelve el\n" "marcador de fin de iteración:" #: src\patterns/ffi/export.md:205 #, fuzzy msgid "" -"1. The loop condition sets `l` to zero, and enters the loop because `0 >= " -"0`.\n" +"1. The loop condition sets `l` to zero, and enters the loop because `0 >= 0`.\n" "2. The length is incremented, in this case by zero.\n" -"3. The if statement is true, so the database is closed. There should be a " -"break\n" +"3. The if statement is true, so the database is closed. There should be a break\n" " statement here.\n" -"4. The loop condition executes again, causing a `next` call on the closed " -"object." +"4. The loop condition executes again, causing a `next` call on the closed object." msgstr "" -"1. La condición del bucle establece `l` en cero y entra en el bucle porque " -"`0 >= 0`.\n" +"1. La condición del bucle establece `l` en cero y entra en el bucle porque `0 >= 0`.\n" "2. La longitud se incrementa, en este caso por cero.\n" -"3. La declaración if es verdadera, por lo que la base de datos está cerrada. " -"debe haber un descanso\n" +"3. La declaración if es verdadera, por lo que la base de datos está cerrada. debe haber un descanso\n" " declaración aquí.\n" -"4. La condición de bucle se ejecuta de nuevo, provocando una llamada " -"`siguiente` en el objeto cerrado." +"4. La condición de bucle se ejecuta de nuevo, provocando una llamada `siguiente` en el objeto cerrado." #: src\patterns/ffi/export.md:211 #, fuzzy msgid "" "The worst part about this bug?\n" -"If the Rust implementation was careful, this code will work most of the " -"time!\n" -"If the memory for the `Dbm` object is not immediately reused, an internal " -"check\n" -"will almost certainly fail, resulting in the iterator returning a `-1` " -"indicating\n" -"an error. But occasionally, it will cause a segmentation fault, or even " -"worse,\n" +"If the Rust implementation was careful, this code will work most of the time!\n" +"If the memory for the `Dbm` object is not immediately reused, an internal check\n" +"will almost certainly fail, resulting in the iterator returning a `-1` indicating\n" +"an error. But occasionally, it will cause a segmentation fault, or even worse,\n" "nonsensical memory corruption!" msgstr "" "¿La peor parte de este error?\n" -"Si la implementación de Rust fue cuidadosa, ¡este código funcionará la mayor " -"parte del tiempo!\n" -"Si la memoria para el objeto `Dbm` no se reutiliza de inmediato, una " -"verificación interna\n" -"es casi seguro que fallará, lo que hará que el iterador devuelva un `-1` que " -"indica\n" -"un error. Pero en ocasiones, provocará un fallo de segmentación, o peor " -"aún,\n" +"Si la implementación de Rust fue cuidadosa, ¡este código funcionará la mayor parte del tiempo!\n" +"Si la memoria para el objeto `Dbm` no se reutiliza de inmediato, una verificación interna\n" +"es casi seguro que fallará, lo que hará que el iterador devuelva un `-1` que indica\n" +"un error. Pero en ocasiones, provocará un fallo de segmentación, o peor aún,\n" "Corrupción de memoria sin sentido!" #: src\patterns/ffi/export.md:218 #, fuzzy msgid "" "None of this can be avoided by Rust.\n" -"From its perspective, it put those objects on its heap, returned pointers to " -"them,\n" +"From its perspective, it put those objects on its heap, returned pointers to them,\n" "and gave up control of their lifetimes. The C code simply must \"play nice\"." msgstr "" "Rust no puede evitar nada de esto.\n" -"Desde su perspectiva, puso esos objetos en su montón, les devolvió " -"punteros,\n" -"y cedieron el control de sus vidas. El código C simplemente debe \"jugar " -"bien\"." +"Desde su perspectiva, puso esos objetos en su montón, les devolvió punteros,\n" +"y cedieron el control de sus vidas. El código C simplemente debe \"jugar bien\"." #: src\patterns/ffi/export.md:222 #, fuzzy msgid "" "The programmer must read and understand the API documentation.\n" -"While some consider that par for the course in C, a good API design can " -"mitigate\n" -"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ " -"of\n" +"While some consider that par for the course in C, a good API design can mitigate\n" +"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ of\n" "the iterator with its parent:" msgstr "" "El programador debe leer y comprender la documentación de la API.\n" -"Mientras que algunos consideran que está a la par del curso en C, un buen " -"diseño de API puede mitigar\n" -"este riesgo La API POSIX para `DBM` hizo esto al _consolidar la propiedad_ " -"de\n" +"Mientras que algunos consideran que está a la par del curso en C, un buen diseño de API puede mitigar\n" +"este riesgo La API POSIX para `DBM` hizo esto al _consolidar la propiedad_ de\n" "el iterador con su padre:" #: src\patterns/ffi/export.md:227 @@ -6974,10 +5888,8 @@ msgstr "" #: src\patterns/ffi/export.md:232 #, fuzzy -msgid "" -"Thus, all the lifetimes were bound together, and such unsafety was prevented." -msgstr "" -"Por lo tanto, todas las vidas estaban unidas y se previno tal inseguridad." +msgid "Thus, all the lifetimes were bound together, and such unsafety was prevented." +msgstr "Por lo tanto, todas las vidas estaban unidas y se previno tal inseguridad." #: src\patterns/ffi/export.md:236 #, fuzzy @@ -6985,70 +5897,55 @@ msgid "" "However, this design choice also has a number of drawbacks, which should be\n" "considered as well." msgstr "" -"Sin embargo, esta elección de diseño también tiene una serie de " -"inconvenientes, que deben ser\n" +"Sin embargo, esta elección de diseño también tiene una serie de inconvenientes, que deben ser\n" "considerado también." #: src\patterns/ffi/export.md:239 #, fuzzy msgid "" "First, the API itself becomes less expressive.\n" -"With POSIX DBM, there is only one iterator per object, and every call " -"changes\n" -"its state. This is much more restrictive than iterators in almost any " -"language,\n" -"even though it is safe. Perhaps with other related objects, whose lifetimes " -"are\n" +"With POSIX DBM, there is only one iterator per object, and every call changes\n" +"its state. This is much more restrictive than iterators in almost any language,\n" +"even though it is safe. Perhaps with other related objects, whose lifetimes are\n" "less hierarchical, this limitation is more of a cost than the safety." msgstr "" "Primero, la propia API se vuelve menos expresiva.\n" "Con POSIX DBM, solo hay un iterador por objeto y cada llamada cambia\n" -"su estado Esto es mucho más restrictivo que los iteradores en casi cualquier " -"idioma,\n" +"su estado Esto es mucho más restrictivo que los iteradores en casi cualquier idioma,\n" "aunque sea seguro. Tal vez con otros objetos relacionados, cuyas vidas son\n" "menos jerárquica, esta limitación es más costosa que la seguridad." #: src\patterns/ffi/export.md:245 #, fuzzy msgid "" -"Second, depending on the relationships of the API's parts, significant " -"design effort\n" -"may be involved. Many of the easier design points have other patterns " -"associated\n" +"Second, depending on the relationships of the API's parts, significant design effort\n" +"may be involved. Many of the easier design points have other patterns associated\n" "with them:" msgstr "" -"Segundo, dependiendo de las relaciones de las partes de la API, un esfuerzo " -"de diseño significativo\n" -"puede estar implicado. Muchos de los puntos de diseño más fáciles tienen " -"otros patrones asociados\n" +"Segundo, dependiendo de las relaciones de las partes de la API, un esfuerzo de diseño significativo\n" +"puede estar implicado. Muchos de los puntos de diseño más fáciles tienen otros patrones asociados\n" "con ellos:" #: src\patterns/ffi/export.md:249 #, fuzzy msgid "" -"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types " -"together\n" +"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types together\n" " into an opaque \"object\"\n" "\n" -"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling " -"with integer\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling with integer\n" " codes and sentinel return values (such as `NULL` pointers)\n" "\n" -"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows " -"accepting\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows accepting\n" " strings with minimal unsafe code, and is easier to get right than\n" " [Passing Strings to FFI](../../idioms/ffi/passing-strings.md)" msgstr "" -"- [Consolidación de tipos de contenedor] (./wrappers.md) agrupa varios tipos " -"de Rust juntos\n" +"- [Consolidación de tipos de contenedor] (./wrappers.md) agrupa varios tipos de Rust juntos\n" " en un \"objeto\" opaco\n" "\n" -"- [FFI Error Passing](../../idioms/ffi/errors.md) explica el manejo de " -"errores con enteros\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) explica el manejo de errores con enteros\n" " códigos y valores de retorno de centinela (como punteros `NULL`)\n" "\n" -"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) permite " -"aceptar\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) permite aceptar\n" " cadenas con código inseguro mínimo, y es más fácil hacerlo bien que\n" " [Pasar cadenas a FFI](../../idioms/ffi/passing-strings.md)" @@ -7069,12 +5966,10 @@ msgstr "# Escriba la consolidación en contenedores" #: src\patterns/ffi/wrappers.md:5 #, fuzzy msgid "" -"This pattern is designed to allow gracefully handling multiple related " -"types,\n" +"This pattern is designed to allow gracefully handling multiple related types,\n" "while minimizing the surface area for memory unsafety." msgstr "" -"Este patrón está diseñado para permitir el manejo elegante de múltiples " -"tipos relacionados,\n" +"Este patrón está diseñado para permitir el manejo elegante de múltiples tipos relacionados,\n" "mientras minimiza el área de superficie para la inseguridad de la memoria." #: src\patterns/ffi/wrappers.md:8 @@ -7084,64 +5979,48 @@ msgid "" "This ensures that many patterns of access between types can be memory safe,\n" "data race safety included." msgstr "" -"Una de las piedras angulares de las reglas de aliasing de Rust son las " -"vidas.\n" -"Esto asegura que muchos patrones de acceso entre tipos puedan ser seguros " -"para la memoria,\n" +"Una de las piedras angulares de las reglas de aliasing de Rust son las vidas.\n" +"Esto asegura que muchos patrones de acceso entre tipos puedan ser seguros para la memoria,\n" "seguridad de carrera de datos incluida." #: src\patterns/ffi/wrappers.md:12 #, fuzzy msgid "" -"However, when Rust types are exported to other languages, they are usually " -"transformed\n" -"into pointers. In Rust, a pointer means \"the user manages the lifetime of " -"the pointee.\"\n" +"However, when Rust types are exported to other languages, they are usually transformed\n" +"into pointers. In Rust, a pointer means \"the user manages the lifetime of the pointee.\"\n" "It is their responsibility to avoid memory unsafety." msgstr "" -"Sin embargo, cuando los tipos de Rust se exportan a otros lenguajes, " -"generalmente se transforman\n" -"en punteros. En Rust, un puntero significa \"el usuario administra la vida " -"útil del pointee\".\n" +"Sin embargo, cuando los tipos de Rust se exportan a otros lenguajes, generalmente se transforman\n" +"en punteros. En Rust, un puntero significa \"el usuario administra la vida útil del pointee\".\n" "Es su responsabilidad evitar la inseguridad de la memoria." #: src\patterns/ffi/wrappers.md:16 #, fuzzy msgid "" -"Some level of trust in the user code is thus required, notably around " -"use-after-free\n" -"which Rust can do nothing about. However, some API designs place higher " -"burdens\n" +"Some level of trust in the user code is thus required, notably around use-after-free\n" +"which Rust can do nothing about. However, some API designs place higher burdens\n" "than others on the code written in the other language." msgstr "" -"Por lo tanto, se requiere cierto nivel de confianza en el código de usuario, " -"especialmente en torno al uso después de la liberación.\n" -"sobre el cual Rust no puede hacer nada. Sin embargo, algunos diseños de API " -"imponen mayores cargas\n" +"Por lo tanto, se requiere cierto nivel de confianza en el código de usuario, especialmente en torno al uso después de la liberación.\n" +"sobre el cual Rust no puede hacer nada. Sin embargo, algunos diseños de API imponen mayores cargas\n" "que otros en el código escrito en el otro idioma." #: src\patterns/ffi/wrappers.md:20 #, fuzzy msgid "" -"The lowest risk API is the \"consolidated wrapper\", where all possible " -"interactions\n" -"with an object are folded into a \"wrapper type\", while keeping the Rust " -"API clean." +"The lowest risk API is the \"consolidated wrapper\", where all possible interactions\n" +"with an object are folded into a \"wrapper type\", while keeping the Rust API clean." msgstr "" -"La API de menor riesgo es el \"contenedor consolidado\", donde todas las " -"posibles interacciones\n" -"con un objeto se pliegan en un \"tipo contenedor\", mientras se mantiene " -"limpia la API de Rust." +"La API de menor riesgo es el \"contenedor consolidado\", donde todas las posibles interacciones\n" +"con un objeto se pliegan en un \"tipo contenedor\", mientras se mantiene limpia la API de Rust." #: src\patterns/ffi/wrappers.md:25 #, fuzzy msgid "" -"To understand this, let us look at a classic example of an API to export: " -"iteration\n" +"To understand this, let us look at a classic example of an API to export: iteration\n" "through a collection." msgstr "" -"Para entender esto, veamos un ejemplo clásico de una API para exportar: " -"iteración\n" +"Para entender esto, veamos un ejemplo clásico de una API para exportar: iteración\n" "a través de una colección." #: src\patterns/ffi/wrappers.md:28 @@ -7155,26 +6034,22 @@ msgid "" "1. The iterator is initialized with `first_key`.\n" "2. Each call to `next_key` will advance the iterator.\n" "3. Calls to `next_key` if the iterator is at the end will do nothing.\n" -"4. As noted above, the iterator is \"wrapped into\" the collection (unlike " -"the native\n" +"4. As noted above, the iterator is \"wrapped into\" the collection (unlike the native\n" " Rust API)." msgstr "" "1. El iterador se inicializa con `first_key`.\n" "2. Cada llamada a `next_key` hará avanzar el iterador.\n" "3. Las llamadas a `next_key` si el iterador está al final no harán nada.\n" -"4. Como se señaló anteriormente, el iterador está \"envuelto\" en la " -"colección (a diferencia del nativo\n" +"4. Como se señaló anteriormente, el iterador está \"envuelto\" en la colección (a diferencia del nativo\n" " API de óxido)." #: src\patterns/ffi/wrappers.md:36 #, fuzzy msgid "" -"If the iterator implements `nth()` efficiently, then it is possible to make " -"it\n" +"If the iterator implements `nth()` efficiently, then it is possible to make it\n" "ephemeral to each function call:" msgstr "" -"Si el iterador implementa `nth()` de manera eficiente, entonces es posible " -"hacerlo\n" +"Si el iterador implementa `nth()` de manera eficiente, entonces es posible hacerlo\n" "efímero a cada llamada de función:" #: src\patterns/ffi/wrappers.md:39 @@ -7205,51 +6080,39 @@ msgstr "" #: src\patterns/ffi/wrappers.md:61 #, fuzzy msgid "As a result, the wrapper is simple and contains no `unsafe` code." -msgstr "" -"Como resultado, el envoltorio es simple y no contiene código \"no seguro\"." +msgstr "Como resultado, el envoltorio es simple y no contiene código \"no seguro\"." #: src\patterns/ffi/wrappers.md:65 #, fuzzy msgid "" "This makes APIs safer to use, avoiding issues with lifetimes between types.\n" -"See [Object-Based APIs](./export.md) for more on the advantages and " -"pitfalls\n" +"See [Object-Based APIs](./export.md) for more on the advantages and pitfalls\n" "this avoids." msgstr "" -"Esto hace que las API sean más seguras de usar, evitando problemas con la " -"vida útil entre tipos.\n" -"Consulte [API basadas en objetos] (./export.md) para obtener más información " -"sobre las ventajas y desventajas\n" +"Esto hace que las API sean más seguras de usar, evitando problemas con la vida útil entre tipos.\n" +"Consulte [API basadas en objetos] (./export.md) para obtener más información sobre las ventajas y desventajas\n" "esto evita." #: src\patterns/ffi/wrappers.md:71 #, fuzzy msgid "" -"Often, wrapping types is quite difficult, and sometimes a Rust API " -"compromise\n" +"Often, wrapping types is quite difficult, and sometimes a Rust API compromise\n" "would make things easier." msgstr "" -"A menudo, envolver tipos es bastante difícil y, a veces, un compromiso de la " -"API de Rust\n" +"A menudo, envolver tipos es bastante difícil y, a veces, un compromiso de la API de Rust\n" "facilitaría las cosas." #: src\patterns/ffi/wrappers.md:74 #, fuzzy msgid "" -"As an example, consider an iterator which does not efficiently implement " -"`nth()`.\n" -"It would definitely be worth putting in special logic to make the object " -"handle\n" -"iteration internally, or to support a different access pattern efficiently " -"that\n" +"As an example, consider an iterator which does not efficiently implement `nth()`.\n" +"It would definitely be worth putting in special logic to make the object handle\n" +"iteration internally, or to support a different access pattern efficiently that\n" "only the Foreign Function API will use." msgstr "" -"Como ejemplo, considere un iterador que no implementa eficientemente " -"`nth()`.\n" -"Definitivamente valdría la pena poner una lógica especial para hacer que el " -"objeto maneje\n" -"iteración internamente, o para admitir un patrón de acceso diferente de " -"manera eficiente que\n" +"Como ejemplo, considere un iterador que no implementa eficientemente `nth()`.\n" +"Definitivamente valdría la pena poner una lógica especial para hacer que el objeto maneje\n" +"iteración internamente, o para admitir un patrón de acceso diferente de manera eficiente que\n" "solo se utilizará la API de funciones externas." #: src\patterns/ffi/wrappers.md:79 @@ -7260,16 +6123,12 @@ msgstr "### Tratando de envolver iteradores (y fallando)" #: src\patterns/ffi/wrappers.md:81 #, fuzzy msgid "" -"To wrap any type of iterator into the API correctly, the wrapper would need " -"to\n" -"do what a C version of the code would do: erase the lifetime of the " -"iterator,\n" +"To wrap any type of iterator into the API correctly, the wrapper would need to\n" +"do what a C version of the code would do: erase the lifetime of the iterator,\n" "and manage it manually." msgstr "" -"Para envolver cualquier tipo de iterador en la API correctamente, el " -"envoltorio tendría que\n" -"hacer lo que haría una versión C del código: borrar la vida útil del " -"iterador,\n" +"Para envolver cualquier tipo de iterador en la API correctamente, el envoltorio tendría que\n" +"hacer lo que haría una versión C del código: borrar la vida útil del iterador,\n" "y administrarlo manualmente." #: src\patterns/ffi/wrappers.md:85 @@ -7306,8 +6165,7 @@ msgid "" "it's ugly already. But it gets even worse: _any other operation can cause\n" "Rust `undefined behaviour`_." msgstr "" -"Con 'transmutar' que se usa para extender la vida útil y un puntero para " -"ocultarlo,\n" +"Con 'transmutar' que se usa para extender la vida útil y un puntero para ocultarlo,\n" "ya es feo. Pero se pone aún peor: _cualquier otra operación puede causar\n" "Rust `comportamiento indefinido`_." @@ -7320,8 +6178,7 @@ msgid "" "libraries expect it." msgstr "" "Considere que `MySet` en el contenedor podría ser manipulado por otros\n" -"funciones durante la iteración, como almacenar un nuevo valor en la clave " -"que fue\n" +"funciones durante la iteración, como almacenar un nuevo valor en la clave que fue\n" "iterando sobre. La API no desaconseja esto, y de hecho algunos C similares\n" "las bibliotecas lo esperan." @@ -7344,8 +6201,7 @@ msgid "" "\n" " // DO NOT USE THIS CODE. IT IS UNSAFE TO DEMONSTRATE A PROLBEM.\n" "\n" -" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in " -"here!\n" +" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in here!\n" " &mut (*myset).myset\n" " };\n" "\n" @@ -7363,103 +6219,71 @@ msgstr "" #: src\patterns/ffi/wrappers.md:137 #, fuzzy msgid "" -"If the iterator exists when this function is called, we have violated one of " -"Rust's\n" -"aliasing rules. According to Rust, the mutable reference in this block must " -"have\n" -"_exclusive_ access to the object. If the iterator simply exists, it's not " -"exclusive,\n" +"If the iterator exists when this function is called, we have violated one of Rust's\n" +"aliasing rules. According to Rust, the mutable reference in this block must have\n" +"_exclusive_ access to the object. If the iterator simply exists, it's not exclusive,\n" "so we have `undefined behaviour`! " msgstr "" -"Si el iterador existe cuando se llama a esta función, hemos violado una de " -"las reglas de Rust\n" -"reglas de alias. Según Rust, la referencia mutable en este bloque debe " -"tener\n" -"acceso _exclusivo_ al objeto. Si el iterador simplemente existe, no es " -"exclusivo,\n" +"Si el iterador existe cuando se llama a esta función, hemos violado una de las reglas de Rust\n" +"reglas de alias. Según Rust, la referencia mutable en este bloque debe tener\n" +"acceso _exclusivo_ al objeto. Si el iterador simplemente existe, no es exclusivo,\n" "¡así que tenemos un `comportamiento indefinido`!" #: src\patterns/ffi/wrappers.md:142 #, fuzzy msgid "" -"To avoid this, we must have a way of ensuring that mutable reference really " -"is exclusive.\n" -"That basically means clearing out the iterator's shared reference while it " -"exists,\n" -"and then reconstructing it. In most cases, that will still be less efficient " -"than\n" +"To avoid this, we must have a way of ensuring that mutable reference really is exclusive.\n" +"That basically means clearing out the iterator's shared reference while it exists,\n" +"and then reconstructing it. In most cases, that will still be less efficient than\n" "the C version." msgstr "" -"Para evitar esto, debemos tener una forma de asegurar que la referencia " -"mutable sea realmente exclusiva.\n" -"Eso básicamente significa borrar la referencia compartida del iterador " -"mientras existe,\n" -"y luego reconstruirlo. En la mayoría de los casos, seguirá siendo menos " -"eficiente que\n" +"Para evitar esto, debemos tener una forma de asegurar que la referencia mutable sea realmente exclusiva.\n" +"Eso básicamente significa borrar la referencia compartida del iterador mientras existe,\n" +"y luego reconstruirlo. En la mayoría de los casos, seguirá siendo menos eficiente que\n" "la versión C." #: src\patterns/ffi/wrappers.md:147 #, fuzzy msgid "" "Some may ask: how can C do this more efficiently?\n" -"The answer is, it cheats. Rust's aliasing rules are the problem, and C " -"simply ignores\n" -"them for its pointers. In exchange, it is common to see code that is " -"declared\n" -"in the manual as \"not thread safe\" under some or all circumstances. In " -"fact,\n" -"the [GNU C " -"library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"The answer is, it cheats. Rust's aliasing rules are the problem, and C simply ignores\n" +"them for its pointers. In exchange, it is common to see code that is declared\n" +"in the manual as \"not thread safe\" under some or all circumstances. In fact,\n" +"the [GNU C library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" "has an entire lexicon dedicated to concurrent behavior!" msgstr "" -"Algunos pueden preguntarse: ¿cómo puede C hacer esto de manera más " -"eficiente?\n" -"La respuesta es que hace trampa. Las reglas de alias de Rust son el " -"problema, y C simplemente ignora\n" +"Algunos pueden preguntarse: ¿cómo puede C hacer esto de manera más eficiente?\n" +"La respuesta es que hace trampa. Las reglas de alias de Rust son el problema, y C simplemente ignora\n" "ellos por sus punteros. A cambio, es común ver código que se declara\n" -"en el manual como \"no seguro para subprocesos\" en algunas o todas las " -"circunstancias. De hecho,\n" -"la [biblioteca GNU " -"C](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"en el manual como \"no seguro para subprocesos\" en algunas o todas las circunstancias. De hecho,\n" +"la [biblioteca GNU C](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" "tiene un léxico completo dedicado al comportamiento concurrente!" #: src\patterns/ffi/wrappers.md:154 #, fuzzy msgid "" -"Rust would rather make everything memory safe all the time, for both safety " -"and\n" -"optimizations that C code cannot attain. Being denied access to certain " -"shortcuts\n" +"Rust would rather make everything memory safe all the time, for both safety and\n" +"optimizations that C code cannot attain. Being denied access to certain shortcuts\n" "is the price Rust programmers need to pay." msgstr "" -"Rust prefiere que todo sea seguro para la memoria todo el tiempo, tanto por " -"seguridad como por\n" -"optimizaciones que el código C no puede lograr. Ser denegado el acceso a " -"ciertos accesos directos\n" +"Rust prefiere que todo sea seguro para la memoria todo el tiempo, tanto por seguridad como por\n" +"optimizaciones que el código C no puede lograr. Ser denegado el acceso a ciertos accesos directos\n" "es el precio que los programadores de Rust deben pagar." #: src\patterns/ffi/wrappers.md:158 #, fuzzy msgid "" "For the C programmers out there scratching their heads, the iterator need\n" -"not be read _during_ this code cause the UB. The exclusivity rule also " -"enables\n" -"compiler optimizations which may cause inconsistent observations by the " -"iterator's\n" -"shared reference (e.g. stack spills or reordering instructions for " -"efficiency).\n" -"These observations may happen _any time after_ the mutable reference is " -"created." +"not be read _during_ this code cause the UB. The exclusivity rule also enables\n" +"compiler optimizations which may cause inconsistent observations by the iterator's\n" +"shared reference (e.g. stack spills or reordering instructions for efficiency).\n" +"These observations may happen _any time after_ the mutable reference is created." msgstr "" "Para los programadores de C que se rascan la cabeza, el iterador necesita\n" -"no se leerá _durante_ este código causará la UB. La regla de exclusividad " -"también permite\n" -"optimizaciones del compilador que pueden causar observaciones inconsistentes " -"por parte del iterador\n" -"referencia compartida (por ejemplo, derrames de pilas o instrucciones de " -"reordenación para mayor eficiencia).\n" -"Estas observaciones pueden ocurrir _en cualquier momento después de_ que se " -"cree la referencia mutable." +"no se leerá _durante_ este código causará la UB. La regla de exclusividad también permite\n" +"optimizaciones del compilador que pueden causar observaciones inconsistentes por parte del iterador\n" +"referencia compartida (por ejemplo, derrames de pilas o instrucciones de reordenación para mayor eficiencia).\n" +"Estas observaciones pueden ocurrir _en cualquier momento después de_ que se cree la referencia mutable." #: src\anti_patterns/index.md:1 #, fuzzy @@ -7469,25 +6293,18 @@ msgstr "# Anti-patrones" #: src\anti_patterns/index.md:3 #, fuzzy msgid "" -"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution " -"to\n" +"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution to\n" "a \"recurring problem that is usually ineffective and risks being highly\n" "counterproductive\". Just as valuable as knowing how to solve a problem, is\n" -"knowing how _not_ to solve it. Anti-patterns give us great counter-examples " -"to\n" -"consider relative to design patterns. Anti-patterns are not confined to " -"code.\n" +"knowing how _not_ to solve it. Anti-patterns give us great counter-examples to\n" +"consider relative to design patterns. Anti-patterns are not confined to code.\n" "For example, a process can be an anti-pattern, too." msgstr "" -"Un [antipatrón](https://en.wikipedia.org/wiki/Anti-pattern) es una solución " -"para\n" -"un \"problema recurrente que generalmente es ineficaz y corre el riesgo de " -"ser altamente\n" +"Un [antipatrón](https://en.wikipedia.org/wiki/Anti-pattern) es una solución para\n" +"un \"problema recurrente que generalmente es ineficaz y corre el riesgo de ser altamente\n" "contraproducente\". Tan valioso como saber cómo resolver un problema, es\n" -"saber cómo _no_ resolverlo. Los antipatrones nos dan grandes contraejemplos " -"para\n" -"considerar en relación con los patrones de diseño. Los antipatrones no se " -"limitan al código.\n" +"saber cómo _no_ resolverlo. Los antipatrones nos dan grandes contraejemplos para\n" +"considerar en relación con los patrones de diseño. Los antipatrones no se limitan al código.\n" "Por ejemplo, un proceso también puede ser un antipatrón." #: src\anti_patterns/borrow_clone.md:1 @@ -7498,24 +6315,16 @@ msgstr "# Clonar para satisfacer el verificador de préstamo" #: src\anti_patterns/borrow_clone.md:5 #, fuzzy msgid "" -"The borrow checker prevents Rust users from developing otherwise unsafe code " -"by\n" -"ensuring that either: only one mutable reference exists, or potentially many " -"but\n" -"all immutable references exist. If the code written does not hold true to " -"these\n" -"conditions, this anti-pattern arises when the developer resolves the " -"compiler\n" +"The borrow checker prevents Rust users from developing otherwise unsafe code by\n" +"ensuring that either: only one mutable reference exists, or potentially many but\n" +"all immutable references exist. If the code written does not hold true to these\n" +"conditions, this anti-pattern arises when the developer resolves the compiler\n" "error by cloning the variable." msgstr "" -"El verificador de préstamos evita que los usuarios de Rust desarrollen " -"código que de otro modo no sería seguro.\n" -"asegurando que: solo existe una referencia mutable, o potencialmente muchas " -"pero\n" -"todas las referencias inmutables existen. Si el código escrito no es fiel a " -"estos\n" -"condiciones, este antipatrón surge cuando el desarrollador resuelve el " -"compilador\n" +"El verificador de préstamos evita que los usuarios de Rust desarrollen código que de otro modo no sería seguro.\n" +"asegurando que: solo existe una referencia mutable, o potencialmente muchas pero\n" +"todas las referencias inmutables existen. Si el código escrito no es fiel a estos\n" +"condiciones, este antipatrón surge cuando el desarrollador resuelve el compilador\n" "error al clonar la variable." #: src\anti_patterns/borrow_clone.md:13 @@ -7527,8 +6336,7 @@ msgid "" "// Borrow `x` -- but clone it first\n" "let y = &mut (x.clone());\n" "\n" -"// without the x.clone() two lines prior, this line would fail on compile " -"as\n" +"// without the x.clone() two lines prior, this line would fail on compile as\n" "// x has been borrowed\n" "// thanks to x.clone(), x was never borrowed, and this line will run.\n" "println!(\"{}\", x);\n" @@ -7544,53 +6352,38 @@ msgstr "" msgid "" "It is tempting, particularly for beginners, to use this pattern to resolve\n" "confusing issues with the borrow checker. However, there are serious\n" -"consequences. Using `.clone()` causes a copy of the data to be made. Any " -"changes\n" -"between the two are not synchronized -- as if two completely separate " -"variables\n" +"consequences. Using `.clone()` causes a copy of the data to be made. Any changes\n" +"between the two are not synchronized -- as if two completely separate variables\n" "exist." msgstr "" -"Es tentador, especialmente para los principiantes, usar este patrón para " -"resolver\n" -"Problemas confusos con el verificador de préstamos. Sin embargo, existen " -"graves\n" -"consecuencias. El uso de `.clone()` hace que se haga una copia de los datos. " -"Algún cambio\n" -"entre los dos no están sincronizados, como si dos variables completamente " -"separadas\n" +"Es tentador, especialmente para los principiantes, usar este patrón para resolver\n" +"Problemas confusos con el verificador de préstamos. Sin embargo, existen graves\n" +"consecuencias. El uso de `.clone()` hace que se haga una copia de los datos. Algún cambio\n" +"entre los dos no están sincronizados, como si dos variables completamente separadas\n" "existir." #: src\anti_patterns/borrow_clone.md:38 #, fuzzy msgid "" -"There are special cases -- `Rc` is designed to handle clones " -"intelligently.\n" -"It internally manages exactly one copy of the data, and cloning it will " -"only\n" +"There are special cases -- `Rc` is designed to handle clones intelligently.\n" +"It internally manages exactly one copy of the data, and cloning it will only\n" "clone the reference." msgstr "" -"Hay casos especiales: `Rc` está diseñado para manejar clones de forma " -"inteligente.\n" -"Administra internamente exactamente una copia de los datos, y clonarlos " -"solo\n" +"Hay casos especiales: `Rc` está diseñado para manejar clones de forma inteligente.\n" +"Administra internamente exactamente una copia de los datos, y clonarlos solo\n" "clonar la referencia." #: src\anti_patterns/borrow_clone.md:42 #, fuzzy msgid "" "There is also `Arc` which provides shared ownership of a value of type T\n" -"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new " -"`Arc`\n" -"instance, which points to the same allocation on the heap as the source " -"`Arc`,\n" +"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new `Arc`\n" +"instance, which points to the same allocation on the heap as the source `Arc`,\n" "while increasing a reference count." msgstr "" -"También existe `Arc` que proporciona la propiedad compartida de un valor " -"de tipo T\n" -"que se asigna en el montón. Invocar `.clone()` en `Arc` produce un nuevo " -"`Arc`\n" -"instancia, que apunta a la misma asignación en el montón que la fuente " -"`Arc`,\n" +"También existe `Arc` que proporciona la propiedad compartida de un valor de tipo T\n" +"que se asigna en el montón. Invocar `.clone()` en `Arc` produce un nuevo `Arc`\n" +"instancia, que apunta a la misma asignación en el montón que la fuente `Arc`,\n" "mientras aumenta un recuento de referencia." #: src\anti_patterns/borrow_clone.md:47 @@ -7601,8 +6394,7 @@ msgid "" "that's a good indication this anti-pattern may be in use." msgstr "" "En general, los clones deben ser deliberados, con pleno conocimiento de los\n" -"consecuencias. Si se usa un clon para hacer que desaparezca un error del " -"comprobador de préstamo,\n" +"consecuencias. Si se usa un clon para hacer que desaparezca un error del comprobador de préstamo,\n" "esa es una buena indicación de que este antipatrón puede estar en uso." #: src\anti_patterns/borrow_clone.md:51 @@ -7626,62 +6418,46 @@ msgstr "" "- el desarrollador aún es nuevo en la propiedad\n" "- el código no tiene grandes limitaciones de velocidad o memoria\n" " (como proyectos de hackathon o prototipos)\n" -"- satisfacer el verificador de préstamos es realmente complicado, y " -"prefieres\n" +"- satisfacer el verificador de préstamos es realmente complicado, y prefieres\n" " optimizar la legibilidad sobre el rendimiento" #: src\anti_patterns/borrow_clone.md:60 #, fuzzy msgid "" -"If an unnecessary clone is suspected, The [Rust Book's chapter on " -"Ownership](https://doc.rust-lang.org/book/ownership.html)\n" -"should be understood fully before assessing whether the clone is required or " -"not." +"If an unnecessary clone is suspected, The [Rust Book's chapter on Ownership](https://doc.rust-lang.org/book/ownership.html)\n" +"should be understood fully before assessing whether the clone is required or not." msgstr "" -"Si se sospecha de un clon innecesario, el [capítulo de Rust Book sobre " -"propiedad] (https://doc.rust-lang.org/book/ownership.html)\n" +"Si se sospecha de un clon innecesario, el [capítulo de Rust Book sobre propiedad] (https://doc.rust-lang.org/book/ownership.html)\n" "debe entenderse completamente antes de evaluar si el clon es necesario o no." #: src\anti_patterns/borrow_clone.md:63 #, fuzzy msgid "" -"Also be sure to always run `cargo clippy` in your project, which will detect " -"some\n" -"cases in which `.clone()` is not necessary, like " -"[1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"Also be sure to always run `cargo clippy` in your project, which will detect some\n" +"cases in which `.clone()` is not necessary, like [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" "[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" -"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or " -"[4](https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref)." +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or [4](https://rust-lang.github.io/rust-clippy/master/index." +"html#clone_double_ref)." msgstr "" -"También asegúrese de ejecutar siempre `cargo clippy` en su proyecto, que " -"detectará algunos\n" -"casos en los que `.clone()` no es necesario, como " -"[1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"También asegúrese de ejecutar siempre `cargo clippy` en su proyecto, que detectará algunos\n" +"casos en los que `.clone()` no es necesario, como [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" "[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" -"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) o " -"[4](https://rust-lang.github.io/rust-clippy/master " -"/index.html#clone_double_ref)." +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) o [4](https://rust-lang.github.io/rust-clippy/master /index." +"html#clone_double_ref)." #: src\anti_patterns/borrow_clone.md:70 #, fuzzy msgid "" -"- [`mem::{take(_), replace(_)}` to keep owned values in changed " -"enums](../idioms/mem-replace.md)\n" -"- [`Rc` documentation, which handles .clone() " -"intelligently](http://doc.rust-lang.org/std/rc/)\n" -"- [`Arc` documentation, a thread-safe reference-counting " -"pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" -"- [Tricks with ownership in " -"Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" -msgstr "" -"- [`mem::{take(_), replace(_)}` para mantener los valores propios en las " -"enumeraciones modificadas](../idioms/mem-replace.md)\n" -"- [Documentación `Rc`, que maneja .clone() " -"inteligentemente](http://doc.rust-lang.org/std/rc/)\n" -"- [Documentación de `Arc`, un puntero de recuento de referencia seguro " -"para subprocesos] (https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" -"- [Trucos con propiedad en " -"Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +"- [`mem::{take(_), replace(_)}` to keep owned values in changed enums](../idioms/mem-replace.md)\n" +"- [`Rc` documentation, which handles .clone() intelligently](http://doc.rust-lang.org/std/rc/)\n" +"- [`Arc` documentation, a thread-safe reference-counting pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" +"- [Tricks with ownership in Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +msgstr "" +"- [`mem::{take(_), replace(_)}` para mantener los valores propios en las enumeraciones modificadas](../idioms/mem-replace.md)\n" +"- [Documentación `Rc`, que maneja .clone() inteligentemente](http://doc.rust-lang.org/std/rc/)\n" +"- [Documentación de `Arc`, un puntero de recuento de referencia seguro para subprocesos] (https://doc.rust-lang.org/std/sync/struct." +"Arc.html)\n" +"- [Trucos con propiedad en Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" #: src\anti_patterns/deny-warnings.md:1 #, fuzzy @@ -7694,8 +6470,7 @@ msgid "" "A well-intentioned crate author wants to ensure their code builds without\n" "warnings. So they annotate their crate root with the following:" msgstr "" -"Un autor de cajas bien intencionado quiere asegurarse de que su código se " -"construya sin\n" +"Un autor de cajas bien intencionado quiere asegurarse de que su código se construya sin\n" "advertencias Así que anotan su raíz de caja con lo siguiente:" #: src\anti_patterns/deny-warnings.md:10 @@ -7720,40 +6495,28 @@ msgstr "## Inconvenientes" #: src\anti_patterns/deny-warnings.md:22 #, fuzzy msgid "" -"By disallowing the compiler to build with warnings, a crate author opts out " -"of\n" -"Rust's famed stability. Sometimes new features or old misfeatures need a " -"change\n" -"in how things are done, thus lints are written that `warn` for a certain " -"grace\n" +"By disallowing the compiler to build with warnings, a crate author opts out of\n" +"Rust's famed stability. Sometimes new features or old misfeatures need a change\n" +"in how things are done, thus lints are written that `warn` for a certain grace\n" "period before being turned to `deny`." msgstr "" -"Al no permitir que el compilador construya con advertencias, el autor de un " -"cajón opta por no participar\n" -"La famosa estabilidad de Rust. A veces, las nuevas características o las " -"antiguas características incorrectas necesitan un cambio.\n" -"en cómo se hacen las cosas, así se escriben hilachas que `advierten` para " -"cierta gracia\n" +"Al no permitir que el compilador construya con advertencias, el autor de un cajón opta por no participar\n" +"La famosa estabilidad de Rust. A veces, las nuevas características o las antiguas características incorrectas necesitan un cambio.\n" +"en cómo se hacen las cosas, así se escriben hilachas que `advierten` para cierta gracia\n" "antes de pasar a `denegar`." #: src\anti_patterns/deny-warnings.md:27 #, fuzzy msgid "" -"For example, it was discovered that a type could have two `impl`s with the " -"same\n" -"method. This was deemed a bad idea, but in order to make the transition " -"smooth,\n" -"the `overlapping-inherent-impls` lint was introduced to give a warning to " -"those\n" +"For example, it was discovered that a type could have two `impl`s with the same\n" +"method. This was deemed a bad idea, but in order to make the transition smooth,\n" +"the `overlapping-inherent-impls` lint was introduced to give a warning to those\n" "stumbling on this fact, before it becomes a hard error in a future release." msgstr "" "Por ejemplo, se descubrió que un tipo podía tener dos `impl`s con el mismo\n" -"método. Esto se consideró una mala idea, pero para que la transición sea " -"fluida,\n" -"el lint `overlapping-inherent-impls` se introdujo para dar una advertencia a " -"aquellos\n" -"tropezando con este hecho, antes de que se convierta en un error grave en " -"una versión futura." +"método. Esto se consideró una mala idea, pero para que la transición sea fluida,\n" +"el lint `overlapping-inherent-impls` se introdujo para dar una advertencia a aquellos\n" +"tropezando con este hecho, antes de que se convierta en un error grave en una versión futura." #: src\anti_patterns/deny-warnings.md:32 #, fuzzy @@ -7761,37 +6524,28 @@ msgid "" "Also sometimes APIs get deprecated, so their use will emit a warning where\n" "before there was none." msgstr "" -"Además, a veces las API quedan obsoletas, por lo que su uso emitirá una " -"advertencia donde\n" +"Además, a veces las API quedan obsoletas, por lo que su uso emitirá una advertencia donde\n" "antes no había ninguno." #: src\anti_patterns/deny-warnings.md:35 #, fuzzy -msgid "" -"All this conspires to potentially break the build whenever something changes." -msgstr "" -"Todo esto conspira para potencialmente romper la compilación cada vez que " -"algo cambia." +msgid "All this conspires to potentially break the build whenever something changes." +msgstr "Todo esto conspira para potencialmente romper la compilación cada vez que algo cambia." #: src\anti_patterns/deny-warnings.md:37 #, fuzzy msgid "" -"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can " -"no\n" +"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can no\n" "longer be used unless the annotation is removed. This is mitigated with\n" -"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all " -"`deny`\n" +"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all `deny`\n" "lint errors into warnings." msgstr "" -"Además, las cajas que suministren pelusas adicionales (por ejemplo, " -"[rust-clippy]) no pueden\n" +"Además, las cajas que suministren pelusas adicionales (por ejemplo, [rust-clippy]) no pueden\n" "ya no se utilizará a menos que se elimine la anotación. Esto se mitiga con\n" -"[--cap-pelusas]. El argumento de la línea de comando `--cap-lints=warn` " -"convierte todo `deny`\n" +"[--cap-pelusas]. El argumento de la línea de comando `--cap-lints=warn` convierte todo `deny`\n" "lint errores en advertencias." -#: src\anti_patterns/deny-warnings.md:42 -#: src\functional/generics-type-classes.md:227 +#: src\anti_patterns/deny-warnings.md:42 src\functional/generics-type-classes.md:227 #, fuzzy msgid "## Alternatives" msgstr "## Alternativas" @@ -7799,23 +6553,18 @@ msgstr "## Alternativas" #: src\anti_patterns/deny-warnings.md:44 #, fuzzy msgid "" -"There are two ways of tackling this problem: First, we can decouple the " -"build\n" +"There are two ways of tackling this problem: First, we can decouple the build\n" "setting from the code, and second, we can name the lints we want to deny\n" "explicitly." msgstr "" -"Hay dos formas de abordar este problema: primero, podemos desacoplar la " -"compilación\n" -"configuración del código, y segundo, podemos nombrar las pelusas que " -"queremos denegar\n" +"Hay dos formas de abordar este problema: primero, podemos desacoplar la compilación\n" +"configuración del código, y segundo, podemos nombrar las pelusas que queremos denegar\n" "explícitamente." #: src\anti_patterns/deny-warnings.md:48 #, fuzzy msgid "The following command line will build with all warnings set to `deny`:" -msgstr "" -"La siguiente línea de comando se construirá con todas las advertencias " -"configuradas en \"denegar\":" +msgstr "La siguiente línea de comando se construirá con todas las advertencias configuradas en \"denegar\":" #: src\anti_patterns/deny-warnings.md:50 #, fuzzy @@ -7829,23 +6578,18 @@ msgid "" "Travis, but remember that this may break the build when something changes)\n" "without requiring a change to the code." msgstr "" -"Esto lo puede hacer cualquier desarrollador individual (o se puede " -"configurar en una herramienta de CI como\n" -"Travis, pero recuerda que esto puede romper la compilación cuando algo " -"cambia)\n" +"Esto lo puede hacer cualquier desarrollador individual (o se puede configurar en una herramienta de CI como\n" +"Travis, pero recuerda que esto puede romper la compilación cuando algo cambia)\n" "sin requerir un cambio en el código." #: src\anti_patterns/deny-warnings.md:56 #, fuzzy msgid "" "Alternatively, we can specify the lints that we want to `deny` in the code.\n" -"Here is a list of warning lints that is (hopefully) safe to deny (as of " -"Rustc 1.48.0):" +"Here is a list of warning lints that is (hopefully) safe to deny (as of Rustc 1.48.0):" msgstr "" -"Alternativamente, podemos especificar los lints que queremos `denegar` en el " -"código.\n" -"Aquí hay una lista de pelusas de advertencia que (con suerte) son seguras de " -"negar (a partir de Rustc 1.48.0):" +"Alternativamente, podemos especificar los lints que queremos `denegar` en el código.\n" +"Aquí hay una lista de pelusas de advertencia que (con suerte) son seguras de negar (a partir de Rustc 1.48.0):" #: src\anti_patterns/deny-warnings.md:59 msgid "" @@ -7872,9 +6616,7 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:78 #, fuzzy msgid "In addition, the following `allow`ed lints may be a good idea to `deny`:" -msgstr "" -"Además, las siguientes pelusas \"permitidas\" pueden ser una buena idea para " -"\"denegar\":" +msgstr "Además, las siguientes pelusas \"permitidas\" pueden ser una buena idea para \"denegar\":" #: src\anti_patterns/deny-warnings.md:80 msgid "" @@ -7893,9 +6635,7 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:91 #, fuzzy msgid "Some may also want to add `missing-copy-implementations` to their list." -msgstr "" -"Algunos también pueden querer agregar \"implementaciones de copias " -"faltantes\" a su lista." +msgstr "Algunos también pueden querer agregar \"implementaciones de copias faltantes\" a su lista." #: src\anti_patterns/deny-warnings.md:93 #, fuzzy @@ -7903,25 +6643,21 @@ msgid "" "Note that we explicitly did not add the `deprecated` lint, as it is fairly\n" "certain that there will be more deprecated APIs in the future." msgstr "" -"Tenga en cuenta que no agregamos explícitamente la pelusa `obsoleta`, ya que " -"es bastante\n" +"Tenga en cuenta que no agregamos explícitamente la pelusa `obsoleta`, ya que es bastante\n" "seguro de que habrá más API obsoletas en el futuro." #: src\anti_patterns/deny-warnings.md:98 #, fuzzy msgid "" -"- [A collection of all clippy " -"lints](https://rust-lang.github.io/rust-clippy/master)\n" +"- [A collection of all clippy lints](https://rust-lang.github.io/rust-clippy/master)\n" "- [deprecate attribute] documentation\n" "- Type `rustc -W help` for a list of lints on your system. Also type\n" " `rustc --help` for a general list of options\n" "- [rust-clippy] is a collection of lints for better Rust code" msgstr "" -"- [Una colección de todas las pelusas cortadas] " -"(https://rust-lang.github.io/rust-clippy/master)\n" +"- [Una colección de todas las pelusas cortadas] (https://rust-lang.github.io/rust-clippy/master)\n" "- Documentación de [atributo en desuso]\n" -"- Escriba `rustc -W help` para obtener una lista de pelusas en su sistema. " -"También escriba\n" +"- Escriba `rustc -W help` para obtener una lista de pelusas en su sistema. También escriba\n" " `rustc --help` para una lista general de opciones\n" "- [rust-clippy] es una colección de pelusas para mejorar el código de Rust" @@ -7933,19 +6669,16 @@ msgstr "# Polimorfismo `Deref`" #: src\anti_patterns/deref.md:5 #, fuzzy msgid "" -"Misuse the `Deref` trait to emulate inheritance between structs, and thus " -"reuse\n" +"Misuse the `Deref` trait to emulate inheritance between structs, and thus reuse\n" "methods." msgstr "" -"Usar incorrectamente el rasgo `Deref` para emular la herencia entre " -"estructuras y, por lo tanto, reutilizar\n" +"Usar incorrectamente el rasgo `Deref` para emular la herencia entre estructuras y, por lo tanto, reutilizar\n" "métodos." #: src\anti_patterns/deref.md:10 #, fuzzy msgid "" -"Sometimes we want to emulate the following common pattern from OO languages " -"such\n" +"Sometimes we want to emulate the following common pattern from OO languages such\n" "as Java:" msgstr "" "A veces queremos emular el siguiente patrón común de los lenguajes OO como\n" @@ -8006,49 +6739,33 @@ msgstr "" #: src\anti_patterns/deref.md:56 #, fuzzy msgid "" -"There is no struct inheritance in Rust. Instead we use composition and " -"include\n" -"an instance of `Foo` in `Bar` (since the field is a value, it is stored " -"inline,\n" -"so if there were fields, they would have the same layout in memory as the " -"Java\n" +"There is no struct inheritance in Rust. Instead we use composition and include\n" +"an instance of `Foo` in `Bar` (since the field is a value, it is stored inline,\n" +"so if there were fields, they would have the same layout in memory as the Java\n" "version (probably, you should use `#[repr(C)]` if you want to be sure))." msgstr "" -"No hay herencia de estructuras en Rust. En su lugar, usamos composición e " -"incluimos\n" -"una instancia de `Foo` en `Bar` (dado que el campo es un valor, se almacena " -"en línea,\n" -"entonces, si hubiera campos, tendrían el mismo diseño en la memoria que " -"Java\n" +"No hay herencia de estructuras en Rust. En su lugar, usamos composición e incluimos\n" +"una instancia de `Foo` en `Bar` (dado que el campo es un valor, se almacena en línea,\n" +"entonces, si hubiera campos, tendrían el mismo diseño en la memoria que Java\n" "versión (probablemente, debería usar `#[repr(C)]` si quiere estar seguro))." #: src\anti_patterns/deref.md:61 #, fuzzy msgid "" -"In order to make the method call work we implement `Deref` for `Bar` with " -"`Foo`\n" +"In order to make the method call work we implement `Deref` for `Bar` with `Foo`\n" "as the target (returning the embedded `Foo` field). That means that when we\n" -"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That " -"is\n" -"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, " -"here we\n" +"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That is\n" +"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, here we\n" "have two unrelated types. However, since the dot operator does implicit\n" -"dereferencing, it means that the method call will search for methods on " -"`Foo` as\n" +"dereferencing, it means that the method call will search for methods on `Foo` as\n" "well as `Bar`." msgstr "" -"Para hacer que la llamada al método funcione, implementamos `Deref` para " -"`Bar` con `Foo`\n" -"como objetivo (devolviendo el campo `Foo` incrustado). Eso significa que " -"cuando nosotros\n" -"desreferenciar una `Bar` (por ejemplo, usando `*`) entonces obtendremos un " -"`Foo`. Eso es\n" -"bastante raro. La desreferenciación generalmente da una `T` de una " -"referencia a `T`, aquí\n" -"tienen dos tipos no relacionados. Sin embargo, dado que el operador punto " -"hace implícito\n" -"desreferenciación, significa que la llamada al método buscará métodos en " -"`Foo` como\n" +"Para hacer que la llamada al método funcione, implementamos `Deref` para `Bar` con `Foo`\n" +"como objetivo (devolviendo el campo `Foo` incrustado). Eso significa que cuando nosotros\n" +"desreferenciar una `Bar` (por ejemplo, usando `*`) entonces obtendremos un `Foo`. Eso es\n" +"bastante raro. La desreferenciación generalmente da una `T` de una referencia a `T`, aquí\n" +"tienen dos tipos no relacionados. Sin embargo, dado que el operador punto hace implícito\n" +"desreferenciación, significa que la llamada al método buscará métodos en `Foo` como\n" "así como `Bar`." #: src\anti_patterns/deref.md:71 @@ -8070,136 +6787,97 @@ msgstr "" #: src\anti_patterns/deref.md:83 #, fuzzy msgid "" -"Most importantly this is a surprising idiom - future programmers reading " -"this in\n" -"code will not expect this to happen. That's because we are misusing the " -"`Deref`\n" -"trait rather than using it as intended (and documented, etc.). It's also " -"because\n" +"Most importantly this is a surprising idiom - future programmers reading this in\n" +"code will not expect this to happen. That's because we are misusing the `Deref`\n" +"trait rather than using it as intended (and documented, etc.). It's also because\n" "the mechanism here is completely implicit." msgstr "" -"Lo más importante es que este es un idioma sorprendente: los futuros " -"programadores que lean esto en\n" -"el código no esperará que esto suceda. Eso es porque estamos haciendo un mal " -"uso de `Deref`\n" -"rasgo en lugar de usarlo según lo previsto (y documentado, etc.). también es " -"porque\n" +"Lo más importante es que este es un idioma sorprendente: los futuros programadores que lean esto en\n" +"el código no esperará que esto suceda. Eso es porque estamos haciendo un mal uso de `Deref`\n" +"rasgo en lugar de usarlo según lo previsto (y documentado, etc.). también es porque\n" "el mecanismo aquí es completamente implícito." #: src\anti_patterns/deref.md:88 #, fuzzy msgid "" "This pattern does not introduce subtyping between `Foo` and `Bar` like\n" -"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` " -"are\n" -"not automatically implemented for `Bar`, so this pattern interacts badly " -"with\n" +"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` are\n" +"not automatically implemented for `Bar`, so this pattern interacts badly with\n" "bounds checking and thus generic programming." msgstr "" "Este patrón no introduce subtipos entre `Foo` y `Bar` como\n" -"la herencia en Java o C++ sí. Además, los rasgos implementados por `Foo` " -"son\n" -"no se implementa automáticamente para `Bar`, por lo que este patrón " -"interactúa mal con\n" +"la herencia en Java o C++ sí. Además, los rasgos implementados por `Foo` son\n" +"no se implementa automáticamente para `Bar`, por lo que este patrón interactúa mal con\n" "verificación de límites y, por lo tanto, programación genérica." #: src\anti_patterns/deref.md:93 #, fuzzy msgid "" -"Using this pattern gives subtly different semantics from most OO languages " -"with\n" -"regards to `self`. Usually it remains a reference to the sub-class, with " -"this\n" +"Using this pattern gives subtly different semantics from most OO languages with\n" +"regards to `self`. Usually it remains a reference to the sub-class, with this\n" "pattern it will be the 'class' where the method is defined." msgstr "" -"El uso de este patrón proporciona una semántica sutilmente diferente de la " -"mayoría de los lenguajes OO con\n" -"en lo que respecta a 'uno mismo'. Por lo general, sigue siendo una " -"referencia a la subclase, con esto\n" +"El uso de este patrón proporciona una semántica sutilmente diferente de la mayoría de los lenguajes OO con\n" +"en lo que respecta a 'uno mismo'. Por lo general, sigue siendo una referencia a la subclase, con esto\n" "patrón será la 'clase' donde se define el método." #: src\anti_patterns/deref.md:97 #, fuzzy msgid "" -"Finally, this pattern only supports single inheritance, and has no notion " -"of\n" -"interfaces, class-based privacy, or other inheritance-related features. So, " -"it\n" -"gives an experience that will be subtly surprising to programmers used to " -"Java\n" +"Finally, this pattern only supports single inheritance, and has no notion of\n" +"interfaces, class-based privacy, or other inheritance-related features. So, it\n" +"gives an experience that will be subtly surprising to programmers used to Java\n" "inheritance, etc." msgstr "" "Finalmente, este patrón solo admite herencia única y no tiene noción de\n" -"interfaces, privacidad basada en clases u otras características relacionadas " -"con la herencia. Por lo que\n" -"brinda una experiencia que sorprenderá sutilmente a los programadores " -"acostumbrados a Java\n" +"interfaces, privacidad basada en clases u otras características relacionadas con la herencia. Por lo que\n" +"brinda una experiencia que sorprenderá sutilmente a los programadores acostumbrados a Java\n" "herencia, etc" #: src\anti_patterns/deref.md:104 #, fuzzy msgid "" -"There is no one good alternative. Depending on the exact circumstances it " -"might\n" -"be better to re-implement using traits or to write out the facade methods " -"to\n" +"There is no one good alternative. Depending on the exact circumstances it might\n" +"be better to re-implement using traits or to write out the facade methods to\n" "dispatch to `Foo` manually. We do intend to add a mechanism for inheritance\n" "similar to this to Rust, but it is likely to be some time before it reaches\n" -"stable Rust. See these " -"[blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"stable Rust. See these [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" "[posts](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" -"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more " -"details." -msgstr "" -"No hay una buena alternativa. Dependiendo de las circunstancias exactas, " -"podría\n" -"sería mejor volver a implementar usando rasgos o escribir los métodos de " -"fachada para\n" -"enviar a `Foo` manualmente. Tenemos la intención de agregar un mecanismo " -"para la herencia.\n" -"similar a esto para Rust, pero es probable que pase algún tiempo antes de " -"que llegue\n" -"Roya estable. Ver estos " -"[blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" -"[publicaciones] " -"(http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" -"y este [problema de RFC] (https://github.com/rust-lang/rfcs/issues/349) para " -"obtener más detalles." +"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more details." +msgstr "" +"No hay una buena alternativa. Dependiendo de las circunstancias exactas, podría\n" +"sería mejor volver a implementar usando rasgos o escribir los métodos de fachada para\n" +"enviar a `Foo` manualmente. Tenemos la intención de agregar un mecanismo para la herencia.\n" +"similar a esto para Rust, pero es probable que pase algún tiempo antes de que llegue\n" +"Roya estable. Ver estos [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"[publicaciones] (http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" +"y este [problema de RFC] (https://github.com/rust-lang/rfcs/issues/349) para obtener más detalles." #: src\anti_patterns/deref.md:112 #, fuzzy msgid "" -"The `Deref` trait is designed for the implementation of custom pointer " -"types.\n" +"The `Deref` trait is designed for the implementation of custom pointer types.\n" "The intention is that it will take a pointer-to-`T` to a `T`, not convert\n" "between different types. It is a shame that this isn't (probably cannot be)\n" "enforced by the trait definition." msgstr "" -"El rasgo `Deref` está diseñado para la implementación de tipos de punteros " -"personalizados.\n" +"El rasgo `Deref` está diseñado para la implementación de tipos de punteros personalizados.\n" "La intención es que tomará un puntero a `T` a `T`, no convertir\n" -"entre diferentes tipos. Es una pena que esto no sea (probablemente no puede " -"ser)\n" +"entre diferentes tipos. Es una pena que esto no sea (probablemente no puede ser)\n" "reforzado por la definición de rasgo." #: src\anti_patterns/deref.md:117 #, fuzzy msgid "" -"Rust tries to strike a careful balance between explicit and implicit " -"mechanisms,\n" -"favouring explicit conversions between types. Automatic dereferencing in the " -"dot\n" -"operator is a case where the ergonomics strongly favour an implicit " -"mechanism,\n" +"Rust tries to strike a careful balance between explicit and implicit mechanisms,\n" +"favouring explicit conversions between types. Automatic dereferencing in the dot\n" +"operator is a case where the ergonomics strongly favour an implicit mechanism,\n" "but the intention is that this is limited to degrees of indirection, not\n" "conversion between arbitrary types." msgstr "" -"Rust intenta lograr un equilibrio cuidadoso entre los mecanismos explícitos " -"e implícitos,\n" -"favoreciendo conversiones explícitas entre tipos. Eliminación automática de " -"referencias en el punto\n" -"operador es un caso donde la ergonomía favorece fuertemente un mecanismo " -"implícito,\n" +"Rust intenta lograr un equilibrio cuidadoso entre los mecanismos explícitos e implícitos,\n" +"favoreciendo conversiones explícitas entre tipos. Eliminación automática de referencias en el punto\n" +"operador es un caso donde la ergonomía favorece fuertemente un mecanismo implícito,\n" "pero la intención es que esto se limite a grados de indirección, no\n" "conversión entre tipos arbitrarios." @@ -8207,19 +6885,14 @@ msgstr "" #, fuzzy msgid "" "- [Collections are smart pointers idiom](../idioms/deref.md).\n" -"- Delegation crates for less boilerplate like " -"[delegate](https://crates.io/crates/delegate)\n" +"- Delegation crates for less boilerplate like [delegate](https://crates.io/crates/delegate)\n" " or [ambassador](https://crates.io/crates/ambassador)\n" -"- [Documentation for `Deref` " -"trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." msgstr "" -"- [Las colecciones son modismos de punteros " -"inteligentes](../idioms/deref.md).\n" -"- Cajas de delegación para menos repetitivo como " -"[delegate](https://crates.io/crates/delegate)\n" +"- [Las colecciones son modismos de punteros inteligentes](../idioms/deref.md).\n" +"- Cajas de delegación para menos repetitivo como [delegate](https://crates.io/crates/delegate)\n" " o [embajador](https://crates.io/crates/ambassador)\n" -"- [Documentación para el rasgo " -"`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentación para el rasgo `Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." #: src\functional/index.md:1 #, fuzzy @@ -8230,31 +6903,24 @@ msgstr "# Uso funcional de Rust" #, fuzzy msgid "" "Rust is an imperative language, but it follows many\n" -"[functional " -"programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." +"[functional programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." msgstr "" "Rust es un lenguaje imperativo, pero sigue muchos\n" -"[programación " -"funcional](https://en.wikipedia.org/wiki/Functional_programming) paradigmas." +"[programación funcional](https://en.wikipedia.org/wiki/Functional_programming) paradigmas." #: src\functional/index.md:6 #, fuzzy msgid "" -"> In computer science, _functional programming_ is a programming paradigm " -"where\n" +"> In computer science, _functional programming_ is a programming paradigm where\n" "> programs are constructed by applying and composing functions.\n" -"> It is a declarative programming paradigm in which function definitions " -"are\n" +"> It is a declarative programming paradigm in which function definitions are\n" "> trees of expressions that each return a value, rather than a sequence of\n" "> imperative statements which change the state of the program." msgstr "" -"> En informática, la _programación funcional_ es un paradigma de " -"programación donde\n" +"> En informática, la _programación funcional_ es un paradigma de programación donde\n" "> los programas se construyen aplicando y componiendo funciones.\n" -"> Es un paradigma de programación declarativa en el que las definiciones de " -"funciones son\n" -"> árboles de expresiones que devuelven un valor, en lugar de una secuencia " -"de\n" +"> Es un paradigma de programación declarativa en el que las definiciones de funciones son\n" +"> árboles de expresiones que devuelven un valor, en lugar de una secuencia de\n" "> declaraciones imperativas que cambian el estado del programa." #: src\functional/paradigms.md:1 @@ -8270,12 +6936,9 @@ msgid "" "describe **how** to do something, whereas declarative programs describe\n" "**what** to do. Let's sum the numbers from 1 to 10 to show this." msgstr "" -"Uno de los mayores obstáculos para comprender los programas funcionales " -"cuando se trata de\n" -"desde un trasfondo imperativo es el cambio de pensamiento. programas " -"imperativos\n" -"describen **cómo** hacer algo, mientras que los programas declarativos " -"describen\n" +"Uno de los mayores obstáculos para comprender los programas funcionales cuando se trata de\n" +"desde un trasfondo imperativo es el cambio de pensamiento. programas imperativos\n" +"describen **cómo** hacer algo, mientras que los programas declarativos describen\n" "**qué hacer. Sumemos los números del 1 al 10 para mostrar esto." #: src\functional/paradigms.md:8 @@ -8297,19 +6960,16 @@ msgstr "" #: src\functional/paradigms.md:18 #, fuzzy msgid "" -"With imperative programs, we have to play compiler to see what is " -"happening.\n" +"With imperative programs, we have to play compiler to see what is happening.\n" "Here, we start with a `sum` of `0`.\n" "Next, we iterate through the range from 1 to 10.\n" "Each time through the loop, we add the corresponding value in the range.\n" "Then we print it out." msgstr "" -"Con los programas imperativos, tenemos que jugar al compilador para ver qué " -"está pasando.\n" +"Con los programas imperativos, tenemos que jugar al compilador para ver qué está pasando.\n" "Aquí, comenzamos con una `suma` de `0`.\n" "A continuación, iteramos a través del rango de 1 a 10.\n" -"Cada vez que recorremos el bucle, sumamos el valor correspondiente en el " -"rango.\n" +"Cada vez que recorremos el bucle, sumamos el valor correspondiente en el rango.\n" "Luego lo imprimimos." #: src\functional/paradigms.md:24 @@ -8344,12 +7004,10 @@ msgstr "" #: src\functional/paradigms.md:37 #, fuzzy msgid "" -"This is how most of us start out programming. We learn that a program is a " -"set\n" +"This is how most of us start out programming. We learn that a program is a set\n" "of steps." msgstr "" -"Así es como la mayoría de nosotros empezamos a programar. Aprendemos que un " -"programa es un conjunto\n" +"Así es como la mayoría de nosotros empezamos a programar. Aprendemos que un programa es un conjunto\n" "de pasos" #: src\functional/paradigms.md:40 @@ -8369,15 +7027,12 @@ msgstr "" msgid "" "Whoa! This is really different! What's going on here?\n" "Remember that with declarative programs we are describing **what** to do,\n" -"rather than **how** to do it. `fold` is a function that " -"[composes](https://en.wikipedia.org/wiki/Function_composition)\n" +"rather than **how** to do it. `fold` is a function that [composes](https://en.wikipedia.org/wiki/Function_composition)\n" "functions. The name is a convention from Haskell." msgstr "" "¡Guau! ¡Esto es realmente diferente! ¿Que está pasando aqui?\n" -"Recuerde que con los programas declarativos estamos describiendo **qué** " -"hacer,\n" -"en lugar de **cómo** hacerlo. `fold` es una función que [compone] " -"(https://en.wikipedia.org/wiki/Function_composition)\n" +"Recuerde que con los programas declarativos estamos describiendo **qué** hacer,\n" +"en lugar de **cómo** hacerlo. `fold` es una función que [compone] (https://en.wikipedia.org/wiki/Function_composition)\n" "funciones El nombre es una convención de Haskell." #: src\functional/paradigms.md:51 @@ -8385,23 +7040,16 @@ msgstr "" msgid "" "Here, we are composing functions of addition (this closure: `|a, b| a + b`)\n" "with a range from 1 to 10. The `0` is the starting point, so `a` is `0` at\n" -"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the " -"result.\n" -"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the " -"next\n" -"result. This process continues until we get to the last element in the " -"range,\n" +"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the result.\n" +"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the next\n" +"result. This process continues until we get to the last element in the range,\n" "`10`." msgstr "" "Aquí, estamos componiendo funciones de suma (este cierre: `|a, b| a + b`)\n" -"con un rango de 1 a 10. El `0` es el punto de partida, por lo que `a` es `0` " -"en\n" -"primero. `b` es el primer elemento del rango, `1`. `0 + 1 = 1` es el " -"resultado.\n" -"Así que ahora 'doblamos' de nuevo, con 'a = 1', 'b = 2' y así '1 + 2 = 3' es " -"el siguiente\n" -"resultado. Este proceso continúa hasta que llegamos al último elemento del " -"rango,\n" +"con un rango de 1 a 10. El `0` es el punto de partida, por lo que `a` es `0` en\n" +"primero. `b` es el primer elemento del rango, `1`. `0 + 1 = 1` es el resultado.\n" +"Así que ahora 'doblamos' de nuevo, con 'a = 1', 'b = 2' y así '1 + 2 = 3' es el siguiente\n" +"resultado. Este proceso continúa hasta que llegamos al último elemento del rango,\n" "`10`." #: src\functional/paradigms.md:58 @@ -8441,24 +7089,16 @@ msgstr "# Genéricos como clases de tipos" #: src\functional/generics-type-classes.md:5 #, fuzzy msgid "" -"Rust's type system is designed more like functional languages (like " -"Haskell)\n" -"rather than imperative languages (like Java and C++). As a result, Rust can " -"turn\n" -"many kinds of programming problems into \"static typing\" problems. This is " -"one\n" -"of the biggest wins of choosing a functional language, and is critical to " -"many\n" +"Rust's type system is designed more like functional languages (like Haskell)\n" +"rather than imperative languages (like Java and C++). As a result, Rust can turn\n" +"many kinds of programming problems into \"static typing\" problems. This is one\n" +"of the biggest wins of choosing a functional language, and is critical to many\n" "of Rust's compile time guarantees." msgstr "" -"El sistema de tipos de Rust está diseñado más como lenguajes funcionales " -"(como Haskell)\n" -"en lugar de lenguajes imperativos (como Java y C++). Como resultado, Rust " -"puede convertir\n" -"muchos tipos de problemas de programación en problemas de \"tipado " -"estático\". Este es uno\n" -"de las mayores ganancias de elegir un lenguaje funcional, y es fundamental " -"para muchos\n" +"El sistema de tipos de Rust está diseñado más como lenguajes funcionales (como Haskell)\n" +"en lugar de lenguajes imperativos (como Java y C++). Como resultado, Rust puede convertir\n" +"muchos tipos de problemas de programación en problemas de \"tipado estático\". Este es uno\n" +"de las mayores ganancias de elegir un lenguaje funcional, y es fundamental para muchos\n" "de las garantías de tiempo de compilación de Rust." #: src\functional/generics-type-classes.md:11 @@ -8466,141 +7106,104 @@ msgstr "" msgid "" "A key part of this idea is the way generic types work. In C++ and Java, for\n" "example, generic types are a meta-programming construct for the compiler.\n" -"`vector` and `vector` in C++ are just two different copies of " -"the\n" +"`vector` and `vector` in C++ are just two different copies of the\n" "same boilerplate code for a `vector` type (known as a `template`) with two\n" "different types filled in." msgstr "" -"Una parte clave de esta idea es la forma en que funcionan los tipos " -"genéricos. En C++ y Java, por\n" -"Por ejemplo, los tipos genéricos son una construcción de metaprogramación " -"para el compilador.\n" +"Una parte clave de esta idea es la forma en que funcionan los tipos genéricos. En C++ y Java, por\n" +"Por ejemplo, los tipos genéricos son una construcción de metaprogramación para el compilador.\n" "`vector` y `vector` en C++ son solo dos copias diferentes del\n" -"mismo código repetitivo para un tipo `vector` (conocido como `plantilla`) " -"con dos\n" +"mismo código repetitivo para un tipo `vector` (conocido como `plantilla`) con dos\n" "diferentes tipos rellenados." #: src\functional/generics-type-classes.md:17 #, fuzzy msgid "" -"In Rust, a generic type parameter creates what is known in functional " -"languages\n" -"as a \"type class constraint\", and each different parameter filled in by an " -"end\n" -"user _actually changes the type_. In other words, `Vec` and " -"`Vec`\n" -"_are two different types_, which are recognized as distinct by all parts of " -"the\n" +"In Rust, a generic type parameter creates what is known in functional languages\n" +"as a \"type class constraint\", and each different parameter filled in by an end\n" +"user _actually changes the type_. In other words, `Vec` and `Vec`\n" +"_are two different types_, which are recognized as distinct by all parts of the\n" "type system." msgstr "" -"En Rust, un parámetro de tipo genérico crea lo que se conoce en lenguajes " -"funcionales\n" -"como una \"restricción de clase de tipo\", y cada parámetro diferente " -"completado por un extremo\n" -"el usuario _realmente cambia el tipo_. En otras palabras, `Vec` y " -"`Vec`\n" -"_son dos tipos diferentes_, que son reconocidos como distintos por todas las " -"partes del\n" +"En Rust, un parámetro de tipo genérico crea lo que se conoce en lenguajes funcionales\n" +"como una \"restricción de clase de tipo\", y cada parámetro diferente completado por un extremo\n" +"el usuario _realmente cambia el tipo_. En otras palabras, `Vec` y `Vec`\n" +"_son dos tipos diferentes_, que son reconocidos como distintos por todas las partes del\n" "sistema de tipos." #: src\functional/generics-type-classes.md:23 #, fuzzy msgid "" "This is called **monomorphization**, where different types are created from\n" -"**polymorphic** code. This special behavior requires `impl` blocks to " -"specify\n" -"generic parameters. Different values for the generic type cause different " -"types,\n" +"**polymorphic** code. This special behavior requires `impl` blocks to specify\n" +"generic parameters. Different values for the generic type cause different types,\n" "and different types can have different `impl` blocks." msgstr "" -"Esto se llama **monomorfización**, donde se crean diferentes tipos a partir " -"de\n" -"Código **polimórfico**. Este comportamiento especial requiere bloques `impl` " -"para especificar\n" -"parámetros genéricos. Diferentes valores para el tipo genérico causan " -"diferentes tipos,\n" +"Esto se llama **monomorfización**, donde se crean diferentes tipos a partir de\n" +"Código **polimórfico**. Este comportamiento especial requiere bloques `impl` para especificar\n" +"parámetros genéricos. Diferentes valores para el tipo genérico causan diferentes tipos,\n" "y diferentes tipos pueden tener diferentes bloques `impl`." #: src\functional/generics-type-classes.md:28 #, fuzzy msgid "" -"In object-oriented languages, classes can inherit behavior from their " -"parents.\n" +"In object-oriented languages, classes can inherit behavior from their parents.\n" "However, this allows the attachment of not only additional behavior to\n" "particular members of a type class, but extra behavior as well." msgstr "" -"En los lenguajes orientados a objetos, las clases pueden heredar el " -"comportamiento de sus padres.\n" +"En los lenguajes orientados a objetos, las clases pueden heredar el comportamiento de sus padres.\n" "Sin embargo, esto permite adjuntar no sólo un comportamiento adicional a\n" -"miembros particulares de una clase de tipo, pero también comportamiento " -"adicional." +"miembros particulares de una clase de tipo, pero también comportamiento adicional." #: src\functional/generics-type-classes.md:32 #, fuzzy msgid "" -"The nearest equivalent is the runtime polymorphism in Javascript and " -"Python,\n" +"The nearest equivalent is the runtime polymorphism in Javascript and Python,\n" "where new members can be added to objects willy-nilly by any constructor.\n" -"However, unlike those languages, all of Rust's additional methods can be " -"type\n" -"checked when they are used, because their generics are statically defined. " -"That\n" +"However, unlike those languages, all of Rust's additional methods can be type\n" +"checked when they are used, because their generics are statically defined. That\n" "makes them more usable while remaining safe." msgstr "" -"El equivalente más cercano es el polimorfismo en tiempo de ejecución en " -"Javascript y Python,\n" -"donde cualquier constructor puede agregar nuevos miembros a los objetos de " -"cualquier manera.\n" -"Sin embargo, a diferencia de esos lenguajes, todos los métodos adicionales " -"de Rust se pueden escribir\n" -"verificados cuando se usan, porque sus genéricos están definidos " -"estáticamente. Eso\n" +"El equivalente más cercano es el polimorfismo en tiempo de ejecución en Javascript y Python,\n" +"donde cualquier constructor puede agregar nuevos miembros a los objetos de cualquier manera.\n" +"Sin embargo, a diferencia de esos lenguajes, todos los métodos adicionales de Rust se pueden escribir\n" +"verificados cuando se usan, porque sus genéricos están definidos estáticamente. Eso\n" "los hace más utilizables sin dejar de ser seguros." #: src\functional/generics-type-classes.md:40 #, fuzzy msgid "" "Suppose you are designing a storage server for a series of lab machines.\n" -"Because of the software involved, there are two different protocols you " -"need\n" +"Because of the software involved, there are two different protocols you need\n" "to support: BOOTP (for PXE network boot), and NFS (for remote mount storage)." msgstr "" -"Suponga que está diseñando un servidor de almacenamiento para una serie de " -"máquinas de laboratorio.\n" +"Suponga que está diseñando un servidor de almacenamiento para una serie de máquinas de laboratorio.\n" "Debido al software involucrado, hay dos protocolos diferentes que necesita\n" -"para admitir: BOOTP (para arranque de red PXE) y NFS (para almacenamiento de " -"montaje remoto)." +"para admitir: BOOTP (para arranque de red PXE) y NFS (para almacenamiento de montaje remoto)." #: src\functional/generics-type-classes.md:44 #, fuzzy msgid "" "Your goal is to have one program, written in Rust, which can handle both of\n" -"them. It will have protocol handlers and listen for both kinds of requests. " -"The\n" -"main application logic will then allow a lab administrator to configure " -"storage\n" +"them. It will have protocol handlers and listen for both kinds of requests. The\n" +"main application logic will then allow a lab administrator to configure storage\n" "and security controls for the actual files." msgstr "" "Su objetivo es tener un programa, escrito en Rust, que pueda manejar ambos\n" -"a ellos. Tendrá controladores de protocolo y escuchará ambos tipos de " -"solicitudes. El\n" -"La lógica de la aplicación principal permitirá que un administrador de " -"laboratorio configure el almacenamiento\n" +"a ellos. Tendrá controladores de protocolo y escuchará ambos tipos de solicitudes. El\n" +"La lógica de la aplicación principal permitirá que un administrador de laboratorio configure el almacenamiento\n" "y controles de seguridad para los archivos reales." #: src\functional/generics-type-classes.md:49 #, fuzzy msgid "" "The requests from machines in the lab for files contain the same basic\n" -"information, no matter what protocol they came from: an authentication " -"method,\n" +"information, no matter what protocol they came from: an authentication method,\n" "and a file name to retrieve. A straightforward implementation would look\n" "something like this:" msgstr "" -"Las solicitudes de archivos de las máquinas en el laboratorio contienen el " -"mismo\n" -"información, sin importar de qué protocolo provengan: un método de " -"autenticación,\n" +"Las solicitudes de archivos de las máquinas en el laboratorio contienen el mismo\n" +"información, sin importar de qué protocolo provengan: un método de autenticación,\n" "y un nombre de archivo para recuperar. Una implementación sencilla se vería\n" "algo como esto:" @@ -8624,14 +7227,11 @@ msgstr "" msgid "" "This design might work well enough. But now suppose you needed to support\n" "adding metadata that was _protocol specific_. For example, with NFS, you\n" -"wanted to determine what their mount point was in order to enforce " -"additional\n" +"wanted to determine what their mount point was in order to enforce additional\n" "security rules." msgstr "" -"Este diseño podría funcionar lo suficientemente bien. Pero ahora supongamos " -"que necesita apoyo\n" -"agregando metadatos que eran _específicos del protocolo_. Por ejemplo, con " -"NFS, usted\n" +"Este diseño podría funcionar lo suficientemente bien. Pero ahora supongamos que necesita apoyo\n" +"agregando metadatos que eran _específicos del protocolo_. Por ejemplo, con NFS, usted\n" "quería determinar cuál era su punto de montaje para hacer cumplir\n" "reglas de seguridad" @@ -8639,14 +7239,11 @@ msgstr "" #, fuzzy msgid "" "The way the current struct is designed leaves the protocol decision until\n" -"runtime. That means any method that applies to one protocol and not the " -"other\n" +"runtime. That means any method that applies to one protocol and not the other\n" "requires the programmer to do a runtime check." msgstr "" -"La forma en que está diseñada la estructura actual deja la decisión del " -"protocolo hasta\n" -"tiempo de ejecución Eso significa cualquier método que se aplique a un " -"protocolo y no al otro.\n" +"La forma en que está diseñada la estructura actual deja la decisión del protocolo hasta\n" +"tiempo de ejecución Eso significa cualquier método que se aplique a un protocolo y no al otro.\n" "requiere que el programador haga una verificación de tiempo de ejecución." #: src\functional/generics-type-classes.md:75 @@ -8678,16 +7275,12 @@ msgstr "" #: src\functional/generics-type-classes.md:95 #, fuzzy msgid "" -"Every caller of `mount_point()` must check for `None` and write code to " -"handle\n" -"it. This is true even if they know only NFS requests are ever used in a " -"given\n" +"Every caller of `mount_point()` must check for `None` and write code to handle\n" +"it. This is true even if they know only NFS requests are ever used in a given\n" "code path!" msgstr "" -"Cada llamador de `mount_point()` debe buscar `Ninguno` y escribir código " -"para manejar\n" -"él. Esto es cierto incluso si saben que solo se usan solicitudes NFS en un " -"determinado\n" +"Cada llamador de `mount_point()` debe buscar `Ninguno` y escribir código para manejar\n" +"él. Esto es cierto incluso si saben que solo se usan solicitudes NFS en un determinado\n" "ruta de código!" #: src\functional/generics-type-classes.md:99 @@ -8695,27 +7288,21 @@ msgstr "" msgid "" "It would be far more optimal to cause a compile-time error if the different\n" "request types were confused. After all, the entire path of the user's code,\n" -"including what functions from the library they use, will know whether a " -"request\n" +"including what functions from the library they use, will know whether a request\n" "is an NFS request or a BOOTP request." msgstr "" -"Sería mucho más óptimo causar un error en tiempo de compilación si los " -"diferentes\n" -"los tipos de solicitud estaban confundidos. Después de todo, la ruta " -"completa del código del usuario,\n" -"incluidas las funciones de la biblioteca que utilizan, sabrán si una " -"solicitud\n" +"Sería mucho más óptimo causar un error en tiempo de compilación si los diferentes\n" +"los tipos de solicitud estaban confundidos. Después de todo, la ruta completa del código del usuario,\n" +"incluidas las funciones de la biblioteca que utilizan, sabrán si una solicitud\n" "es una solicitud NFS o una solicitud BOOTP." #: src\functional/generics-type-classes.md:104 #, fuzzy msgid "" -"In Rust, this is actually possible! The solution is to _add a generic type_ " -"in\n" +"In Rust, this is actually possible! The solution is to _add a generic type_ in\n" "order to split the API." msgstr "" -"¡En Rust, esto es realmente posible! La solución es _agregar un tipo " -"genérico_ en\n" +"¡En Rust, esto es realmente posible! La solución es _agregar un tipo genérico_ en\n" "para dividir la API." #: src\functional/generics-type-classes.md:107 @@ -8832,63 +7419,47 @@ msgstr "" #: src\functional/generics-type-classes.md:206 #, fuzzy msgid "" -"They would get a syntax error. The type `FileDownloadRequest` does " -"not\n" -"implement `mount_point()`, only the type `FileDownloadRequest` does. " -"And\n" +"They would get a syntax error. The type `FileDownloadRequest` does not\n" +"implement `mount_point()`, only the type `FileDownloadRequest` does. And\n" "that is created by the NFS module, not the BOOTP module of course!" msgstr "" "Obtendrían un error de sintaxis. El tipo `FileDownloadRequest` no\n" -"implementa `mount_point()`, solo lo hace el tipo `FileDownloadRequest`. " -"Y\n" +"implementa `mount_point()`, solo lo hace el tipo `FileDownloadRequest`. Y\n" "eso lo crea el módulo NFS, ¡no el módulo BOOTP, por supuesto!" #: src\functional/generics-type-classes.md:212 #, fuzzy msgid "" -"First, it allows fields that are common to multiple states to be " -"de-duplicated.\n" +"First, it allows fields that are common to multiple states to be de-duplicated.\n" "By making the non-shared fields generic, they are implemented once." msgstr "" -"En primer lugar, permite eliminar la duplicación de campos que son comunes a " -"varios estados.\n" -"Al hacer que los campos no compartidos sean genéricos, se implementan una " -"vez." +"En primer lugar, permite eliminar la duplicación de campos que son comunes a varios estados.\n" +"Al hacer que los campos no compartidos sean genéricos, se implementan una vez." #: src\functional/generics-type-classes.md:215 #, fuzzy msgid "" -"Second, it makes the `impl` blocks easier to read, because they are broken " -"down\n" -"by state. Methods common to all states are typed once in one block, and " -"methods\n" +"Second, it makes the `impl` blocks easier to read, because they are broken down\n" +"by state. Methods common to all states are typed once in one block, and methods\n" "unique to one state are in a separate block." msgstr "" -"En segundo lugar, hace que los bloques `impl` sean más fáciles de leer, " -"porque están desglosados\n" -"por estado Los métodos comunes a todos los estados se escriben una vez en un " -"bloque y los métodos\n" +"En segundo lugar, hace que los bloques `impl` sean más fáciles de leer, porque están desglosados\n" +"por estado Los métodos comunes a todos los estados se escriben una vez en un bloque y los métodos\n" "exclusivos de un estado están en un bloque separado." #: src\functional/generics-type-classes.md:219 #, fuzzy -msgid "" -"Both of these mean there are fewer lines of code, and they are better " -"organized." -msgstr "" -"Ambos significan que hay menos líneas de código y están mejor organizados." +msgid "Both of these mean there are fewer lines of code, and they are better organized." +msgstr "Ambos significan que hay menos líneas de código y están mejor organizados." #: src\functional/generics-type-classes.md:223 #, fuzzy msgid "" -"This currently increases the size of the binary, due to the way " -"monomorphization\n" -"is implemented in the compiler. Hopefully the implementation will be able " -"to\n" +"This currently increases the size of the binary, due to the way monomorphization\n" +"is implemented in the compiler. Hopefully the implementation will be able to\n" "improve in the future." msgstr "" -"Esto actualmente aumenta el tamaño del binario, debido a la forma en que se " -"monomorfiza.\n" +"Esto actualmente aumenta el tamaño del binario, debido a la forma en que se monomorfiza.\n" "se implementa en el compilador. Esperemos que la implementación pueda\n" "mejorar en el futuro." @@ -8899,20 +7470,16 @@ msgid "" " initialization, consider the\n" " [Builder Pattern](../patterns/creational/builder.md) instead.\n" "\n" -"- If the API between types does not change -- only the behavior does -- " -"then\n" -" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better " -"used\n" +"- If the API between types does not change -- only the behavior does -- then\n" +" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better used\n" " instead." msgstr "" -"- Si un tipo parece necesitar una \"API dividida\" debido a la construcción " -"o parcial\n" +"- Si un tipo parece necesitar una \"API dividida\" debido a la construcción o parcial\n" " inicialización, considere la\n" " [Patrón de constructor] (../patterns/creational/builder.md) en su lugar.\n" "\n" "- Si la API entre tipos no cambia, solo cambia el comportamiento, entonces\n" -" el [Patrón de estrategia] (../patterns/behavioural/strategy.md) se usa " -"mejor\n" +" el [Patrón de estrategia] (../patterns/behavioural/strategy.md) se usa mejor\n" " en cambio." #: src\functional/generics-type-classes.md:239 @@ -8923,108 +7490,79 @@ msgstr "Este patrón se utiliza en toda la biblioteca estándar:" #: src\functional/generics-type-classes.md:241 #, fuzzy msgid "" -"- `Vec` can be cast from a String, unlike every other type of " -"`Vec`.[^1]\n" +"- `Vec` can be cast from a String, unlike every other type of `Vec`.[^1]\n" "- They can also be cast into a binary heap, but only if they contain a type\n" " that implements the `Ord` trait.[^2]\n" "- The `to_string` method was specialized for `Cow` only of type `str`.[^3]" msgstr "" -"- `Vec` se puede convertir desde una cadena, a diferencia de cualquier " -"otro tipo de `Vec`.[^1]\n" -"- También se pueden convertir en un montón binario, pero solo si contienen " -"un tipo\n" +"- `Vec` se puede convertir desde una cadena, a diferencia de cualquier otro tipo de `Vec`.[^1]\n" +"- También se pueden convertir en un montón binario, pero solo si contienen un tipo\n" " que implementa el rasgo `Ord`.[^2]\n" "- El método `to_string` se especializó para `Vaca` solo del tipo `str`.[^3]" #: src\functional/generics-type-classes.md:246 #, fuzzy msgid "It is also used by several popular crates to allow API flexibility:" -msgstr "" -"También lo utilizan varias cajas populares para permitir la flexibilidad de " -"la API:" +msgstr "También lo utilizan varias cajas populares para permitir la flexibilidad de la API:" #: src\functional/generics-type-classes.md:248 #, fuzzy msgid "" -"- The `embedded-hal` ecosystem used for embedded devices makes extensive use " -"of\n" -" this pattern. For example, it allows statically verifying the " -"configuration of\n" -" device registers used to control embedded pins. When a pin is put into a " -"mode,\n" +"- The `embedded-hal` ecosystem used for embedded devices makes extensive use of\n" +" this pattern. For example, it allows statically verifying the configuration of\n" +" device registers used to control embedded pins. When a pin is put into a mode,\n" " it returns a `Pin` struct, whose generic determines the functions\n" " usable in that mode, which are not on the `Pin` itself. [^4]\n" "\n" -"- The `hyper` HTTP client library uses this to expose rich APIs for " -"different\n" -" pluggable requests. Clients with different connectors have different " -"methods\n" +"- The `hyper` HTTP client library uses this to expose rich APIs for different\n" +" pluggable requests. Clients with different connectors have different methods\n" " on them as well as different trait implementations, while a core set of\n" " methods apply to any connector. [^5]\n" "\n" -"- The \"type state\" pattern -- where an object gains and loses API based on " -"an\n" -" internal state or invariant -- is implemented in Rust using the same " -"basic\n" +"- The \"type state\" pattern -- where an object gains and loses API based on an\n" +" internal state or invariant -- is implemented in Rust using the same basic\n" " concept, and a slightly different technique. [^6]" msgstr "" -"- El ecosistema `embedded-hal` utilizado para dispositivos integrados hace " -"un uso extensivo de\n" -" este patrón Por ejemplo, permite verificar estáticamente la configuración " -"de\n" -" registros de dispositivos utilizados para controlar pines incrustados. " -"Cuando un pin se pone en un modo,\n" -" devuelve una estructura `Pin`, cuyo genérico determina las " -"funciones\n" +"- El ecosistema `embedded-hal` utilizado para dispositivos integrados hace un uso extensivo de\n" +" este patrón Por ejemplo, permite verificar estáticamente la configuración de\n" +" registros de dispositivos utilizados para controlar pines incrustados. Cuando un pin se pone en un modo,\n" +" devuelve una estructura `Pin`, cuyo genérico determina las funciones\n" " utilizables en ese modo, que no están en el propio `Pin`. [^4]\n" "\n" -"- La biblioteca de cliente HTTP 'hiper' usa esto para exponer API " -"enriquecidas para diferentes\n" -" solicitudes conectables. Los clientes con diferentes conectores tienen " -"diferentes métodos\n" -" en ellos, así como diferentes implementaciones de rasgos, mientras que un " -"conjunto básico de\n" +"- La biblioteca de cliente HTTP 'hiper' usa esto para exponer API enriquecidas para diferentes\n" +" solicitudes conectables. Los clientes con diferentes conectores tienen diferentes métodos\n" +" en ellos, así como diferentes implementaciones de rasgos, mientras que un conjunto básico de\n" " Los métodos se aplican a cualquier conector. [^5]\n" "\n" -"- El patrón de \"estado de tipo\", donde un objeto gana y pierde API en " -"función de un\n" +"- El patrón de \"estado de tipo\", donde un objeto gana y pierde API en función de un\n" " estado interno o invariante: se implementa en Rust utilizando el mismo\n" " concepto, y una técnica ligeramente diferente. [^6]" #: src\functional/generics-type-classes.md:263 #, fuzzy -msgid "" -"See: [impl From\\ for " -"Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" -msgstr "" -"Ver: [impl From\\ for " -"Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 " -")" +msgid "See: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" +msgstr "Ver: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 )" #: src\functional/generics-type-classes.md:265 #, fuzzy msgid "" -"See: [impl\\ From\\\\> for " -"BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/binary_heap.rs.html#1345-1354)" +"See: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/" +"binary_heap.rs.html#1345-1354)" msgstr "" -"Ver: [impl\\ From\\\\> for " -"BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections " -"/binary_heap.rs.html#1345-1354)" +"Ver: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections /" +"binary_heap.rs.html#1345-1354)" #: src\functional/generics-type-classes.md:267 #, fuzzy -msgid "" -"See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, " -"str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" -msgstr "" -"Consulte: [impl\\<'\\_\\> ToString for Cow\\<'\\_, " -"str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" +msgid "See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" +msgstr "Consulte: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" #: src\functional/generics-type-classes.md:269 #, fuzzy msgid "" "Example:\n" -"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html)" +"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/" +"gpioa/struct.PA0.html)" msgstr "" "Ejemplo:\n" "[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/ " @@ -9043,20 +7581,18 @@ msgstr "" #, fuzzy msgid "" "See:\n" -"[The Case for the Type State " -"Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate-pattern-the-typestate-pattern-itself/)\n" +"[The Case for the Type State Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-" +"typestate-pattern-the-typestate-pattern-itself/)\n" "and\n" -"[Rusty Typestate Series (an extensive " -"thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-typestate-series/rust-typestate-index)" +"[Rusty Typestate Series (an extensive thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index)" msgstr "" "Ver:\n" -"[El caso del patrón de estado " -"tipo](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate- " -"patrón-el-tipo-estado-patrón-en-sí/)\n" +"[El caso del patrón de estado tipo](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-" +"typestate- patrón-el-tipo-estado-patrón-en-sí/)\n" "y\n" -"[Serie Rusty Typestate (una tesis " -"extensa)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-typestate-series/rust-typestate-index " -")" +"[Serie Rusty Typestate (una tesis extensa)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index )" #: src\functional/lenses.md:1 #, fuzzy @@ -9068,14 +7604,12 @@ msgstr "# Lentes y Prismas" msgid "" "This is a pure functional concept that is not frequently used in Rust.\n" "Nevertheless, exploring the concept may be helpful to understand other\n" -"patterns in Rust APIs, such as " -"[visitors](../patterns/behavioural/visitor.md).\n" +"patterns in Rust APIs, such as [visitors](../patterns/behavioural/visitor.md).\n" "They also have niche use cases." msgstr "" "Este es un concepto funcional puro que no se usa con frecuencia en Rust.\n" "Sin embargo, explorar el concepto puede ser útil para entender otros\n" -"patrones en las API de Rust, como [visitantes] " -"(../patterns/behavioural/visitor.md).\n" +"patrones en las API de Rust, como [visitantes] (../patterns/behavioural/visitor.md).\n" "También tienen casos de uso de nicho." #: src\functional/lenses.md:8 @@ -9088,15 +7622,12 @@ msgstr "## Lentes: acceso uniforme en todos los tipos" msgid "" "A lens is a concept from functional programming languages that allows\n" "accessing parts of a data type in an abstract, unified way.[^1]\n" -"In basic concept, it is similar to the way Rust traits work with type " -"erasure,\n" +"In basic concept, it is similar to the way Rust traits work with type erasure,\n" "but it has a bit more power and flexibility." msgstr "" -"Una lente es un concepto de los lenguajes de programación funcional que " -"permite\n" +"Una lente es un concepto de los lenguajes de programación funcional que permite\n" "acceder a partes de un tipo de datos de forma abstracta y unificada.[^1]\n" -"En concepto básico, es similar a la forma en que los rasgos de Rust " -"funcionan con el borrado de tipos,\n" +"En concepto básico, es similar a la forma en que los rasgos de Rust funcionan con el borrado de tipos,\n" "pero tiene un poco más de potencia y flexibilidad." #: src\functional/lenses.md:15 @@ -9107,13 +7638,10 @@ msgid "" "This is because they come from different databases or legacy systems.\n" "One database contains the data needed to perform credit checks:" msgstr "" -"Por ejemplo, suponga que un banco contiene varios formatos JSON para " -"clientes\n" +"Por ejemplo, suponga que un banco contiene varios formatos JSON para clientes\n" "datos.\n" -"Esto se debe a que provienen de diferentes bases de datos o sistemas " -"heredados.\n" -"Una base de datos contiene los datos necesarios para realizar verificaciones " -"de crédito:" +"Esto se debe a que provienen de diferentes bases de datos o sistemas heredados.\n" +"Una base de datos contiene los datos necesarios para realizar verificaciones de crédito:" #: src\functional/lenses.md:20 msgid "" @@ -9154,23 +7682,19 @@ msgstr "" #: src\functional/lenses.md:47 #, fuzzy msgid "" -"Notice that both types have a customer ID number which corresponds to a " -"person.\n" +"Notice that both types have a customer ID number which corresponds to a person.\n" "How would a single function handle both records of different types?" msgstr "" -"Tenga en cuenta que ambos tipos tienen un número de identificación de " -"cliente que corresponde a una persona.\n" +"Tenga en cuenta que ambos tipos tienen un número de identificación de cliente que corresponde a una persona.\n" "¿Cómo manejaría una sola función ambos registros de diferentes tipos?" #: src\functional/lenses.md:50 #, fuzzy msgid "" -"In Rust, a `struct` could represent each of these types, and a trait would " -"have\n" +"In Rust, a `struct` could represent each of these types, and a trait would have\n" "a `get_customer_id` function they would implement:" msgstr "" -"En Rust, una `estructura` podría representar cada uno de estos tipos, y un " -"rasgo tendría\n" +"En Rust, una `estructura` podría representar cada uno de estos tipos, y un rasgo tendría\n" "una función `get_customer_id` que implementarían:" #: src\functional/lenses.md:53 @@ -9217,8 +7741,7 @@ msgid "" " records.iter().map(|r| r.get_customer_id()).collect()\n" "}\n" "\n" -"// dynamic dispatch: iterates over any type with a customer ID, collecting " -"all\n" +"// dynamic dispatch: iterates over any type with a customer ID, collecting all\n" "// values together\n" "fn unique_ids_iter(iterator: I) -> HashSet\n" " where I: Iterator>\n" @@ -9236,27 +7759,20 @@ msgid "" "Rather than implementing a trait on each type, all matching structures can\n" "simply be accessed the same way." msgstr "" -"Sin embargo, las lentes permiten que el código que respalda la " -"identificación del cliente se mueva de la\n" +"Sin embargo, las lentes permiten que el código que respalda la identificación del cliente se mueva de la\n" "_type_ a la _función de acceso_.\n" -"En lugar de implementar un rasgo en cada tipo, todas las estructuras " -"coincidentes pueden\n" +"En lugar de implementar un rasgo en cada tipo, todas las estructuras coincidentes pueden\n" "simplemente se puede acceder de la misma manera." #: src\functional/lenses.md:109 #, fuzzy msgid "" "While the Rust language itself does not support this (type erasure is the\n" -"preferred solution to this problem), the [lens-rs " -"crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows " -"code\n" +"preferred solution to this problem), the [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows code\n" "that feels like this to be written with macros:" msgstr "" -"Si bien el lenguaje Rust en sí mismo no admite esto (el borrado de tipo es " -"el\n" -"solución preferida para este problema), [lens-rs " -"crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) permite " -"código\n" +"Si bien el lenguaje Rust en sí mismo no admite esto (el borrado de tipo es el\n" +"solución preferida para este problema), [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) permite código\n" "que se siente así para ser escrito con macros:" #: src\functional/lenses.md:113 @@ -9301,42 +7817,32 @@ msgstr "" #: src\functional/lenses.md:149 #, fuzzy msgid "" -"The version of `unique_ids_lens` shown here allows any type to be in the " -"iterator,\n" -"so long as it has an attribute called `customer_id` which can be accessed " -"by\n" +"The version of `unique_ids_lens` shown here allows any type to be in the iterator,\n" +"so long as it has an attribute called `customer_id` which can be accessed by\n" "the function.\n" "This is how most functional programming languages operate on lenses." msgstr "" -"La versión de `unique_ids_lens` que se muestra aquí permite que cualquier " -"tipo esté en el iterador,\n" -"siempre que tenga un atributo llamado `customer_id` al que se pueda acceder " -"mediante\n" +"La versión de `unique_ids_lens` que se muestra aquí permite que cualquier tipo esté en el iterador,\n" +"siempre que tenga un atributo llamado `customer_id` al que se pueda acceder mediante\n" "la función.\n" -"Así es como la mayoría de los lenguajes de programación funcionales operan " -"en lentes." +"Así es como la mayoría de los lenguajes de programación funcionales operan en lentes." #: src\functional/lenses.md:154 #, fuzzy msgid "" -"Rather than macros, they achieve this with a technique known as " -"\"currying\".\n" +"Rather than macros, they achieve this with a technique known as \"currying\".\n" "That is, they \"partially construct\" the function, leaving the type of the\n" -"final parameter (the value being operated on) unfilled until the function " -"is\n" +"final parameter (the value being operated on) unfilled until the function is\n" "called.\n" -"Thus it can be called with different types dynamically even from one place " -"in\n" +"Thus it can be called with different types dynamically even from one place in\n" "the code.\n" "That is what the `optics!` and `view_ref` in the example above simulates." msgstr "" "En lugar de macros, lo logran con una técnica conocida como \"curring\".\n" "Es decir, \"construyen parcialmente\" la función, dejando el tipo de la\n" -"parámetro final (el valor que se está operando) sin completar hasta que la " -"función es\n" +"parámetro final (el valor que se está operando) sin completar hasta que la función es\n" "llamado.\n" -"Por lo tanto, se puede llamar con diferentes tipos dinámicamente incluso " -"desde un lugar en\n" +"Por lo tanto, se puede llamar con diferentes tipos dinámicamente incluso desde un lugar en\n" "el código.\n" "Eso es lo que simula `optics!` y `view_ref` en el ejemplo anterior." @@ -9346,17 +7852,14 @@ msgid "" "The functional approach need not be restricted to accessing members.\n" "More powerful lenses can be created which both _set_ and _get_ data in a\n" "structure.\n" -"But the concept really becomes interesting when used as a building block " -"for\n" +"But the concept really becomes interesting when used as a building block for\n" "composition.\n" "That is where the concept appears more clearly in Rust." msgstr "" "El enfoque funcional no tiene por qué limitarse a los miembros de acceso.\n" -"Se pueden crear lentes más potentes que _configuran_ y _obtienen_ datos en " -"un\n" +"Se pueden crear lentes más potentes que _configuran_ y _obtienen_ datos en un\n" "estructura.\n" -"Pero el concepto realmente se vuelve interesante cuando se usa como un " -"bloque de construcción para\n" +"Pero el concepto realmente se vuelve interesante cuando se usa como un bloque de construcción para\n" "composición.\n" "Ahí es donde aparece más claro el concepto en Rust." @@ -9368,38 +7871,30 @@ msgstr "## Prismas: una forma de \"óptica\" de orden superior" #: src\functional/lenses.md:171 #, fuzzy msgid "" -"A simple function such as `unique_ids_lens` above operates on a single " -"lens.\n" +"A simple function such as `unique_ids_lens` above operates on a single lens.\n" "A _prism_ is a function that operates on a _family_ of lenses.\n" "It is one conceptual level higher, using lenses as a building block, and\n" "continuing the metaphor, is part of a family of \"optics\".\n" -"It is the main one that is useful in understanding Rust APIs, so will be " -"the\n" +"It is the main one that is useful in understanding Rust APIs, so will be the\n" "focus here." msgstr "" "Una función simple como `unique_ids_lens` anterior opera en una sola lente.\n" "Un _prisma_ es una función que opera en una _familia_ de lentes.\n" -"Es un nivel conceptual más alto, usando lentes como bloque de construcción, " -"y\n" +"Es un nivel conceptual más alto, usando lentes como bloque de construcción, y\n" "continuando con la metáfora, forma parte de una familia de \"ópticas\".\n" -"Es el principal que es útil para comprender las API de Rust, por lo que será " -"el\n" +"Es el principal que es útil para comprender las API de Rust, por lo que será el\n" "enfócate aquí." #: src\functional/lenses.md:178 #, fuzzy msgid "" -"The same way that traits allow \"lens-like\" design with static polymorphism " -"and\n" -"dynamic dispatch, prism-like designs appear in Rust APIs which split " -"problems\n" +"The same way that traits allow \"lens-like\" design with static polymorphism and\n" +"dynamic dispatch, prism-like designs appear in Rust APIs which split problems\n" "into multiple associated types to be composed.\n" "A good example of this is the traits in the parsing crate _Serde_." msgstr "" -"De la misma manera que los rasgos permiten un diseño \"similar a una lente\" " -"con polimorfismo estático y\n" -"envío dinámico, los diseños de prisma aparecen en las API de Rust que " -"dividen los problemas\n" +"De la misma manera que los rasgos permiten un diseño \"similar a una lente\" con polimorfismo estático y\n" +"envío dinámico, los diseños de prisma aparecen en las API de Rust que dividen los problemas\n" "en múltiples tipos asociados para ser compuestos.\n" "Un buen ejemplo de esto son los rasgos en la caja de análisis _Serde_." @@ -9411,11 +7906,9 @@ msgid "" "Consider the `Deserializer` trait, implemented by some type in any library\n" "which parses a new format:" msgstr "" -"Tratar de entender la forma en que funciona _Serde_ solo leyendo la API es " -"un\n" +"Tratar de entender la forma en que funciona _Serde_ solo leyendo la API es un\n" "desafío, especialmente la primera vez.\n" -"Considere el rasgo `Deserializer`, implementado por algún tipo en cualquier " -"biblioteca\n" +"Considere el rasgo `Deserializer`, implementado por algún tipo en cualquier biblioteca\n" "que analiza un nuevo formato:" #: src\functional/lenses.md:188 @@ -9424,13 +7917,11 @@ msgid "" "pub trait Deserializer<'de>: Sized {\n" " type Error: Error;\n" "\n" -" fn deserialize_any(self, visitor: V) -> Result\n" +" fn deserialize_any(self, visitor: V) -> Result\n" " where\n" " V: Visitor<'de>;\n" "\n" -" fn deserialize_bool(self, visitor: V) -> Result\n" +" fn deserialize_bool(self, visitor: V) -> Result\n" " where\n" " V: Visitor<'de>;\n" "\n" @@ -9459,8 +7950,7 @@ msgid "" "To understand that, we need to keep the lens concept in mind and look at\n" "the definition of the `Visitor` type that is passed in generically:" msgstr "" -"Para entender eso, necesitamos tener en mente el concepto de lente y " -"observar\n" +"Para entender eso, necesitamos tener en mente el concepto de lente y observar\n" "la definición del tipo `Visitor` que se pasa genéricamente:" #: src\functional/lenses.md:212 @@ -9489,12 +7979,10 @@ msgstr "" #: src\functional/lenses.md:232 #, fuzzy msgid "" -"The job of the `Visitor` type is to construct values in the _Serde_ data " -"model,\n" +"The job of the `Visitor` type is to construct values in the _Serde_ data model,\n" "which are represented by its associated `Value` type." msgstr "" -"El trabajo del tipo `Visitor` es construir valores en el modelo de datos " -"_Serde_,\n" +"El trabajo del tipo `Visitor` es construir valores en el modelo de datos _Serde_,\n" "que están representados por su tipo `Valor` asociado." #: src\functional/lenses.md:235 @@ -9504,41 +7992,31 @@ msgid "" "If this fails, it returns an `Error` type - an error type determined by the\n" "`Deserializer` when its methods were called." msgstr "" -"Estos valores representan partes del valor de Rust que se está " -"deserializando.\n" -"Si esto falla, devuelve un tipo `Error` - un tipo de error determinado por " -"el\n" +"Estos valores representan partes del valor de Rust que se está deserializando.\n" +"Si esto falla, devuelve un tipo `Error` - un tipo de error determinado por el\n" "`Deserializer` cuando se llamaron sus métodos." #: src\functional/lenses.md:239 #, fuzzy msgid "" -"This highlights that `Deserializer` is similar to `CustomerId` from " -"earlier,\n" -"allowing any format parser which implements it to create `Value`s based on " -"what\n" +"This highlights that `Deserializer` is similar to `CustomerId` from earlier,\n" +"allowing any format parser which implements it to create `Value`s based on what\n" "it parsed.\n" "The `Value` trait is acting like a lens in functional programming languages." msgstr "" "Esto resalta que `Deserializer` es similar a `CustomerId` anterior,\n" -"permitiendo que cualquier analizador de formato que lo implemente cree " -"'Valores' basados en lo que\n" +"permitiendo que cualquier analizador de formato que lo implemente cree 'Valores' basados en lo que\n" "analizó.\n" -"El rasgo `Valor` está actuando como una lente en los lenguajes de " -"programación funcionales." +"El rasgo `Valor` está actuando como una lente en los lenguajes de programación funcionales." #: src\functional/lenses.md:244 #, fuzzy msgid "" -"But unlike the `CustomerId` trait, the return types of `Visitor` methods " -"are\n" -"_generic_, and the concrete `Value` type is _determined by the Visitor " -"itself_." +"But unlike the `CustomerId` trait, the return types of `Visitor` methods are\n" +"_generic_, and the concrete `Value` type is _determined by the Visitor itself_." msgstr "" -"Pero a diferencia del rasgo `CustomerId`, los tipos de retorno de los " -"métodos `Visitor` son\n" -"_genérico_, y el tipo de `Valor` concreto es _determinado por el propio " -"Visitante_." +"Pero a diferencia del rasgo `CustomerId`, los tipos de retorno de los métodos `Visitor` son\n" +"_genérico_, y el tipo de `Valor` concreto es _determinado por el propio Visitante_." #: src\functional/lenses.md:247 #, fuzzy @@ -9546,28 +8024,24 @@ msgid "" "Instead of acting as one lens, it effectively acts as a family of\n" "lenses, one for each concrete type of `Visitor`." msgstr "" -"En lugar de actuar como una sola lente, actúa efectivamente como una familia " -"de\n" +"En lugar de actuar como una sola lente, actúa efectivamente como una familia de\n" "lentes, uno para cada tipo concreto de 'Visitante'." #: src\functional/lenses.md:250 #, fuzzy msgid "" -"The `Deserializer` API is based on having a generic set of \"lenses\" work " -"across\n" +"The `Deserializer` API is based on having a generic set of \"lenses\" work across\n" "a set of other generic types for \"observation\".\n" "It is a _prism_." msgstr "" -"La API `Deserializer` se basa en tener un conjunto genérico de \"lentes\" " -"que funcionan en\n" +"La API `Deserializer` se basa en tener un conjunto genérico de \"lentes\" que funcionan en\n" "un conjunto de otros tipos genéricos para \"observación\".\n" "Es un _prisma_." #: src\functional/lenses.md:254 #, fuzzy msgid "For example, consider the identity record from earlier but simplified:" -msgstr "" -"Por ejemplo, considere el registro de identidad anterior pero simplificado:" +msgstr "Por ejemplo, considere el registro de identidad anterior pero simplificado:" #: src\functional/lenses.md:256 msgid "" @@ -9580,37 +8054,28 @@ msgstr "" #: src\functional/lenses.md:262 #, fuzzy -msgid "" -"How would the _Serde_ library deserialize this JSON into `struct " -"CreditRecord`?" -msgstr "" -"¿Cómo deserializaría la biblioteca _Serde_ este JSON en `struct " -"CreditRecord`?" +msgid "How would the _Serde_ library deserialize this JSON into `struct CreditRecord`?" +msgstr "¿Cómo deserializaría la biblioteca _Serde_ este JSON en `struct CreditRecord`?" #: src\functional/lenses.md:264 #, fuzzy msgid "" -"1. The user would call a library function to deserialize the data. This " -"would\n" +"1. The user would call a library function to deserialize the data. This would\n" " create a `Deserializer` based on the JSON format.\n" "1. Based on the fields in the struct, a `Visitor` would be created (more on\n" " that in a moment) which knows how to create each type in a generic data\n" " model that was needed to represent it: `u64` and `String`.\n" "1. The deserializer would make calls to the `Visitor` as it parsed items.\n" -"1. The `Visitor` would indicate if the items found were expected, and if " -"not,\n" +"1. The `Visitor` would indicate if the items found were expected, and if not,\n" " raise an error to indicate deserialization has failed." msgstr "" -"1. El usuario llamaría a una función de biblioteca para deserializar los " -"datos. Esto sería\n" +"1. El usuario llamaría a una función de biblioteca para deserializar los datos. Esto sería\n" " cree un `Deserializador` basado en el formato JSON.\n" "1. Según los campos de la estructura, se crearía un 'Visitante' (más sobre\n" " eso en un momento) que sabe cómo crear cada tipo en un data genérico\n" " modelo que se necesitaba para representarlo: `u64` y `String`.\n" -"1. El deserializador haría llamadas al `Visitor` mientras analizaba los " -"elementos.\n" -"1. El `Visitante` indicaría si los artículos encontrados eran los esperados, " -"y si no,\n" +"1. El deserializador haría llamadas al `Visitor` mientras analizaba los elementos.\n" +"1. El `Visitante` indicaría si los artículos encontrados eran los esperados, y si no,\n" " genera un error para indicar que la deserialización ha fallado." #: src\functional/lenses.md:273 @@ -9628,8 +8093,7 @@ msgid "" "1. Visit a string value, which will go into the `customer_id` field.\n" "1. Visit the end of the map." msgstr "" -"1. Visitar un mapa (equivalente de _Serde_ a `HashMap` o diccionario de " -"JSON).\n" +"1. Visitar un mapa (equivalente de _Serde_ a `HashMap` o diccionario de JSON).\n" "1. Visite una clave de cadena llamada \"nombre\".\n" "1. Visite un valor de cadena, que irá al campo `nombre`.\n" "1. Visite una clave de cadena llamada \"customer_id\".\n" @@ -9678,8 +8142,7 @@ msgid "" "That macro simply generates an impl block causing the struct to implement a\n" "trait called `Deserialize`." msgstr "" -"Esa macro simplemente genera un bloque impl que hace que la estructura " -"implemente un\n" +"Esa macro simplemente genera un bloque impl que hace que la estructura implemente un\n" "rasgo llamado `Deserializar`." #: src\functional/lenses.md:304 @@ -9703,23 +8166,20 @@ msgstr "" msgid "" "This is the function that determines how to create the struct itself.\n" "Code is generated based on the struct's fields.\n" -"When the parsing library is called - in our example, a JSON parsing library " -"-\n" +"When the parsing library is called - in our example, a JSON parsing library -\n" "it creates a `Deserializer` and calls `Type::deserialize` with it as a\n" "parameter." msgstr "" "Esta es la función que determina cómo crear la estructura en sí.\n" "El código se genera en función de los campos de la estructura.\n" -"Cuando se llama a la biblioteca de análisis, en nuestro ejemplo, una " -"biblioteca de análisis JSON,\n" +"Cuando se llama a la biblioteca de análisis, en nuestro ejemplo, una biblioteca de análisis JSON,\n" "crea un 'Deserializer' y llama a 'Type::deserialize' con él como un\n" "parámetro." #: src\functional/lenses.md:320 #, fuzzy msgid "" -"The `deserialize` code will then create a `Visitor` which will have its " -"calls\n" +"The `deserialize` code will then create a `Visitor` which will have its calls\n" "\"refracted\" by the `Deserializer`.\n" "If everything goes well, eventually that `Visitor` will construct a value\n" "corresponding to the type being parsed and return it." @@ -9731,12 +8191,8 @@ msgstr "" #: src\functional/lenses.md:325 #, fuzzy -msgid "" -"For a complete example, see the [_Serde_ " -"documentation](https://serde.rs/deserialize-struct.html)." -msgstr "" -"Para ver un ejemplo completo, consulte la " -"[documentación_Serde_](https://serde.rs/deserialize-struct.html)." +msgid "For a complete example, see the [_Serde_ documentation](https://serde.rs/deserialize-struct.html)." +msgstr "Para ver un ejemplo completo, consulte la [documentación_Serde_](https://serde.rs/deserialize-struct.html)." #: src\functional/lenses.md:327 #, fuzzy @@ -9746,75 +8202,56 @@ msgstr "Para terminar, este es el poder de _Serde_:" #: src\functional/lenses.md:329 #, fuzzy msgid "" -"1. The structure being parsed is represented by an `impl` block for " -"`Deserialize`\n" -"1. The input data format (e.g. JSON) is represented by a `Deserializer` " -"called\n" +"1. The structure being parsed is represented by an `impl` block for `Deserialize`\n" +"1. The input data format (e.g. JSON) is represented by a `Deserializer` called\n" " by `Deserialize`\n" -"1. The `Deserializer` acts like a prism which \"refracts\" lens-like " -"`Visitor`\n" +"1. The `Deserializer` acts like a prism which \"refracts\" lens-like `Visitor`\n" " calls which actually build the data value" msgstr "" -"1. La estructura que se analiza está representada por un bloque `impl` para " -"`Deserialize`\n" -"1. El formato de datos de entrada (por ejemplo, JSON) está representado por " -"un `Deserializador` llamado\n" +"1. La estructura que se analiza está representada por un bloque `impl` para `Deserialize`\n" +"1. El formato de datos de entrada (por ejemplo, JSON) está representado por un `Deserializador` llamado\n" " por `Deserializar`\n" -"1. El 'Deserializador' actúa como un prisma que \"refracta\" al 'Visitor' " -"similar a una lente\n" +"1. El 'Deserializador' actúa como un prisma que \"refracta\" al 'Visitor' similar a una lente\n" " llamadas que realmente construyen el valor de los datos" #: src\functional/lenses.md:335 #, fuzzy msgid "" -"The result is that types to be deserialized only implement the \"top layer\" " -"of\n" +"The result is that types to be deserialized only implement the \"top layer\" of\n" "the API, and file formats only need to implement the \"bottom layer\".\n" -"Each piece can then \"just work\" with the rest of the ecosystem, since " -"generic\n" +"Each piece can then \"just work\" with the rest of the ecosystem, since generic\n" "types will bridge them." msgstr "" -"El resultado es que los tipos que se van a deserializar solo implementan la " -"\"capa superior\" de\n" -"la API y los formatos de archivo solo necesitan implementar la \"capa " -"inferior\".\n" -"Luego, cada pieza puede \"simplemente funcionar\" con el resto del " -"ecosistema, ya que los genéricos\n" +"El resultado es que los tipos que se van a deserializar solo implementan la \"capa superior\" de\n" +"la API y los formatos de archivo solo necesitan implementar la \"capa inferior\".\n" +"Luego, cada pieza puede \"simplemente funcionar\" con el resto del ecosistema, ya que los genéricos\n" "los tipos los unirán." #: src\functional/lenses.md:340 #, fuzzy msgid "" -"To emphasize, the only reason this model works on any format and any type " -"is\n" +"To emphasize, the only reason this model works on any format and any type is\n" "because the `Deserializer` trait's output type **is specified by the\n" -"implementor of `Visitor` it is passed**, rather than being tied to one " -"specific\n" +"implementor of `Visitor` it is passed**, rather than being tied to one specific\n" "type.\n" "This was not true in the account example earlier." msgstr "" -"Para enfatizar, la única razón por la que este modelo funciona en cualquier " -"formato y cualquier tipo es\n" -"porque el tipo de salida del rasgo `Deserializer` ** está especificado por " -"el\n" -"implementador de `Visitor` se pasa **, en lugar de estar vinculado a un " -"específico\n" +"Para enfatizar, la única razón por la que este modelo funciona en cualquier formato y cualquier tipo es\n" +"porque el tipo de salida del rasgo `Deserializer` ** está especificado por el\n" +"implementador de `Visitor` se pasa **, en lugar de estar vinculado a un específico\n" "tipo.\n" "Esto no era cierto en el ejemplo de la cuenta anterior." #: src\functional/lenses.md:346 #, fuzzy msgid "" -"Rust's generic-inspired type system can bring it close to these concepts " -"and\n" +"Rust's generic-inspired type system can bring it close to these concepts and\n" "use their power, as shown in this API design.\n" "But it may also need procedural macros to create bridges for its generics." msgstr "" -"El sistema de tipos de inspiración genérica de Rust puede acercarlo a estos " -"conceptos y\n" +"El sistema de tipos de inspiración genérica de Rust puede acercarlo a estos conceptos y\n" "usa su poder, como se muestra en este diseño de API.\n" -"Pero también puede necesitar macros de procedimiento para crear puentes para " -"sus genéricos." +"Pero también puede necesitar macros de procedimiento para crear puentes para sus genéricos." #: src\functional/lenses.md:350 #, fuzzy @@ -9826,53 +8263,38 @@ msgstr "## Ver también" msgid "" "- [lens-rs crate](https://crates.io/crates/lens-rs) for a pre-built lenses\n" " implementation, with a cleaner interface than these examples\n" -"- [serde](https://serde.rs) itself, which makes these concepts intuitive " -"for\n" +"- [serde](https://serde.rs) itself, which makes these concepts intuitive for\n" " end users (i.e. defining the structs) without needing to undestand the\n" " details\n" -"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for " -"drawing\n" -" computer graphics that uses lens API design, including proceducal macros " -"to\n" -" create full prisms for buffers of different pixel types that remain " -"generic\n" -"- [An Article about Lenses in " -"Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-lens-and-other-optics-in-scala-e5f7e2fdafe)\n" +"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for drawing\n" +" computer graphics that uses lens API design, including proceducal macros to\n" +" create full prisms for buffers of different pixel types that remain generic\n" +"- [An Article about Lenses in Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-" +"references-lens-and-other-optics-in-scala-e5f7e2fdafe)\n" " that is very readable even without Scala expertise.\n" "- [Paper: Profunctor Optics: Modular Data\n" -" " -"Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +" Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" msgstr "" -"- [caja de lentes-rs] (https://crates.io/crates/lens-rs) para lentes " -"preconstruidos\n" +"- [caja de lentes-rs] (https://crates.io/crates/lens-rs) para lentes preconstruidos\n" " implementación, con una interfaz más limpia que estos ejemplos\n" -"- [serde](https://serde.rs) en sí mismo, lo que hace que estos conceptos " -"sean intuitivos para\n" -" usuarios finales (es decir, definir las estructuras) sin necesidad de " -"entender el\n" +"- [serde](https://serde.rs) en sí mismo, lo que hace que estos conceptos sean intuitivos para\n" +" usuarios finales (es decir, definir las estructuras) sin necesidad de entender el\n" " detalles\n" -"- [luminance](https://github.com/phaazon/luminance-rs) es una caja para " -"dibujar\n" -" gráficos por computadora que utilizan el diseño de la API de la lente, " -"incluidas las macros procesales para\n" -" crear prismas completos para búferes de diferentes tipos de píxeles que " -"siguen siendo genéricos\n" -"- [Un artículo sobre lentes en Scala] " -"(https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/function-references-lens-and-other-optics-in- " -"scala-e5f7e2fdafe)\n" +"- [luminance](https://github.com/phaazon/luminance-rs) es una caja para dibujar\n" +" gráficos por computadora que utilizan el diseño de la API de la lente, incluidas las macros procesales para\n" +" crear prismas completos para búferes de diferentes tipos de píxeles que siguen siendo genéricos\n" +"- [Un artículo sobre lentes en Scala] (https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/function-" +"references-lens-and-other-optics-in- scala-e5f7e2fdafe)\n" " eso es muy legible incluso sin experiencia en Scala.\n" "- [Papel: Óptica Profunctor: Datos Modulares\n" -" " -"Accesores](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +" Accesores](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" #: src\functional/lenses.md:365 #, fuzzy msgid "" -"[School of Haskell: A Little Lens Starter " -"Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" -msgstr "" -"[Escuela de Haskell: un pequeño tutorial para principiantes de lentes] " -"la-semana/un-pequeño-lentes-inicio-tutorial)" +"[School of Haskell: A Little Lens Starter Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/" +"to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" +msgstr "[Escuela de Haskell: un pequeño tutorial para principiantes de lentes] la-semana/un-pequeño-lentes-inicio-tutorial)" #: src\additional_resources/index.md:1 #, fuzzy @@ -9894,21 +8316,16 @@ msgstr "## Negociaciones" msgid "" "- [Design Patterns in Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) by\n" " Nicholas Cameron at the PDRust (2016)\n" -"- [Writing Idiomatic Libraries in " -"Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +"- [Writing Idiomatic Libraries in Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" " by Pascal Hertleif at RustFest (2017)\n" -"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) " -"by\n" +"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) by\n" " Nicholas Cameron at LinuxConfAu (2018)" msgstr "" -"- [Patrones de diseño en Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) " -"por\n" +"- [Patrones de diseño en Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) por\n" " Nicholas Cameron en el PDRust (2016)\n" -"- [Escribir bibliotecas idiomáticas en " -"Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +"- [Escribir bibliotecas idiomáticas en Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" " por Pascal Hertleif en RustFest (2017)\n" -"- [Técnicas de programación de óxido] " -"(https://www.youtube.com/watch?v=vqavdUGKeb4) por\n" +"- [Técnicas de programación de óxido] (https://www.youtube.com/watch?v=vqavdUGKeb4) por\n" " Nicholas Cameron en LinuxConfAu (2018)" #: src\additional_resources/index.md:14 @@ -9919,8 +8336,7 @@ msgstr "## Libros (en línea)" #: src\additional_resources/index.md:16 #, fuzzy msgid "- [The Rust API Guidelines](https://rust-lang.github.io/api-guidelines)" -msgstr "" -"- [Las pautas de la API de Rust] (https://rust-lang.github.io/api-guidelines)" +msgstr "- [Las pautas de la API de Rust] (https://rust-lang.github.io/api-guidelines)" #: src\additional_resources/design-principles.md:1 #, fuzzy @@ -9940,62 +8356,42 @@ msgstr "## [SÓLIDO](https://en.wikipedia.org/wiki/SÓLIDO)" #: src\additional_resources/design-principles.md:9 #, fuzzy msgid "" -"- [Single Responsibility Principle " -"(SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" -" A class should only have a single responsibility, that is, only changes " -"to\n" +"- [Single Responsibility Principle (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" A class should only have a single responsibility, that is, only changes to\n" " one part of the software's specification should be able to affect the\n" " specification of the class.\n" -"- [Open/Closed Principle " -"(OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +"- [Open/Closed Principle (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" " \"Software entities ... should be open for extension, but closed for\n" " modification.\"\n" -"- [Liskov Substitution Principle " -"(LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" -" \"Objects in a program should be replaceable with instances of their " -"subtypes\n" +"- [Liskov Substitution Principle (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Objects in a program should be replaceable with instances of their subtypes\n" " without altering the correctness of that program.\"\n" -"- [Interface Segregation Principle " -"(ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +"- [Interface Segregation Principle (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" " \"Many client-specific interfaces are better than one general-purpose\n" " interface.\"\n" -"- [Dependency Inversion Principle " -"(DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +"- [Dependency Inversion Principle (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" " One should \"depend upon abstractions, [not] concretions.\"" msgstr "" -"- [Principio de responsabilidad única (SRP)] " -"(https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" -" Una clase solo debe tener una única responsabilidad, es decir, solo " -"cambios a\n" +"- [Principio de responsabilidad única (SRP)] (https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" Una clase solo debe tener una única responsabilidad, es decir, solo cambios a\n" " una parte de la especificación del software debería poder afectar la\n" " especificación de la clase.\n" -"- [Principio abierto/cerrado " -"(OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" -" \"Las entidades de software... deberían estar abiertas para la extensión, " -"pero cerradas para\n" +"- [Principio abierto/cerrado (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +" \"Las entidades de software... deberían estar abiertas para la extensión, pero cerradas para\n" " modificación.\"\n" -"- [Principio de sustitución de Liskov (LSP)] " -"(https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" -" \"Los objetos en un programa deben ser reemplazables con instancias de sus " -"subtipos\n" +"- [Principio de sustitución de Liskov (LSP)] (https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Los objetos en un programa deben ser reemplazables con instancias de sus subtipos\n" " sin alterar la corrección de ese programa\".\n" -"- [Principio de segregación de interfaz (ISP)] " -"(https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" -" \"Muchas interfaces específicas del cliente son mejores que una de " -"propósito general\n" +"- [Principio de segregación de interfaz (ISP)] (https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +" \"Muchas interfaces específicas del cliente son mejores que una de propósito general\n" " interfaz.\"\n" -"- [Principio de inversión de dependencia (DIP)] " -"(https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +"- [Principio de inversión de dependencia (DIP)] (https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" " Uno debe \"depender de abstracciones, [no] de concreciones\"." #: src\additional_resources/design-principles.md:25 #, fuzzy -msgid "" -"## [DRY (Don’t Repeat " -"Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" -msgstr "" -"## [SECO (No te " -"repitas)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgid "## [DRY (Don’t Repeat Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgstr "## [SECO (No te repitas)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" #: src\additional_resources/design-principles.md:27 #, fuzzy @@ -10013,8 +8409,7 @@ msgstr "## [principio KISS](https://en.wikipedia.org/wiki/KISS_principle)" #: src\additional_resources/design-principles.md:32 msgid "" -"most systems work best if they are kept simple rather than made " -"complicated;\n" +"most systems work best if they are kept simple rather than made complicated;\n" "therefore, simplicity should be a key goal in design, and unnecessary\n" "complexity should be avoided" msgstr "" @@ -10028,75 +8423,51 @@ msgstr "## [Ley de Deméter (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter) #, fuzzy msgid "" "a given object should assume as little as possible about the structure or\n" -"properties of anything else (including its subcomponents), in accordance " -"with\n" +"properties of anything else (including its subcomponents), in accordance with\n" "the principle of \"information hiding\"" msgstr "" "un objeto dado debe suponer lo menos posible acerca de la estructura o\n" -"propiedades de cualquier otra cosa (incluidos sus subcomponentes), de " -"acuerdo con\n" +"propiedades de cualquier otra cosa (incluidos sus subcomponentes), de acuerdo con\n" "el principio de \"ocultamiento de información\"" #: src\additional_resources/design-principles.md:42 #, fuzzy -msgid "" -"## [Design by contract " -"(DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" -msgstr "" -"## [Diseño por contrato " -"(DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgid "## [Design by contract (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgstr "## [Diseño por contrato (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" #: src\additional_resources/design-principles.md:44 #, fuzzy msgid "" "software designers should define formal, precise and verifiable interface\n" -"specifications for software components, which extend the ordinary definition " -"of\n" +"specifications for software components, which extend the ordinary definition of\n" "abstract data types with preconditions, postconditions and invariants" msgstr "" -"los diseñadores de software deben definir una interfaz formal, precisa y " -"verificable\n" -"especificaciones para componentes de software, que amplían la definición " -"ordinaria de\n" -"tipos de datos abstractos con condiciones previas, condiciones posteriores e " -"invariantes" +"los diseñadores de software deben definir una interfaz formal, precisa y verificable\n" +"especificaciones para componentes de software, que amplían la definición ordinaria de\n" +"tipos de datos abstractos con condiciones previas, condiciones posteriores e invariantes" #: src\additional_resources/design-principles.md:48 #, fuzzy -msgid "" -"## " -"[Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" -msgstr "" -"## " -"[Encapsulación](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgid "## [Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgstr "## [Encapsulación](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" #: src\additional_resources/design-principles.md:50 #, fuzzy msgid "" -"bundling of data with the methods that operate on that data, or the " -"restricting\n" -"of direct access to some of an object's components. Encapsulation is used " -"to\n" -"hide the values or state of a structured data object inside a class, " -"preventing\n" +"bundling of data with the methods that operate on that data, or the restricting\n" +"of direct access to some of an object's components. Encapsulation is used to\n" +"hide the values or state of a structured data object inside a class, preventing\n" "unauthorized parties' direct access to them." msgstr "" -"agrupación de datos con los métodos que operan en esos datos, o la " -"restricción\n" -"de acceso directo a algunos de los componentes de un objeto. La " -"encapsulación se utiliza para\n" -"ocultar los valores o el estado de un objeto de datos estructurados dentro " -"de una clase, evitando\n" +"agrupación de datos con los métodos que operan en esos datos, o la restricción\n" +"de acceso directo a algunos de los componentes de un objeto. La encapsulación se utiliza para\n" +"ocultar los valores o el estado de un objeto de datos estructurados dentro de una clase, evitando\n" "el acceso directo de terceros no autorizados a ellos." #: src\additional_resources/design-principles.md:55 #, fuzzy -msgid "" -"## " -"[Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" -msgstr "" -"## [Comando-Consulta-Separación " -"(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgid "## [Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgstr "## [Comando-Consulta-Separación (CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" #: src\additional_resources/design-principles.md:57 #, fuzzy @@ -10105,31 +8476,23 @@ msgid "" "(procedures) will be permitted to produce side effects.” - Bertrand Meyer:\n" "Object-Oriented Software Construction" msgstr "" -"“Las funciones no deben producir efectos secundarios abstractos... solo " -"comandos\n" +"“Las funciones no deben producir efectos secundarios abstractos... solo comandos\n" "(procedimientos) podrán producir efectos secundarios”. -Bertrand Meyer:\n" "Construcción de software orientada a objetos" #: src\additional_resources/design-principles.md:61 #, fuzzy -msgid "" -"## [Principle of least astonishment " -"(POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" -msgstr "" -"## [Principio del menor asombro " -"(POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgid "## [Principle of least astonishment (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgstr "## [Principio del menor asombro (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" #: src\additional_resources/design-principles.md:63 #, fuzzy msgid "" -"a component of a system should behave in a way that most users will expect " -"it\n" +"a component of a system should behave in a way that most users will expect it\n" "to behave. The behavior should not astonish or surprise users" msgstr "" -"un componente de un sistema debe comportarse de una manera que la mayoría de " -"los usuarios esperarán\n" -"a comportarse. El comportamiento no debe asombrar o sorprender a los " -"usuarios." +"un componente de un sistema debe comportarse de una manera que la mayoría de los usuarios esperarán\n" +"a comportarse. El comportamiento no debe asombrar o sorprender a los usuarios." #: src\additional_resources/design-principles.md:66 #, fuzzy @@ -10139,12 +8502,10 @@ msgstr "## Unidades modulares lingüísticas" #: src\additional_resources/design-principles.md:68 #, fuzzy msgid "" -"“Modules must correspond to syntactic units in the language used.” - " -"Bertrand\n" +"“Modules must correspond to syntactic units in the language used.” - Bertrand\n" "Meyer: Object-Oriented Software Construction" msgstr "" -"“Los módulos deben corresponder a unidades sintácticas en el idioma " -"utilizado.” - Bertrand\n" +"“Los módulos deben corresponder a unidades sintácticas en el idioma utilizado.” - Bertrand\n" "Meyer: Construcción de Software Orientado a Objetos" #: src\additional_resources/design-principles.md:71 @@ -10156,14 +8517,11 @@ msgstr "## Autodocumentación" #, fuzzy msgid "" "“The designer of a module should strive to make all information about the\n" -"module part of the module itself.” - Bertrand Meyer: Object-Oriented " -"Software\n" +"module part of the module itself.” - Bertrand Meyer: Object-Oriented Software\n" "Construction" msgstr "" -"“El diseñador de un módulo debe esforzarse por hacer que toda la información " -"sobre el\n" -"módulo parte del propio módulo.” - Bertrand Meyer: software orientado a " -"objetos\n" +"“El diseñador de un módulo debe esforzarse por hacer que toda la información sobre el\n" +"módulo parte del propio módulo.” - Bertrand Meyer: software orientado a objetos\n" "Construcción" #: src\additional_resources/design-principles.md:77 @@ -10175,15 +8533,12 @@ msgstr "## Acceso uniforme" #, fuzzy msgid "" "“All services offered by a module should be available through a uniform\n" -"notation, which does not betray whether they are implemented through storage " -"or\n" +"notation, which does not betray whether they are implemented through storage or\n" "through computation.” - Bertrand Meyer: Object-Oriented Software Construction" msgstr "" -"“Todos los servicios ofrecidos por un módulo deben estar disponibles a " -"través de un\n" +"“Todos los servicios ofrecidos por un módulo deben estar disponibles a través de un\n" "notación, que no traiciona si se implementan a través del almacenamiento o\n" -"a través de la computación.” - Bertrand Meyer: Construcción de Software " -"Orientado a Objetos" +"a través de la computación.” - Bertrand Meyer: Construcción de Software Orientado a Objetos" #: src\additional_resources/design-principles.md:83 #, fuzzy @@ -10193,14 +8548,11 @@ msgstr "## Opción única" #: src\additional_resources/design-principles.md:85 #, fuzzy msgid "" -"“Whenever a software system must support a set of alternatives, one and " -"only\n" -"one module in the system should know their exhaustive list.” - Bertrand " -"Meyer:\n" +"“Whenever a software system must support a set of alternatives, one and only\n" +"one module in the system should know their exhaustive list.” - Bertrand Meyer:\n" "Object-Oriented Software Construction" msgstr "" -"“Siempre que un sistema de software deba soportar un conjunto de " -"alternativas, una y sólo\n" +"“Siempre que un sistema de software deba soportar un conjunto de alternativas, una y sólo\n" "un módulo en el sistema debe conocer su lista exhaustiva”. -Bertrand Meyer:\n" "Construcción de software orientada a objetos" @@ -10214,49 +8566,12 @@ msgstr "## Persistencia-Cierre" msgid "" "“Whenever a storage mechanism stores an object, it must store with it the\n" "dependents of that object. Whenever a retrieval mechanism retrieves a\n" -"previously stored object, it must also retrieve any dependent of that " -"object\n" -"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented " -"Software\n" +"previously stored object, it must also retrieve any dependent of that object\n" +"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented Software\n" "Construction" msgstr "" -"“Siempre que un mecanismo de almacenamiento almacena un objeto, debe " -"almacenar con él el\n" -"dependientes de ese objeto. Cada vez que un mecanismo de recuperación " -"recupera un\n" -"objeto previamente almacenado, también debe recuperar cualquier dependiente " -"de ese objeto\n" -"que aún no ha sido recuperado.” - Bertrand Meyer: software orientado a " -"objetos\n" +"“Siempre que un mecanismo de almacenamiento almacena un objeto, debe almacenar con él el\n" +"dependientes de ese objeto. Cada vez que un mecanismo de recuperación recupera un\n" +"objeto previamente almacenado, también debe recuperar cualquier dependiente de ese objeto\n" +"que aún no ha sido recuperado.” - Bertrand Meyer: software orientado a objetos\n" "Construcción" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - diff --git a/po/it.po b/po/it.po index c1cbcc8..0f024c0 100644 --- a/po/it.po +++ b/po/it.po @@ -1,16 +1,16 @@ - msgid "" msgstr "" "Project-Id-Version: Rust Design Patterns\n" "POT-Creation-Date: \n" -"PO-Revision-Date: 2023-04-08 21:51+0200\n" -"Last-Translator: \n" +"PO-Revision-Date: 2023-04-09 03:22+0200\n" +"Last-Translator: EMAIL@ADDRESS\n" "Language-Team: Italian\n" +"Language: it\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"Language: it\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Generator: Poedit 3.2.2\n" #: src\SUMMARY.md:3 #, fuzzy @@ -266,12 +266,10 @@ msgstr "## Partecipazione" #, fuzzy msgid "" "If you are interested in contributing to this book, check out the\n" -"[contribution " -"guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +"[contribution guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." msgstr "" "Se sei interessato a contribuire a questo libro, dai un'occhiata al\n" -"[linee guida per il " -"contributo](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +"[linee guida per il contributo](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." #: src\intro.md:8 #, fuzzy @@ -289,8 +287,7 @@ msgid "" msgstr "" "Nello sviluppo del software, spesso incontriamo problemi che condividono\n" "somiglianze indipendentemente dall'ambiente in cui appaiono\n" -"i dettagli di implementazione sono cruciali per risolvere il compito a " -"portata di mano, potremmo\n" +"i dettagli di implementazione sono cruciali per risolvere il compito a portata di mano, potremmo\n" "astratto da queste particolarità per trovare le pratiche comuni che\n" "sono genericamente applicabili." @@ -303,12 +300,10 @@ msgid "" "language for developers, making them an excellent tool for effective\n" "communication when problem-solving in teams." msgstr "" -"I modelli di progettazione sono una raccolta di soluzioni riutilizzabili e " -"testate per\n" +"I modelli di progettazione sono una raccolta di soluzioni riutilizzabili e testate per\n" "problemi ricorrenti in ingegneria. Rendono il nostro software più modulare,\n" "manutenibile ed estensibile. Inoltre, questi modelli forniscono un comune\n" -"linguaggio per sviluppatori, rendendoli uno strumento eccellente per " -"efficaci\n" +"linguaggio per sviluppatori, rendendoli uno strumento eccellente per efficaci\n" "comunicazione durante la risoluzione dei problemi in team." #: src\intro.md:22 src\patterns/index.md:14 @@ -319,8 +314,7 @@ msgstr "## Modelli di design in Rust" #: src\intro.md:24 #, fuzzy msgid "" -"Rust is not object-oriented, and the combination of all its " -"characteristics,\n" +"Rust is not object-oriented, and the combination of all its characteristics,\n" "such as functional elements, a strong type system, and the borrow checker,\n" "makes it unique.\n" "Because of this, Rust design patterns vary with respect to other\n" @@ -328,15 +322,12 @@ msgid "" "That's why we decided to write this book. We hope you enjoy reading it!\n" "The book is divided in three main chapters:" msgstr "" -"Rust non è orientato agli oggetti e la combinazione di tutte le sue " -"caratteristiche,\n" -"come elementi funzionali, un forte sistema di tipi e il controllo del " -"prestito,\n" +"Rust non è orientato agli oggetti e la combinazione di tutte le sue caratteristiche,\n" +"come elementi funzionali, un forte sistema di tipi e il controllo del prestito,\n" "lo rende unico.\n" "Per questo motivo, i modelli di design di Rust variano rispetto ad altri\n" "linguaggi di programmazione tradizionali orientati agli oggetti.\n" -"Ecco perché abbiamo deciso di scrivere questo libro. Ci auguriamo che ti " -"piaccia leggerlo!\n" +"Ecco perché abbiamo deciso di scrivere questo libro. Ci auguriamo che ti piaccia leggerlo!\n" "Il libro è diviso in tre capitoli principali:" #: src\intro.md:32 @@ -347,8 +338,7 @@ msgid "" " You should break them only if you have a good reason for it.\n" "- [Design patterns](./patterns/index.md): methods to solve common problems\n" " when coding.\n" -"- [Anti-patterns](./anti_patterns/index.md): methods to solve common " -"problems\n" +"- [Anti-patterns](./anti_patterns/index.md): methods to solve common problems\n" " when coding.\n" " However, while design patterns give us benefits,\n" " anti-patterns create more problems." @@ -356,11 +346,9 @@ msgstr "" "- [Idioms](./idioms/index.md): linee guida da seguire durante la codifica.\n" " Sono le norme sociali della comunità.\n" " Dovresti romperli solo se hai una buona ragione per farlo.\n" -"- [Design patterns](./patterns/index.md): metodi per risolvere problemi " -"comuni\n" +"- [Design patterns](./patterns/index.md): metodi per risolvere problemi comuni\n" " durante la codifica.\n" -"- [Anti-patterns](./anti_patterns/index.md): metodi per risolvere problemi " -"comuni\n" +"- [Anti-patterns](./anti_patterns/index.md): metodi per risolvere problemi comuni\n" " durante la codifica.\n" " Tuttavia, mentre i design pattern ci danno dei vantaggi,\n" " gli anti-pattern creano più problemi." @@ -373,15 +361,13 @@ msgstr "# Traduzioni" #: src\translations.md:3 #, fuzzy msgid "" -"We are utilizing " -"[mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" -"Please read up on how to _add_ and _update_ translations in [their " -"repository](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations)" +"We are utilizing [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Please read up on how to _add_ and _update_ translations in [their repository](https://github.com/google/mdbook-i18n-helpers#creating-" +"and-updating-translations)" msgstr "" -"Stiamo utilizzando " -"[mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" -"Leggi come _aggiungere_ e _aggiornare_ le traduzioni nel [loro " -"repository](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations)" +"Stiamo utilizzando [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Leggi come _aggiungere_ e _aggiornare_ le traduzioni nel [loro repository](https://github.com/google/mdbook-i18n-helpers#creating-and-" +"updating-translations)" #: src\translations.md:6 #, fuzzy @@ -415,11 +401,9 @@ msgid "" "Writing idiomatic code allows other developers to understand better what is\n" "happening." msgstr "" -"[Idioms](https://en.wikipedia.org/wiki/Programming_idiom) sono comunemente " -"usati\n" +"[Idioms](https://en.wikipedia.org/wiki/Programming_idiom) sono comunemente usati\n" "stili, linee guida e modelli ampiamente concordati da una comunità.\n" -"Scrivere codice idiomatico consente ad altri sviluppatori di capire meglio " -"cos'è\n" +"Scrivere codice idiomatico consente ad altri sviluppatori di capire meglio cos'è\n" "accadendo." #: src\idioms/index.md:8 @@ -432,19 +416,14 @@ msgid "" msgstr "" "Dopotutto, al computer interessa solo il codice macchina che viene generato\n" "dal compilatore.\n" -"Invece, il codice sorgente è principalmente vantaggioso per lo " -"sviluppatore.\n" -"Quindi, visto che abbiamo questo livello di astrazione, perché non renderlo " -"più leggibile?" +"Invece, il codice sorgente è principalmente vantaggioso per lo sviluppatore.\n" +"Quindi, visto che abbiamo questo livello di astrazione, perché non renderlo più leggibile?" #: src\idioms/index.md:13 msgid "" -"Remember the [KISS " -"principle](https://en.wikipedia.org/wiki/KISS_principle):\n" -"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they " -"are\n" -"kept simple rather than made complicated; therefore, simplicity should be a " -"key\n" +"Remember the [KISS principle](https://en.wikipedia.org/wiki/KISS_principle):\n" +"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they are\n" +"kept simple rather than made complicated; therefore, simplicity should be a key\n" "goal in design, and unnecessary complexity should be avoided\"." msgstr "" @@ -458,25 +437,16 @@ msgstr "> Il codice è lì per essere compreso dagli umani, non dai computer." msgid "# Use borrowed types for arguments" msgstr "# Usa i tipi presi in prestito per gli argomenti" -#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 -#: src\idioms/default.md:3 src\idioms/deref.md:3 src\idioms/dtor-finally.md:3 -#: src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 -#: src\idioms/ffi/errors.md:3 src\idioms/ffi/accepting-strings.md:3 -#: src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 -#: src\idioms/pass-var-to-closure.md:3 src\idioms/priv-extend.md:3 -#: src\idioms/temporary-mutability.md:3 -#: src\idioms/return-consumed-arg-on-error.md:3 -#: src\patterns/behavioural/command.md:3 -#: src\patterns/behavioural/interpreter.md:3 -#: src\patterns/behavioural/newtype.md:13 src\patterns/behavioural/RAII.md:3 -#: src\patterns/behavioural/strategy.md:3 src\patterns/behavioural/visitor.md:3 -#: src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 -#: src\patterns/structural/compose-structs.md:5 -#: src\patterns/structural/small-crates.md:3 -#: src\patterns/structural/unsafe-mods.md:3 src\patterns/ffi/export.md:3 -#: src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 -#: src\anti_patterns/deny-warnings.md:3 src\anti_patterns/deref.md:3 -#: src\functional/generics-type-classes.md:3 +#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 src\idioms/default.md:3 src\idioms/deref.md:3 +#: src\idioms/dtor-finally.md:3 src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 src\idioms/ffi/errors.md:3 +#: src\idioms/ffi/accepting-strings.md:3 src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 +#: src\idioms/pass-var-to-closure.md:3 src\idioms/priv-extend.md:3 src\idioms/temporary-mutability.md:3 +#: src\idioms/return-consumed-arg-on-error.md:3 src\patterns/behavioural/command.md:3 src\patterns/behavioural/interpreter.md:3 +#: src\patterns/behavioural/newtype.md:13 src\patterns/behavioural/RAII.md:3 src\patterns/behavioural/strategy.md:3 +#: src\patterns/behavioural/visitor.md:3 src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 +#: src\patterns/structural/compose-structs.md:5 src\patterns/structural/small-crates.md:3 src\patterns/structural/unsafe-mods.md:3 +#: src\patterns/ffi/export.md:3 src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 src\anti_patterns/deny-warnings.md:3 +#: src\anti_patterns/deref.md:3 src\functional/generics-type-classes.md:3 #, fuzzy msgid "## Description" msgstr "## Descrizione" @@ -484,15 +454,12 @@ msgstr "## Descrizione" #: src\idioms/coercion-arguments.md:5 #, fuzzy msgid "" -"Using a target of a deref coercion can increase the flexibility of your " -"code\n" +"Using a target of a deref coercion can increase the flexibility of your code\n" "when you are deciding which argument type to use for a function argument.\n" "In this way, the function will accept more input types." msgstr "" -"L'utilizzo di un obiettivo di una coercizione deref può aumentare la " -"flessibilità del codice\n" -"quando si decide quale tipo di argomento utilizzare per un argomento di " -"funzione.\n" +"L'utilizzo di un obiettivo di una coercizione deref può aumentare la flessibilità del codice\n" +"quando si decide quale tipo di argomento utilizzare per un argomento di funzione.\n" "In questo modo, la funzione accetterà più tipi di input." #: src\idioms/coercion-arguments.md:9 @@ -504,46 +471,32 @@ msgid "" "Such as `&str` over `&String`, `&[T]` over `&Vec`, or `&T` over `&Box`." msgstr "" "Questo non è limitato ai tipi di puntatore slice-able o fat.\n" -"In effetti, dovresti sempre preferire l'utilizzo del **tipo preso in " -"prestito**\n" +"In effetti, dovresti sempre preferire l'utilizzo del **tipo preso in prestito**\n" "**prendendo in prestito il tipo di proprietà**.\n" "Ad esempio `&str` su `&String`, `&[T]` su `&Vec` o `&T` su `&Box`." #: src\idioms/coercion-arguments.md:14 #, fuzzy msgid "" -"Using borrowed types you can avoid layers of indirection for those " -"instances\n" -"where the owned type already provides a layer of indirection. For instance, " -"a\n" +"Using borrowed types you can avoid layers of indirection for those instances\n" +"where the owned type already provides a layer of indirection. For instance, a\n" "`String` has a layer of indirection, so a `&String` will have two layers of\n" -"indirection. We can avoid this by using `&str` instead, and letting " -"`&String`\n" +"indirection. We can avoid this by using `&str` instead, and letting `&String`\n" "coerce to a `&str` whenever the function is invoked." msgstr "" -"Utilizzando i tipi presi in prestito è possibile evitare livelli di " -"riferimento indiretto per tali istanze\n" -"dove il tipo di proprietà fornisce già uno strato di riferimento indiretto. " -"Ad esempio, a\n" -"\"Stringa\" ha uno strato di riferimento indiretto, quindi una \"&Stringa\" " -"avrà due strati di\n" +"Utilizzando i tipi presi in prestito è possibile evitare livelli di riferimento indiretto per tali istanze\n" +"dove il tipo di proprietà fornisce già uno strato di riferimento indiretto. Ad esempio, a\n" +"\"Stringa\" ha uno strato di riferimento indiretto, quindi una \"&Stringa\" avrà due strati di\n" "indiretto. Possiamo evitarlo usando invece `&str` e lasciando `&String`\n" "forzare a un `&str` ogni volta che la funzione viene invocata." -#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 -#: src\idioms/default.md:20 src\idioms/deref.md:9 src\idioms/dtor-finally.md:9 -#: src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 -#: src\idioms/pass-var-to-closure.md:12 src\idioms/priv-extend.md:18 -#: src\idioms/temporary-mutability.md:12 -#: src\idioms/return-consumed-arg-on-error.md:8 -#: src\patterns/behavioural/command.md:18 -#: src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 -#: src\patterns/behavioural/strategy.md:28 -#: src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 -#: src\patterns/creational/fold.md:12 -#: src\patterns/structural/compose-structs.md:17 -#: src\anti_patterns/borrow_clone.md:11 src\anti_patterns/deny-warnings.md:8 -#: src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 +#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 src\idioms/default.md:20 src\idioms/deref.md:9 +#: src\idioms/dtor-finally.md:9 src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 src\idioms/pass-var-to-closure.md:12 +#: src\idioms/priv-extend.md:18 src\idioms/temporary-mutability.md:12 src\idioms/return-consumed-arg-on-error.md:8 +#: src\patterns/behavioural/command.md:18 src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 +#: src\patterns/behavioural/strategy.md:28 src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 +#: src\patterns/creational/fold.md:12 src\patterns/structural/compose-structs.md:17 src\anti_patterns/borrow_clone.md:11 +#: src\anti_patterns/deny-warnings.md:8 src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 #, fuzzy msgid "## Example" msgstr "## Esempio" @@ -551,31 +504,23 @@ msgstr "## Esempio" #: src\idioms/coercion-arguments.md:22 #, fuzzy msgid "" -"For this example, we will illustrate some differences for using `&String` as " -"a\n" -"function argument versus using a `&str`, but the ideas apply as well to " -"using\n" +"For this example, we will illustrate some differences for using `&String` as a\n" +"function argument versus using a `&str`, but the ideas apply as well to using\n" "`&Vec` versus using a `&[T]` or using a `&Box` versus a `&T`." msgstr "" -"Per questo esempio, illustreremo alcune differenze per l'utilizzo di " -"`&String` come a\n" -"argomento della funzione rispetto all'utilizzo di un `&str`, ma le idee si " -"applicano anche all'utilizzo\n" -"`&Vec` rispetto all'utilizzo di un `&[T]` o all'utilizzo di un `&Box` " -"rispetto a un `&T`." +"Per questo esempio, illustreremo alcune differenze per l'utilizzo di `&String` come a\n" +"argomento della funzione rispetto all'utilizzo di un `&str`, ma le idee si applicano anche all'utilizzo\n" +"`&Vec` rispetto all'utilizzo di un `&[T]` o all'utilizzo di un `&Box` rispetto a un `&T`." #: src\idioms/coercion-arguments.md:26 #, fuzzy msgid "" "Consider an example where we wish to determine if a word contains three\n" -"consecutive vowels. We don't need to own the string to determine this, so " -"we\n" +"consecutive vowels. We don't need to own the string to determine this, so we\n" "will take a reference." msgstr "" -"Considera un esempio in cui desideriamo determinare se una parola ne " -"contiene tre\n" -"vocali consecutive. Non abbiamo bisogno di possedere la stringa per " -"determinarlo, quindi noi\n" +"Considera un esempio in cui desideriamo determinare se una parola ne contiene tre\n" +"vocali consecutive. Non abbiamo bisogno di possedere la stringa per determinarlo, quindi noi\n" "prenderà un riferimento." #: src\idioms/coercion-arguments.md:30 @@ -620,16 +565,13 @@ msgstr "" #, fuzzy msgid "" "This works fine because we are passing a `&String` type as a parameter.\n" -"If we remove the comments on the last two lines, the example will fail. " -"This\n" -"is because a `&str` type will not coerce to a `&String` type. We can fix " -"this\n" +"If we remove the comments on the last two lines, the example will fail. This\n" +"is because a `&str` type will not coerce to a `&String` type. We can fix this\n" "by simply modifying the type for our argument." msgstr "" "Funziona bene perché stiamo passando un tipo `&String` come parametro.\n" "Se rimuoviamo i commenti sulle ultime due righe, l'esempio fallirà. Questo\n" -"è perché un tipo `&str` non costringerà a un tipo `&String`. Possiamo " -"risolvere questo problema\n" +"è perché un tipo `&str` non costringerà a un tipo `&String`. Possiamo risolvere questo problema\n" "semplicemente modificando il tipo per il nostro argomento." #: src\idioms/coercion-arguments.md:67 @@ -661,37 +603,28 @@ msgstr "" #, fuzzy msgid "" "But wait, that's not all! There is more to this story.\n" -"It's likely that you may say to yourself: that doesn't matter, I will never " -"be\n" -"using a `&'static str` as an input anyways (as we did when we used " -"`\"Ferris\"`).\n" -"Even ignoring this special example, you may still find that using `&str` " -"will\n" +"It's likely that you may say to yourself: that doesn't matter, I will never be\n" +"using a `&'static str` as an input anyways (as we did when we used `\"Ferris\"`).\n" +"Even ignoring this special example, you may still find that using `&str` will\n" "give you more flexibility than using a `&String`." msgstr "" "Ma aspetta, non è tutto! C'è di più su questa storia.\n" "È probabile che tu possa dire a te stesso: non importa, non lo sarò mai\n" -"usando comunque una `&'static str` come input (come abbiamo fatto quando " -"abbiamo usato `\"Ferris\"`).\n" -"Anche ignorando questo esempio speciale, potresti comunque scoprire che " -"l'uso di `&str` lo farà\n" +"usando comunque una `&'static str` come input (come abbiamo fatto quando abbiamo usato `\"Ferris\"`).\n" +"Anche ignorando questo esempio speciale, potresti comunque scoprire che l'uso di `&str` lo farà\n" "ti offre maggiore flessibilità rispetto all'utilizzo di una `&Stringa`." #: src\idioms/coercion-arguments.md:86 #, fuzzy msgid "" "Let's now take an example where someone gives us a sentence, and we want to\n" -"determine if any of the words in the sentence contain three consecutive " -"vowels.\n" -"We probably should make use of the function we have already defined and " -"simply\n" +"determine if any of the words in the sentence contain three consecutive vowels.\n" +"We probably should make use of the function we have already defined and simply\n" "feed in each word from the sentence." msgstr "" "Facciamo ora un esempio in cui qualcuno ci dà una frase, e noi vogliamo\n" -"determinare se una qualsiasi delle parole nella frase contiene tre vocali " -"consecutive.\n" -"Probabilmente dovremmo utilizzare la funzione che abbiamo già definito e " -"semplicemente\n" +"determinare se una qualsiasi delle parole nella frase contiene tre vocali consecutive.\n" +"Probabilmente dovremmo utilizzare la funzione che abbiamo già definito e semplicemente\n" "inserire ogni parola della frase." #: src\idioms/coercion-arguments.md:91 @@ -720,8 +653,7 @@ msgid "" "\n" "fn main() {\n" " let sentence_string =\n" -" \"Once upon a time, there was a friendly curious crab named " -"Ferris\".to_string();\n" +" \"Once upon a time, there was a friendly curious crab named Ferris\".to_string();\n" " for word in sentence_string.split(' ') {\n" " if three_vowels(word) {\n" " println!(\"{} has three consecutive vowels!\", word);\n" @@ -734,12 +666,10 @@ msgstr "" #: src\idioms/coercion-arguments.md:121 #, fuzzy msgid "" -"Running this example using our function declared with an argument type " -"`&str`\n" +"Running this example using our function declared with an argument type `&str`\n" "will yield" msgstr "" -"Eseguire questo esempio usando la nostra funzione dichiarata con un tipo di " -"argomento `&str`\n" +"Eseguire questo esempio usando la nostra funzione dichiarata con un tipo di argomento `&str`\n" "cederà" #: src\idioms/coercion-arguments.md:124 @@ -753,35 +683,21 @@ msgstr "" #, fuzzy msgid "" "However, this example will not run when our function is declared with an\n" -"argument type `&String`. This is because string slices are a `&str` and not " -"a\n" -"`&String` which would require an allocation to be converted to `&String` " -"which\n" -"is not implicit, whereas converting from `String` to `&str` is cheap and " -"implicit." -msgstr "" -"Tuttavia, questo esempio non verrà eseguito quando la nostra funzione viene " -"dichiarata con an\n" -"tipo di argomento `&Stringa`. Questo perché le sezioni di stringa sono un " -"`&str` e non un\n" -"`&String` che richiederebbe la conversione di un'allocazione in `&String` " -"which\n" -"non è implicito, mentre la conversione da `String` a `&str` è economica e " -"implicita." - -#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 -#: src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 -#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 -#: src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 -#: src\patterns/behavioural/command.md:218 -#: src\patterns/behavioural/interpreter.md:142 -#: src\patterns/behavioural/newtype.md:104 src\patterns/behavioural/RAII.md:111 -#: src\patterns/behavioural/strategy.md:174 -#: src\patterns/behavioural/visitor.md:106 -#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 -#: src\patterns/structural/small-crates.md:45 -#: src\patterns/structural/unsafe-mods.md:32 -#: src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 +"argument type `&String`. This is because string slices are a `&str` and not a\n" +"`&String` which would require an allocation to be converted to `&String` which\n" +"is not implicit, whereas converting from `String` to `&str` is cheap and implicit." +msgstr "" +"Tuttavia, questo esempio non verrà eseguito quando la nostra funzione viene dichiarata con an\n" +"tipo di argomento `&Stringa`. Questo perché le sezioni di stringa sono un `&str` e non un\n" +"`&String` che richiederebbe la conversione di un'allocazione in `&String` which\n" +"non è implicito, mentre la conversione da `String` a `&str` è economica e implicita." + +#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 +#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 +#: src\patterns/behavioural/command.md:218 src\patterns/behavioural/interpreter.md:142 src\patterns/behavioural/newtype.md:104 +#: src\patterns/behavioural/RAII.md:111 src\patterns/behavioural/strategy.md:174 src\patterns/behavioural/visitor.md:106 +#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 src\patterns/structural/small-crates.md:45 +#: src\patterns/structural/unsafe-mods.md:32 src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 #: src\anti_patterns/deref.md:123 src\functional/generics-type-classes.md:237 #, fuzzy msgid "## See also" @@ -790,19 +706,16 @@ msgstr "## Guarda anche" #: src\idioms/coercion-arguments.md:135 #, fuzzy msgid "" -"- [Rust Language Reference on Type " -"Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- [Rust Language Reference on Type Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" "- For more discussion on how to handle `String` and `&str` see\n" -" [this blog series " -"(2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html)\n" +" [this blog series (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-" +"functions.html)\n" " by Herman J. Radtke III" msgstr "" -"- [Riferimento al linguaggio Rust sulle coercizioni di " -"tipo](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- [Riferimento al linguaggio Rust sulle coercizioni di tipo](https://doc.rust-lang.org/reference/type-coercions.html)\n" "- Per ulteriori discussioni su come gestire `String` e `&str` vedere\n" -" [questa serie di blog " -"(2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html " -")\n" +" [questa serie di blog (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-" +"functions.html )\n" " di Hermann J. Radtke III" #: src\idioms/concat-format.md:1 @@ -813,15 +726,13 @@ msgstr "# Concatenazione di stringhe con `format!`" #: src\idioms/concat-format.md:5 #, fuzzy msgid "" -"It is possible to build up strings using the `push` and `push_str` methods " -"on a\n" +"It is possible to build up strings using the `push` and `push_str` methods on a\n" "mutable `String`, or using its `+` operator. However, it is often more\n" "convenient to use `format!`, especially where there is a mix of literal and\n" "non-literal strings." msgstr "" "È possibile creare stringhe usando i metodi `push` e `push_str` su a\n" -"mutabile `Stringa`, o usando il suo operatore `+`. Tuttavia, spesso è di " -"più\n" +"mutabile `Stringa`, o usando il suo operatore `+`. Tuttavia, spesso è di più\n" "conveniente usare `format!`, specialmente dove c'è un misto di letterale e\n" "stringhe non letterali." @@ -841,47 +752,29 @@ msgid "" "```" msgstr "" -#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 -#: src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 -#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 -#: src\idioms/ffi/accepting-strings.md:68 src\idioms/ffi/passing-strings.md:68 -#: src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 -#: src\idioms/return-consumed-arg-on-error.md:55 -#: src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 -#: src\patterns/behavioural/strategy.md:96 -#: src\patterns/creational/builder.md:68 -#: src\patterns/structural/compose-structs.md:75 -#: src\patterns/structural/small-crates.md:12 -#: src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 -#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 -#: src\anti_patterns/deref.md:69 src\functional/generics-type-classes.md:210 +#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 +#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 src\idioms/ffi/accepting-strings.md:68 +#: src\idioms/ffi/passing-strings.md:68 src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 +#: src\idioms/return-consumed-arg-on-error.md:55 src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 +#: src\patterns/behavioural/strategy.md:96 src\patterns/creational/builder.md:68 src\patterns/structural/compose-structs.md:75 +#: src\patterns/structural/small-crates.md:12 src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 +#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 src\anti_patterns/deref.md:69 +#: src\functional/generics-type-classes.md:210 #, fuzzy msgid "## Advantages" msgstr "## Vantaggi" #: src\idioms/concat-format.md:27 #, fuzzy -msgid "" -"Using `format!` is usually the most succinct and readable way to combine " -"strings." -msgstr "" -"Usare `format!` è di solito il modo più succinto e leggibile per combinare " -"le stringhe." - -#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 -#: src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 -#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 -#: src\idioms/ffi/accepting-strings.md:141 -#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 -#: src\idioms/temporary-mutability.md:42 -#: src\idioms/return-consumed-arg-on-error.md:59 -#: src\patterns/behavioural/newtype.md:77 -#: src\patterns/behavioural/strategy.md:104 -#: src\patterns/creational/builder.md:76 -#: src\patterns/structural/compose-structs.md:81 -#: src\patterns/structural/small-crates.md:22 -#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 -#: src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 +msgid "Using `format!` is usually the most succinct and readable way to combine strings." +msgstr "Usare `format!` è di solito il modo più succinto e leggibile per combinare le stringhe." + +#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 +#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 src\idioms/ffi/accepting-strings.md:141 +#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 src\idioms/temporary-mutability.md:42 +#: src\idioms/return-consumed-arg-on-error.md:59 src\patterns/behavioural/newtype.md:77 src\patterns/behavioural/strategy.md:104 +#: src\patterns/creational/builder.md:76 src\patterns/structural/compose-structs.md:81 src\patterns/structural/small-crates.md:22 +#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 #: src\functional/generics-type-classes.md:221 #, fuzzy msgid "## Disadvantages" @@ -890,16 +783,12 @@ msgstr "## Svantaggi" #: src\idioms/concat-format.md:31 #, fuzzy msgid "" -"It is usually not the most efficient way to combine strings - a series of " -"`push`\n" -"operations on a mutable string is usually the most efficient (especially if " -"the\n" +"It is usually not the most efficient way to combine strings - a series of `push`\n" +"operations on a mutable string is usually the most efficient (especially if the\n" "string has been pre-allocated to the expected size)." msgstr "" -"Di solito non è il modo più efficiente per combinare le stringhe: una serie " -"di \"push\".\n" -"operazioni su una stringa mutabile è solitamente la più efficiente " -"(specialmente se il\n" +"Di solito non è il modo più efficiente per combinare le stringhe: una serie di \"push\".\n" +"operazioni su una stringa mutabile è solitamente la più efficiente (specialmente se il\n" "la stringa è stata preallocata alla dimensione prevista)." #: src\idioms/ctor.md:1 @@ -916,12 +805,10 @@ msgstr "## Descrizione\r" #, fuzzy msgid "" "Rust does not have constructors as a language construct. Instead, the\r\n" -"convention is to use an [associated function][associated function] `new` to " -"create an object:" +"convention is to use an [associated function][associated function] `new` to create an object:" msgstr "" "Rust non ha costruttori come costrutto del linguaggio. Invece il\r\n" -"convenzione è usare una [funzione associata][funzione associata] `new` per " -"creare un oggetto:" +"convenzione è usare una [funzione associata][funzione associata] `new` per creare un oggetto:" #: src\idioms/ctor.md:8 msgid "" @@ -960,11 +847,8 @@ msgstr "## Costruttori predefiniti\r" #: src\idioms/ctor.md:37 #, fuzzy -msgid "" -"Rust supports default constructors with the [`Default`][std-default] trait:" -msgstr "" -"Rust supporta i costruttori predefiniti con il tratto " -"[`Default`][std-default]:" +msgid "Rust supports default constructors with the [`Default`][std-default] trait:" +msgstr "Rust supporta i costruttori predefiniti con il tratto [`Default`][std-default]:" #: src\idioms/ctor.md:39 msgid "" @@ -999,12 +883,10 @@ msgstr "" #: src\idioms/ctor.md:66 #, fuzzy msgid "" -"`Default` can also be derived if all types of all fields implement " -"`Default`,\r\n" +"`Default` can also be derived if all types of all fields implement `Default`,\r\n" "like they do with `Second`:" msgstr "" -"`Default` può anche essere derivato se tutti i tipi di tutti i campi " -"implementano `Default`,\r\n" +"`Default` può anche essere derivato se tutti i tipi di tutti i campi implementano `Default`,\r\n" "come fanno con `Secondo`:" #: src\idioms/ctor.md:69 @@ -1050,18 +932,13 @@ msgstr "" #: src\idioms/ctor.md:97 #, fuzzy msgid "" -"**Hint:** The advantage of implementing or deriving `Default` is that your " -"type\r\n" -"can now be used where a `Default` implementation is required, most " -"prominently,\r\n" +"**Hint:** The advantage of implementing or deriving `Default` is that your type\r\n" +"can now be used where a `Default` implementation is required, most prominently,\r\n" "any of the [`*or_default` functions in the standard library][std-or-default]." msgstr "" -"**Suggerimento:** il vantaggio di implementare o derivare `Default` è che il " -"tuo tipo\r\n" -"ora può essere utilizzato dove è richiesta un'implementazione `Default`, " -"soprattutto,\r\n" -"qualsiasi delle [funzioni `*or_default` nella libreria " -"standard][std-or-default]." +"**Suggerimento:** il vantaggio di implementare o derivare `Default` è che il tuo tipo\r\n" +"ora può essere utilizzato dove è richiesta un'implementazione `Default`, soprattutto,\r\n" +"qualsiasi delle [funzioni `*or_default` nella libreria standard][std-or-default]." #: src\idioms/ctor.md:101 #, fuzzy @@ -1074,20 +951,17 @@ msgid "" "- The [default idiom](default.md) for a more in-depth description of the\r\n" " `Default` trait.\r\n" "\r\n" -"- The [builder pattern](../patterns/creational/builder.md) for " -"constructing\r\n" +"- The [builder pattern](../patterns/creational/builder.md) for constructing\r\n" " objects where there are multiple configurations.\r\n" "\r\n" "- [API Guidelines/C-COMMON-TRAITS][API Guidelines/C-COMMON-TRAITS] for\r\n" " implementing both, `Default` and `new`.\r\n" "\r" msgstr "" -"- L'[idioma predefinito](default.md) per una descrizione più approfondita " -"del file\r\n" +"- L'[idioma predefinito](default.md) per una descrizione più approfondita del file\r\n" " Tratto `Predefinito`.\r\n" "\r\n" -"- Il [modello builder](../patterns/creational/builder.md) per la " -"costruzione\r\n" +"- Il [modello builder](../patterns/creational/builder.md) per la costruzione\r\n" " oggetti in cui sono presenti più configurazioni.\r\n" "\r\n" "- [Linee guida API/C-COMMON-TRAITS][Linee guida API/C-COMMON-TRAITS] per\r\n" @@ -1102,11 +976,9 @@ msgstr "# Il tratto `Predefinito`" #: src\idioms/default.md:5 msgid "" "Many types in Rust have a [constructor]. However, this is _specific_ to the\n" -"type; Rust cannot abstract over \"everything that has a `new()` method\". " -"To\n" +"type; Rust cannot abstract over \"everything that has a `new()` method\". To\n" "allow this, the [`Default`] trait was conceived, which can be used with\n" -"containers and other generic types (e.g. see " -"[`Option::unwrap_or_default()`]).\n" +"containers and other generic types (e.g. see [`Option::unwrap_or_default()`]).\n" "Notably, some containers already implement it where applicable." msgstr "" @@ -1120,8 +992,7 @@ msgid "" msgstr "" "Non solo i contenitori a un elemento come `Cow`, `Box` o `Arc` implementano\n" "`Default` per i tipi `Default` contenuti, si può automaticamente\n" -"`#[derive(Default)]` per struct i cui campi lo implementano tutti, quindi " -"more\n" +"`#[derive(Default)]` per struct i cui campi lo implementano tutti, quindi more\n" "i tipi implementano `Default`, più diventa utile." #: src\idioms/default.md:16 @@ -1164,8 +1035,7 @@ msgid "" " conf.check = true;\n" " println!(\"conf = {:#?}\", conf);\n" " \n" -" // partial initialization with default values, creates the same " -"instance\n" +" // partial initialization with default values, creates the same instance\n" " let conf1 = MyConfiguration {\n" " check: true,\n" " ..Default::default()\n" @@ -1178,18 +1048,15 @@ msgstr "" #: src\idioms/default.md:60 #, fuzzy msgid "" -"- The [constructor] idiom is another way to generate instances that may or " -"may\n" +"- The [constructor] idiom is another way to generate instances that may or may\n" " not be \"default\"\n" "- The [`Default`] documentation (scroll down for the list of implementors)\n" "- [`Option::unwrap_or_default()`]\n" "- [`derive(new)`]" msgstr "" -"- L'idioma [costruttore] è un altro modo per generare istanze che possono o " -"possono\n" +"- L'idioma [costruttore] è un altro modo per generare istanze che possono o possono\n" " non essere \"predefinito\"\n" -"- La documentazione [`Default`] (scorrere verso il basso per l'elenco degli " -"implementatori)\n" +"- La documentazione [`Default`] (scorrere verso il basso per l'elenco degli implementatori)\n" "- [`Opzione::unwrap_or_default()`]\n" "- [`deriva(nuovo)`]" @@ -1206,8 +1073,7 @@ msgid "" "and borrowed views of data." msgstr "" "Usa [`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)\n" -"tratto per trattare le raccolte come puntatori intelligenti, offrendo la " -"proprietà\n" +"tratto per trattare le raccolte come puntatori intelligenti, offrendo la proprietà\n" "e viste prese in prestito dei dati." #: src\idioms/deref.md:11 @@ -1233,22 +1099,16 @@ msgstr "" #: src\idioms/deref.md:28 #, fuzzy msgid "" -"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a " -"borrowed\n" -"collection of `T`s. Implementing `Deref` for `Vec` allows implicit " -"dereferencing\n" +"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a borrowed\n" +"collection of `T`s. Implementing `Deref` for `Vec` allows implicit dereferencing\n" "from `&Vec` to `&[T]` and includes the relationship in auto-derefencing\n" -"searches. Most methods you might expect to be implemented for `Vec`s are " -"instead\n" +"searches. Most methods you might expect to be implemented for `Vec`s are instead\n" "implemented for slices." msgstr "" -"Un `Vec` è una raccolta proprietaria di `T`, mentre una slice (`&[T]`) è " -"un oggetto preso in prestito\n" -"raccolta di `T`s. L'implementazione di \"Deref\" per \"Vec\" consente la " -"dereferenziazione implicita\n" +"Un `Vec` è una raccolta proprietaria di `T`, mentre una slice (`&[T]`) è un oggetto preso in prestito\n" +"raccolta di `T`s. L'implementazione di \"Deref\" per \"Vec\" consente la dereferenziazione implicita\n" "da `&Vec` a `&[T]` e include la relazione nell'auto-derefencing\n" -"ricerche. La maggior parte dei metodi che potresti aspettarti di essere " -"implementati per `Vec`s lo sono invece\n" +"ricerche. La maggior parte dei metodi che potresti aspettarti di essere implementati per `Vec`s lo sono invece\n" "implementato per le fette." #: src\idioms/deref.md:34 @@ -1256,18 +1116,12 @@ msgstr "" msgid "Also `String` and `&str` have a similar relation." msgstr "Anche `String` e `&str` hanno una relazione simile." -#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 -#: src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 -#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 -#: src\idioms/return-consumed-arg-on-error.md:43 -#: src\patterns/behavioural/command.md:8 -#: src\patterns/behavioural/interpreter.md:16 -#: src\patterns/behavioural/newtype.md:56 src\patterns/behavioural/RAII.md:72 -#: src\patterns/behavioural/strategy.md:19 -#: src\patterns/behavioural/visitor.md:72 src\patterns/creational/builder.md:63 -#: src\patterns/creational/fold.md:73 -#: src\patterns/structural/compose-structs.md:71 src\patterns/ffi/export.md:15 -#: src\anti_patterns/borrow_clone.md:30 +#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 +#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 src\idioms/return-consumed-arg-on-error.md:43 +#: src\patterns/behavioural/command.md:8 src\patterns/behavioural/interpreter.md:16 src\patterns/behavioural/newtype.md:56 +#: src\patterns/behavioural/RAII.md:72 src\patterns/behavioural/strategy.md:19 src\patterns/behavioural/visitor.md:72 +#: src\patterns/creational/builder.md:63 src\patterns/creational/fold.md:73 src\patterns/structural/compose-structs.md:71 +#: src\patterns/ffi/export.md:15 src\anti_patterns/borrow_clone.md:30 #, fuzzy msgid "## Motivation" msgstr "## Motivazione" @@ -1275,19 +1129,14 @@ msgstr "## Motivazione" #: src\idioms/deref.md:38 #, fuzzy msgid "" -"Ownership and borrowing are key aspects of the Rust language. Data " -"structures\n" +"Ownership and borrowing are key aspects of the Rust language. Data structures\n" "must account for these semantics properly to give a good user\n" -"experience. When implementing a data structure that owns its data, offering " -"a\n" +"experience. When implementing a data structure that owns its data, offering a\n" "borrowed view of that data allows for more flexible APIs." msgstr "" -"La proprietà e il prestito sono aspetti chiave del linguaggio Rust. " -"Strutture dati\n" -"deve tenere conto di queste semantiche correttamente per dare un buon " -"utente\n" -"esperienza. Quando si implementa una struttura dati che possiede i suoi " -"dati, offrendo a\n" +"La proprietà e il prestito sono aspetti chiave del linguaggio Rust. Strutture dati\n" +"deve tenere conto di queste semantiche correttamente per dare un buon utente\n" +"esperienza. Quando si implementa una struttura dati che possiede i suoi dati, offrendo a\n" "vista presa in prestito di tali dati consente API più flessibili." #: src\idioms/deref.md:45 @@ -1296,40 +1145,29 @@ msgid "" "Most methods can be implemented only for the borrowed view, they are then\n" "implicitly available for the owning view." msgstr "" -"La maggior parte dei metodi può essere implementata solo per la vista presa " -"in prestito, allora lo sono\n" +"La maggior parte dei metodi può essere implementata solo per la vista presa in prestito, allora lo sono\n" "implicitamente disponibile per la vista proprietaria." #: src\idioms/deref.md:48 #, fuzzy msgid "Gives clients a choice between borrowing or taking ownership of data." -msgstr "" -"Offre ai clienti la scelta tra prendere in prestito o assumere la proprietà " -"dei dati." +msgstr "Offre ai clienti la scelta tra prendere in prestito o assumere la proprietà dei dati." #: src\idioms/deref.md:52 #, fuzzy msgid "" -"Methods and traits only available via dereferencing are not taken into " -"account\n" -"when bounds checking, so generic programming with data structures using " -"this\n" +"Methods and traits only available via dereferencing are not taken into account\n" +"when bounds checking, so generic programming with data structures using this\n" "pattern can get complex (see the `Borrow` and `AsRef` traits, etc.)." msgstr "" -"I metodi e i tratti disponibili solo tramite dereferenziazione non vengono " -"presi in considerazione\n" -"durante il controllo dei limiti, quindi programmazione generica con " -"strutture di dati che utilizzano this\n" +"I metodi e i tratti disponibili solo tramite dereferenziazione non vengono presi in considerazione\n" +"durante il controllo dei limiti, quindi programmazione generica con strutture di dati che utilizzano this\n" "pattern può diventare complesso (vedi i tratti `Borrow` e `AsRef`, ecc.)." -#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 -#: src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 -#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 -#: src\patterns/behavioural/interpreter.md:103 -#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 -#: src\patterns/behavioural/strategy.md:110 -#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 -#: src\patterns/creational/fold.md:85 +#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 +#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 src\patterns/behavioural/interpreter.md:103 +#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 src\patterns/behavioural/strategy.md:110 +#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 src\patterns/creational/fold.md:85 #: src\patterns/structural/compose-structs.md:89 src\anti_patterns/deref.md:102 #, fuzzy msgid "## Discussion" @@ -1338,77 +1176,56 @@ msgstr "## Discussione" #: src\idioms/deref.md:58 #, fuzzy msgid "" -"Smart pointers and collections are analogous: a smart pointer points to a " -"single\n" -"object, whereas a collection points to many objects. From the point of view " -"of\n" -"the type system, there is little difference between the two. A collection " -"owns\n" +"Smart pointers and collections are analogous: a smart pointer points to a single\n" +"object, whereas a collection points to many objects. From the point of view of\n" +"the type system, there is little difference between the two. A collection owns\n" "its data if the only way to access each datum is via the collection and the\n" "collection is responsible for deleting the data (even in cases of shared\n" -"ownership, some kind of borrowed view may be appropriate). If a collection " -"owns\n" -"its data, it is usually useful to provide a view of the data as borrowed so " -"that\n" +"ownership, some kind of borrowed view may be appropriate). If a collection owns\n" +"its data, it is usually useful to provide a view of the data as borrowed so that\n" "it can be referenced multiple times." msgstr "" -"I puntatori intelligenti e le raccolte sono analoghi: un puntatore " -"intelligente punta a un singolo\n" +"I puntatori intelligenti e le raccolte sono analoghi: un puntatore intelligente punta a un singolo\n" "oggetto, mentre una raccolta punta a molti oggetti. Dal punto di vista di\n" "il sistema di tipo, c'è poca differenza tra i due. Una collezione possiede\n" -"i suoi dati se l'unico modo per accedere a ciascun dato è attraverso la " -"raccolta e il\n" -"collection è responsabile della cancellazione dei dati (anche in caso di " -"shared\n" -"proprietà, potrebbe essere appropriato un qualche tipo di visione presa in " -"prestito). Se una collezione possiede\n" -"suoi dati, di solito è utile fornire una vista dei dati presi in prestito in " -"modo che\n" +"i suoi dati se l'unico modo per accedere a ciascun dato è attraverso la raccolta e il\n" +"collection è responsabile della cancellazione dei dati (anche in caso di shared\n" +"proprietà, potrebbe essere appropriato un qualche tipo di visione presa in prestito). Se una collezione possiede\n" +"suoi dati, di solito è utile fornire una vista dei dati presi in prestito in modo che\n" "può essere referenziato più volte." #: src\idioms/deref.md:67 #, fuzzy msgid "" "Most smart pointers (e.g., `Foo`) implement `Deref`. However,\n" -"collections will usually dereference to a custom type. `[T]` and `str` have " -"some\n" -"language support, but in the general case, this is not necessary. `Foo` " -"can\n" -"implement `Deref>` where `Bar` is a dynamically sized type " -"and\n" +"collections will usually dereference to a custom type. `[T]` and `str` have some\n" +"language support, but in the general case, this is not necessary. `Foo` can\n" +"implement `Deref>` where `Bar` is a dynamically sized type and\n" "`&Bar` is a borrowed view of the data in `Foo`." msgstr "" -"La maggior parte dei puntatori intelligenti (ad esempio, `Foo`) " -"implementano `Deref`. Tuttavia,\n" -"le collezioni di solito fanno riferimento a un tipo personalizzato. `[T]` e " -"`str` ne hanno alcuni\n" -"supporto linguistico, ma nel caso generale questo non è necessario. `Foo` " -"può\n" -"implementa `Deref>` dove `Bar` è un tipo dimensionato " -"dinamicamente e\n" +"La maggior parte dei puntatori intelligenti (ad esempio, `Foo`) implementano `Deref`. Tuttavia,\n" +"le collezioni di solito fanno riferimento a un tipo personalizzato. `[T]` e `str` ne hanno alcuni\n" +"supporto linguistico, ma nel caso generale questo non è necessario. `Foo` può\n" +"implementa `Deref>` dove `Bar` è un tipo dimensionato dinamicamente e\n" "`&Bar` è una vista presa in prestito dei dati in `Foo`." #: src\idioms/deref.md:73 #, fuzzy msgid "" -"Commonly, ordered collections will implement `Index` for `Range`s to " -"provide\n" +"Commonly, ordered collections will implement `Index` for `Range`s to provide\n" "slicing syntax. The target will be the borrowed view." msgstr "" -"Comunemente, le raccolte ordinate implementeranno `Index` per `Range`s da " -"fornire\n" +"Comunemente, le raccolte ordinate implementeranno `Index` per `Range`s da fornire\n" "sintassi per affettare. L'obiettivo sarà la vista presa in prestito." #: src\idioms/deref.md:78 #, fuzzy msgid "" "- [Deref polymorphism anti-pattern](../anti_patterns/deref.md).\n" -"- [Documentation for `Deref` " -"trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." msgstr "" "- [Deref polimorfismo anti-pattern](../anti_patterns/deref.md).\n" -"- [Documentazione per il tratto " -"`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentazione per il tratto `Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." #: src\idioms/dtor-finally.md:1 #, fuzzy @@ -1418,17 +1235,13 @@ msgstr "# Finalizzazione nei distruttori" #: src\idioms/dtor-finally.md:5 #, fuzzy msgid "" -"Rust does not provide the equivalent to `finally` blocks - code that will " -"be\n" -"executed no matter how a function is exited. Instead, an object's destructor " -"can\n" +"Rust does not provide the equivalent to `finally` blocks - code that will be\n" +"executed no matter how a function is exited. Instead, an object's destructor can\n" "be used to run code that must be run before exit." msgstr "" "Rust non fornisce l'equivalente dei blocchi `finally` - codice che sarà\n" -"eseguito indipendentemente da come si esce da una funzione. Invece, il " -"distruttore di un oggetto può farlo\n" -"essere utilizzato per eseguire il codice che deve essere eseguito prima " -"dell'uscita." +"eseguito indipendentemente da come si esce da una funzione. Invece, il distruttore di un oggetto può farlo\n" +"essere utilizzato per eseguire il codice che deve essere eseguito prima dell'uscita." #: src\idioms/dtor-finally.md:11 msgid "" @@ -1457,30 +1270,20 @@ msgstr "" #: src\idioms/dtor-finally.md:34 #, fuzzy msgid "" -"If a function has multiple return points, then executing code on exit " -"becomes\n" -"difficult and repetitive (and thus bug-prone). This is especially the case " -"where\n" +"If a function has multiple return points, then executing code on exit becomes\n" +"difficult and repetitive (and thus bug-prone). This is especially the case where\n" "return is implicit due to a macro. A common case is the `?` operator which\n" -"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used " -"as\n" -"an exception handling mechanism, but unlike Java (which has `finally`), " -"there is\n" +"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used as\n" +"an exception handling mechanism, but unlike Java (which has `finally`), there is\n" "no way to schedule code to run in both the normal and exceptional cases.\n" "Panicking will also exit a function early." msgstr "" -"Se una funzione ha più punti di ritorno, l'esecuzione del codice all'uscita " -"diventa\n" -"difficile e ripetitivo (e quindi soggetto a bug). Questo è particolarmente " -"vero dove\n" -"return è implicito a causa di una macro. Un caso comune è l'operatore `?` " -"which\n" -"restituisce se il risultato è \"Err\", ma continua se è \"Ok\". `?` è usato " -"come\n" -"un meccanismo di gestione delle eccezioni, ma a differenza di Java (che ha " -"\"finalmente\"), c'è\n" -"non c'è modo di programmare l'esecuzione del codice sia nei casi normali che " -"in quelli eccezionali.\n" +"Se una funzione ha più punti di ritorno, l'esecuzione del codice all'uscita diventa\n" +"difficile e ripetitivo (e quindi soggetto a bug). Questo è particolarmente vero dove\n" +"return è implicito a causa di una macro. Un caso comune è l'operatore `?` which\n" +"restituisce se il risultato è \"Err\", ma continua se è \"Ok\". `?` è usato come\n" +"un meccanismo di gestione delle eccezioni, ma a differenza di Java (che ha \"finalmente\"), c'è\n" +"non c'è modo di programmare l'esecuzione del codice sia nei casi normali che in quelli eccezionali.\n" "Anche il panico uscirà presto da una funzione." #: src\idioms/dtor-finally.md:44 @@ -1489,8 +1292,7 @@ msgid "" "Code in destructors will (nearly) always be run - copes with panics, early\n" "returns, etc." msgstr "" -"Il codice nei distruttori verrà (quasi) sempre eseguito - affronta il " -"panico, presto\n" +"Il codice nei distruttori verrà (quasi) sempre eseguito - affronta il panico, presto\n" "ritorni, ecc." #: src\idioms/dtor-finally.md:49 @@ -1499,89 +1301,61 @@ msgid "" "It is not guaranteed that destructors will run. For example, if there is an\n" "infinite loop in a function or if running a function crashes before exit.\n" "Destructors are also not run in the case of a panic in an already panicking\n" -"thread. Therefore, destructors cannot be relied on as finalizers where it " -"is\n" +"thread. Therefore, destructors cannot be relied on as finalizers where it is\n" "absolutely essential that finalisation happens." msgstr "" -"Non è garantito che i distruttori vengano eseguiti. Ad esempio, se esiste " -"un\n" -"ciclo infinito in una funzione o se l'esecuzione di una funzione si arresta " -"in modo anomalo prima dell'uscita.\n" -"Anche i distruttori non vengono eseguiti in caso di panico in una situazione " -"già in preda al panico\n" -"filo. Pertanto, non è possibile fare affidamento sui distruttori come " -"finalizzatori dove si trovano\n" +"Non è garantito che i distruttori vengano eseguiti. Ad esempio, se esiste un\n" +"ciclo infinito in una funzione o se l'esecuzione di una funzione si arresta in modo anomalo prima dell'uscita.\n" +"Anche i distruttori non vengono eseguiti in caso di panico in una situazione già in preda al panico\n" +"filo. Pertanto, non è possibile fare affidamento sui distruttori come finalizzatori dove si trovano\n" "assolutamente essenziale che avvenga la finalizzazione." #: src\idioms/dtor-finally.md:55 #, fuzzy msgid "" -"This pattern introduces some hard to notice, implicit code. Reading a " -"function\n" +"This pattern introduces some hard to notice, implicit code. Reading a function\n" "gives no clear indication of destructors to be run on exit. This can make\n" "debugging tricky." msgstr "" -"Questo modello introduce un codice implicito difficile da notare. Lettura di " -"una funzione\n" -"non fornisce alcuna chiara indicazione dei distruttori da eseguire " -"all'uscita. Questo può fare\n" +"Questo modello introduce un codice implicito difficile da notare. Lettura di una funzione\n" +"non fornisce alcuna chiara indicazione dei distruttori da eseguire all'uscita. Questo può fare\n" "debug complicato." #: src\idioms/dtor-finally.md:59 #, fuzzy -msgid "" -"Requiring an object and `Drop` impl just for finalisation is heavy on " -"boilerplate." -msgstr "" -"Richiedere un oggetto e \"Drop\" impl solo per la finalizzazione è pesante " -"sul boilerplate." +msgid "Requiring an object and `Drop` impl just for finalisation is heavy on boilerplate." +msgstr "Richiedere un oggetto e \"Drop\" impl solo per la finalizzazione è pesante sul boilerplate." #: src\idioms/dtor-finally.md:63 #, fuzzy msgid "" "There is some subtlety about how exactly to store the object used as a\n" -"finalizer. It must be kept alive until the end of the function and must then " -"be\n" -"destroyed. The object must always be a value or uniquely owned pointer " -"(e.g.,\n" -"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer " -"can\n" +"finalizer. It must be kept alive until the end of the function and must then be\n" +"destroyed. The object must always be a value or uniquely owned pointer (e.g.,\n" +"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer can\n" "be kept alive beyond the lifetime of the function. For similar reasons, the\n" "finalizer should not be moved or returned." msgstr "" -"C'è una certa sottigliezza su come memorizzare esattamente l'oggetto usato " -"come a\n" -"finalizzatore. Deve essere mantenuto in vita fino alla fine della funzione e " -"deve esserlo\n" -"distrutto. L'oggetto deve sempre essere un valore o un puntatore di " -"proprietà univoca (ad esempio,\n" -"`Box`). Se viene utilizzato un puntatore condiviso (come `Rc`), il " -"finalizzatore può farlo\n" -"essere mantenuto in vita oltre la durata della funzione. Per ragioni simili, " -"il\n" +"C'è una certa sottigliezza su come memorizzare esattamente l'oggetto usato come a\n" +"finalizzatore. Deve essere mantenuto in vita fino alla fine della funzione e deve esserlo\n" +"distrutto. L'oggetto deve sempre essere un valore o un puntatore di proprietà univoca (ad esempio,\n" +"`Box`). Se viene utilizzato un puntatore condiviso (come `Rc`), il finalizzatore può farlo\n" +"essere mantenuto in vita oltre la durata della funzione. Per ragioni simili, il\n" "finalizzatore non deve essere spostato o restituito." #: src\idioms/dtor-finally.md:70 #, fuzzy msgid "" -"The finalizer must be assigned into a variable, otherwise it will be " -"destroyed\n" -"immediately, rather than when it goes out of scope. The variable name must " -"start\n" -"with `_` if the variable is only used as a finalizer, otherwise the " -"compiler\n" -"will warn that the finalizer is never used. However, do not call the " -"variable\n" +"The finalizer must be assigned into a variable, otherwise it will be destroyed\n" +"immediately, rather than when it goes out of scope. The variable name must start\n" +"with `_` if the variable is only used as a finalizer, otherwise the compiler\n" +"will warn that the finalizer is never used. However, do not call the variable\n" "`_` with no suffix - in that case it will be destroyed immediately." msgstr "" -"Il finalizzatore deve essere assegnato in una variabile, altrimenti verrà " -"distrutto\n" -"immediatamente, piuttosto che quando esce dal campo di applicazione. Il nome " -"della variabile deve iniziare\n" -"con `_` se la variabile è usata solo come finalizzatore, altrimenti il " -"compilatore\n" -"avviserà che il finalizzatore non viene mai utilizzato. Tuttavia, non " -"chiamare la variabile\n" +"Il finalizzatore deve essere assegnato in una variabile, altrimenti verrà distrutto\n" +"immediatamente, piuttosto che quando esce dal campo di applicazione. Il nome della variabile deve iniziare\n" +"con `_` se la variabile è usata solo come finalizzatore, altrimenti il compilatore\n" +"avviserà che il finalizzatore non viene mai utilizzato. Tuttavia, non chiamare la variabile\n" "`_` senza suffisso - in tal caso verrà distrutto immediatamente." #: src\idioms/dtor-finally.md:76 @@ -1590,40 +1364,28 @@ msgid "" "In Rust, destructors are run when an object goes out of scope. This happens\n" "whether we reach the end of block, there is an early return, or the program\n" "panics. When panicking, Rust unwinds the stack running destructors for each\n" -"object in each stack frame. So, destructors get called even if the panic " -"happens\n" +"object in each stack frame. So, destructors get called even if the panic happens\n" "in a function being called." msgstr "" -"In Rust, i distruttori vengono eseguiti quando un oggetto esce dall'ambito. " -"Questo succede\n" -"se raggiungiamo la fine del blocco, c'è un ritorno anticipato o il " -"programma\n" -"panico. In preda al panico, Rust rimuove lo stack eseguendo i distruttori " -"per ciascuno\n" -"oggetto in ogni stack frame. Quindi, i distruttori vengono chiamati anche se " -"si verifica il panico\n" +"In Rust, i distruttori vengono eseguiti quando un oggetto esce dall'ambito. Questo succede\n" +"se raggiungiamo la fine del blocco, c'è un ritorno anticipato o il programma\n" +"panico. In preda al panico, Rust rimuove lo stack eseguendo i distruttori per ciascuno\n" +"oggetto in ogni stack frame. Quindi, i distruttori vengono chiamati anche se si verifica il panico\n" "in una funzione che viene chiamata." #: src\idioms/dtor-finally.md:82 #, fuzzy msgid "" -"If a destructor panics while unwinding, there is no good action to take, so " -"Rust\n" -"aborts the thread immediately, without running further destructors. This " -"means\n" -"that destructors are not absolutely guaranteed to run. It also means that " -"you\n" +"If a destructor panics while unwinding, there is no good action to take, so Rust\n" +"aborts the thread immediately, without running further destructors. This means\n" +"that destructors are not absolutely guaranteed to run. It also means that you\n" "must take extra care in your destructors not to panic, since it could leave\n" "resources in an unexpected state." msgstr "" -"Se un distruttore va nel panico mentre si rilassa, non c'è nessuna buona " -"azione da intraprendere, quindi Rust\n" -"interrompe immediatamente il thread, senza eseguire ulteriori distruttori. " -"Questo significa\n" -"che non è assolutamente garantito che i distruttori funzionino. Significa " -"anche che tu\n" -"devi prestare particolare attenzione ai tuoi distruttori per non farti " -"prendere dal panico, poiché potrebbe andarsene\n" +"Se un distruttore va nel panico mentre si rilassa, non c'è nessuna buona azione da intraprendere, quindi Rust\n" +"interrompe immediatamente il thread, senza eseguire ulteriori distruttori. Questo significa\n" +"che non è assolutamente garantito che i distruttori funzionino. Significa anche che tu\n" +"devi prestare particolare attenzione ai tuoi distruttori per non farti prendere dal panico, poiché potrebbe andarsene\n" "risorse in uno stato imprevisto." #: src\idioms/dtor-finally.md:90 @@ -1634,9 +1396,7 @@ msgstr "[Guardie RAII](../patterns/behavioural/RAII.md)." #: src\idioms/mem-replace.md:1 #, fuzzy msgid "# `mem::{take(_), replace(_)}` to keep owned values in changed enums" -msgstr "" -"# `mem::{take(_), replace(_)}` per mantenere i valori posseduti nelle enum " -"modificate" +msgstr "# `mem::{take(_), replace(_)}` per mantenere i valori posseduti nelle enum modificate" #: src\idioms/mem-replace.md:5 #, fuzzy @@ -1696,8 +1456,7 @@ msgid "" "fn swizzle(e: &mut MultiVariateEnum) {\n" " use MultiVariateEnum::*;\n" " *e = match e {\n" -" // Ownership rules do not allow taking `name` by value, but we " -"cannot\n" +" // Ownership rules do not allow taking `name` by value, but we cannot\n" " // take the value out of a mutable reference, unless we replace it:\n" " A { name } => B { name: mem::take(name) },\n" " B { name } => A { name: mem::take(name) },\n" @@ -1711,63 +1470,45 @@ msgstr "" #: src\idioms/mem-replace.md:59 #, fuzzy msgid "" -"When working with enums, we may want to change an enum value in place, " -"perhaps\n" +"When working with enums, we may want to change an enum value in place, perhaps\n" "to another variant. This is usually done in two phases to keep the borrow\n" -"checker happy. In the first phase, we observe the existing value and look " -"at\n" -"its parts to decide what to do next. In the second phase we may " -"conditionally\n" +"checker happy. In the first phase, we observe the existing value and look at\n" +"its parts to decide what to do next. In the second phase we may conditionally\n" "change the value (as in the example above)." msgstr "" -"Quando lavoriamo con gli enum, potremmo voler cambiare un valore enum sul " -"posto, forse\n" -"ad un'altra variante. Questo di solito viene fatto in due fasi per mantenere " -"il prestito\n" -"correttore felice. Nella prima fase, osserviamo il valore esistente e " -"guardiamo\n" -"sue parti per decidere cosa fare dopo. Nella seconda fase possiamo " -"condizionalmente\n" +"Quando lavoriamo con gli enum, potremmo voler cambiare un valore enum sul posto, forse\n" +"ad un'altra variante. Questo di solito viene fatto in due fasi per mantenere il prestito\n" +"correttore felice. Nella prima fase, osserviamo il valore esistente e guardiamo\n" +"sue parti per decidere cosa fare dopo. Nella seconda fase possiamo condizionalmente\n" "modificare il valore (come nell'esempio precedente)." #: src\idioms/mem-replace.md:65 #, fuzzy msgid "" "The borrow checker won't allow us to take out `name` of the enum (because\n" -"_something_ must be there.) We could of course `.clone()` name and put the " -"clone\n" -"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy " -"the borrow checker](../anti_patterns/borrow_clone.md) anti-pattern. Anyway, " -"we\n" +"_something_ must be there.) We could of course `.clone()` name and put the clone\n" +"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md) " +"anti-pattern. Anyway, we\n" "can avoid the extra allocation by changing `e` with only a mutable borrow." msgstr "" -"Il controllo del prestito non ci consentirà di eliminare il \"nome\" " -"dell'enumerazione (perché\n" -"_qualcosa_ deve esserci.) Potremmo ovviamente nominare `.clone()` e inserire " -"il clone\n" -"nel nostro `MyEnum::B`, ma sarebbe un'istanza dell'anti-pattern [Clone per " -"soddisfare il controllo del prestito](../anti_patterns/borrow_clone.md). " -"Comunque, noi\n" +"Il controllo del prestito non ci consentirà di eliminare il \"nome\" dell'enumerazione (perché\n" +"_qualcosa_ deve esserci.) Potremmo ovviamente nominare `.clone()` e inserire il clone\n" +"nel nostro `MyEnum::B`, ma sarebbe un'istanza dell'anti-pattern [Clone per soddisfare il controllo del prestito](../anti_patterns/" +"borrow_clone.md). Comunque, noi\n" "può evitare l'allocazione extra cambiando `e` solo con un prestito mutabile." #: src\idioms/mem-replace.md:70 #, fuzzy msgid "" -"`mem::take` lets us swap out the value, replacing it with it's default " -"value,\n" -"and returning the previous value. For `String`, the default value is an " -"empty\n" +"`mem::take` lets us swap out the value, replacing it with it's default value,\n" +"and returning the previous value. For `String`, the default value is an empty\n" "`String`, which does not need to allocate. As a result, we get the original\n" "`name` _as an owned value_. We can then wrap this in another enum." msgstr "" -"`mem::take` ci permette di scambiare il valore, sostituendolo con il suo " -"valore predefinito,\n" -"e restituendo il valore precedente. Per \"Stringa\", il valore predefinito è " -"vuoto\n" -"`String`, che non deve essere allocato. Di conseguenza, otteniamo " -"l'originale\n" -"`nome` _come valore di proprietà_. Possiamo quindi avvolgerlo in un altro " -"enum." +"`mem::take` ci permette di scambiare il valore, sostituendolo con il suo valore predefinito,\n" +"e restituendo il valore precedente. Per \"Stringa\", il valore predefinito è vuoto\n" +"`String`, che non deve essere allocato. Di conseguenza, otteniamo l'originale\n" +"`nome` _come valore di proprietà_. Possiamo quindi avvolgerlo in un altro enum." #: src\idioms/mem-replace.md:75 #, fuzzy @@ -1777,8 +1518,7 @@ msgid "" "`mem::replace(name, String::new())`." msgstr "" "**NOTA:** `mem::replace` è molto simile, ma ci permette di specificare cosa\n" -"sostituisci il valore con Un equivalente alla nostra riga `mem::take` " -"sarebbe\n" +"sostituisci il valore con Un equivalente alla nostra riga `mem::take` sarebbe\n" "`mem::replace(name, String::new())`." #: src\idioms/mem-replace.md:79 @@ -1794,11 +1534,8 @@ msgstr "" #: src\idioms/mem-replace.md:85 #, fuzzy -msgid "" -"Look ma, no allocation! Also you may feel like Indiana Jones while doing it." -msgstr "" -"Guarda mamma, nessuna allocazione! Inoltre potresti sentirti come Indiana " -"Jones mentre lo fai." +msgid "Look ma, no allocation! Also you may feel like Indiana Jones while doing it." +msgstr "Guarda mamma, nessuna allocazione! Inoltre potresti sentirti come Indiana Jones mentre lo fai." #: src\idioms/mem-replace.md:89 #, fuzzy @@ -1809,65 +1546,52 @@ msgid "" "languages." msgstr "" "Questo diventa un po' prolisso. Sbagliare ripetutamente ti farà odiare il\n" -"controllore in prestito. Il compilatore potrebbe non riuscire a ottimizzare " -"il doppio archivio,\n" -"con conseguente riduzione delle prestazioni rispetto a ciò che faresti in " -"condizioni non sicure\n" +"controllore in prestito. Il compilatore potrebbe non riuscire a ottimizzare il doppio archivio,\n" +"con conseguente riduzione delle prestazioni rispetto a ciò che faresti in condizioni non sicure\n" "le lingue." #: src\idioms/mem-replace.md:94 #, fuzzy msgid "" -"Furthermore, the type you are taking needs to implement the [`Default` " -"trait](./default.md). However, if the type you're working with doesn't\n" +"Furthermore, the type you are taking needs to implement the [`Default` trait](./default.md). However, if the type you're working with " +"doesn't\n" "implement this, you can instead use `mem::replace`." msgstr "" -"Inoltre, il tipo che stai prendendo deve implementare il [tratto " -"`Default`](./default.md). Tuttavia, se il tipo con cui stai lavorando non lo " -"fa\n" +"Inoltre, il tipo che stai prendendo deve implementare il [tratto `Default`](./default.md). Tuttavia, se il tipo con cui stai lavorando " +"non lo fa\n" "implementarlo, puoi invece usare `mem::replace`." #: src\idioms/mem-replace.md:99 #, fuzzy msgid "" "This pattern is only of interest in Rust. In GC'd languages, you'd take the\n" -"reference to the value by default (and the GC would keep track of refs), and " -"in\n" -"other low-level languages like C you'd simply alias the pointer and fix " -"things\n" +"reference to the value by default (and the GC would keep track of refs), and in\n" +"other low-level languages like C you'd simply alias the pointer and fix things\n" "later." msgstr "" "Questo schema interessa solo Rust. Nelle lingue GC, prenderesti il\n" -"riferimento al valore per impostazione predefinita (e il GC terrà traccia " -"dei riferimenti), e in\n" -"altri linguaggi di basso livello come C avresti semplicemente alias il " -"puntatore e aggiustato le cose\n" +"riferimento al valore per impostazione predefinita (e il GC terrà traccia dei riferimenti), e in\n" +"altri linguaggi di basso livello come C avresti semplicemente alias il puntatore e aggiustato le cose\n" "Dopo." #: src\idioms/mem-replace.md:104 #, fuzzy msgid "" -"However, in Rust, we have to do a little more work to do this. An owned " -"value\n" -"may only have one owner, so to take it out, we need to put something back in " -"–\n" +"However, in Rust, we have to do a little more work to do this. An owned value\n" +"may only have one owner, so to take it out, we need to put something back in –\n" "like Indiana Jones, replacing the artifact with a bag of sand." msgstr "" -"Tuttavia, in Rust, dobbiamo fare un po' più di lavoro per farlo. Un valore " -"posseduto\n" -"potrebbe avere un solo proprietario, quindi per toglierlo dobbiamo " -"rimetterci qualcosa...\n" +"Tuttavia, in Rust, dobbiamo fare un po' più di lavoro per farlo. Un valore posseduto\n" +"potrebbe avere un solo proprietario, quindi per toglierlo dobbiamo rimetterci qualcosa...\n" "come Indiana Jones, sostituendo il manufatto con un sacco di sabbia." #: src\idioms/mem-replace.md:110 #, fuzzy msgid "" -"This gets rid of the [Clone to satisfy the borrow " -"checker](../anti_patterns/borrow_clone.md)\n" +"This gets rid of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md)\n" "anti-pattern in a specific case." msgstr "" -"Questo elimina [Clone per soddisfare il controllo del " -"prestito](../anti_patterns/borrow_clone.md)\n" +"Questo elimina [Clone per soddisfare il controllo del prestito](../anti_patterns/borrow_clone.md)\n" "anti-pattern in un caso specifico." #: src\idioms/on-stack-dyn-dispatch.md:1 @@ -1878,20 +1602,14 @@ msgstr "# Invio dinamico in pila" #: src\idioms/on-stack-dyn-dispatch.md:5 #, fuzzy msgid "" -"We can dynamically dispatch over multiple values, however, to do so, we " -"need\n" -"to declare multiple variables to bind differently-typed objects. To extend " -"the\n" -"lifetime as necessary, we can use deferred conditional initialization, as " -"seen\n" +"We can dynamically dispatch over multiple values, however, to do so, we need\n" +"to declare multiple variables to bind differently-typed objects. To extend the\n" +"lifetime as necessary, we can use deferred conditional initialization, as seen\n" "below:" msgstr "" -"Possiamo spedire dinamicamente su più valori, tuttavia, per farlo, abbiamo " -"bisogno\n" -"per dichiarare più variabili per associare oggetti tipizzati in modo " -"diverso. Per estendere il\n" -"lifetime se necessario, possiamo usare l'inizializzazione condizionale " -"differita, come visto\n" +"Possiamo spedire dinamicamente su più valori, tuttavia, per farlo, abbiamo bisogno\n" +"per dichiarare più variabili per associare oggetti tipizzati in modo diverso. Per estendere il\n" +"lifetime se necessario, possiamo usare l'inizializzazione condizionale differita, come visto\n" "sotto:" #: src\idioms/on-stack-dyn-dispatch.md:12 @@ -1926,33 +1644,24 @@ msgstr "" #, fuzzy msgid "" "Rust monomorphises code by default. This means a copy of the code will be\n" -"generated for each type it is used with and optimized independently. While " -"this\n" -"allows for very fast code on the hot path, it also bloats the code in " -"places\n" -"where performance is not of the essence, thus costing compile time and " -"cache\n" +"generated for each type it is used with and optimized independently. While this\n" +"allows for very fast code on the hot path, it also bloats the code in places\n" +"where performance is not of the essence, thus costing compile time and cache\n" "usage." msgstr "" -"Rust monomorfizza il codice per impostazione predefinita. Ciò significa che " -"una copia del codice sarà\n" -"generato per ogni tipo con cui viene utilizzato e ottimizzato in modo " -"indipendente. Mentre questo\n" -"consente un codice molto veloce sul percorso caldo, inoltre gonfia il codice " -"in alcuni punti\n" -"dove le prestazioni non sono essenziali, costando così tempo di compilazione " -"e cache\n" +"Rust monomorfizza il codice per impostazione predefinita. Ciò significa che una copia del codice sarà\n" +"generato per ogni tipo con cui viene utilizzato e ottimizzato in modo indipendente. Mentre questo\n" +"consente un codice molto veloce sul percorso caldo, inoltre gonfia il codice in alcuni punti\n" +"dove le prestazioni non sono essenziali, costando così tempo di compilazione e cache\n" "utilizzo." #: src\idioms/on-stack-dyn-dispatch.md:45 #, fuzzy msgid "" -"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly " -"ask\n" +"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly ask\n" "for it." msgstr "" -"Fortunatamente, Rust ci consente di utilizzare l'invio dinamico, ma dobbiamo " -"chiedere esplicitamente\n" +"Fortunatamente, Rust ci consente di utilizzare l'invio dinamico, ma dobbiamo chiedere esplicitamente\n" "per questo." #: src\idioms/on-stack-dyn-dispatch.md:50 @@ -1963,15 +1672,13 @@ msgid "" "whole code that follows to work with both `File` or `Stdin`." msgstr "" "Non è necessario allocare nulla nell'heap. Nemmeno noi ne abbiamo bisogno\n" -"inizializzare qualcosa che non useremo in seguito, né abbiamo bisogno di " -"monomorfizzare il\n" +"inizializzare qualcosa che non useremo in seguito, né abbiamo bisogno di monomorfizzare il\n" "tutto il codice che segue per funzionare sia con `File` che con `Stdin`." #: src\idioms/on-stack-dyn-dispatch.md:56 #, fuzzy msgid "The code needs more moving parts than the `Box`-based version:" -msgstr "" -"Il codice richiede più parti mobili rispetto alla versione basata su `Box`:" +msgstr "Il codice richiede più parti mobili rispetto alla versione basata su `Box`:" #: src\idioms/on-stack-dyn-dispatch.md:58 msgid "" @@ -1991,20 +1698,14 @@ msgstr "" msgid "" "Rust newcomers will usually learn that Rust requires all variables to be\n" "initialized _before use_, so it's easy to overlook the fact that _unused_\n" -"variables may well be uninitialized. Rust works quite hard to ensure that " -"this\n" -"works out fine and only the initialized values are dropped at the end of " -"their\n" +"variables may well be uninitialized. Rust works quite hard to ensure that this\n" +"works out fine and only the initialized values are dropped at the end of their\n" "scope." msgstr "" -"I nuovi arrivati di Rust di solito impareranno che Rust richiede che tutte " -"le variabili siano\n" -"inizializzato _prima dell'uso_, quindi è facile trascurare il fatto che _non " -"utilizzato_\n" -"le variabili potrebbero essere non inizializzate. Rust lavora molto " -"duramente per garantire che ciò avvenga\n" -"funziona bene e solo i valori inizializzati vengono eliminati alla fine del " -"loro\n" +"I nuovi arrivati di Rust di solito impareranno che Rust richiede che tutte le variabili siano\n" +"inizializzato _prima dell'uso_, quindi è facile trascurare il fatto che _non utilizzato_\n" +"le variabili potrebbero essere non inizializzate. Rust lavora molto duramente per garantire che ciò avvenga\n" +"funziona bene e solo i valori inizializzati vengono eliminati alla fine del loro\n" "scopo." #: src\idioms/on-stack-dyn-dispatch.md:76 @@ -2016,41 +1717,30 @@ msgstr "L'esempio soddisfa tutti i vincoli che Rust ci impone:" #, fuzzy msgid "" "- All variables are initialized before using (in this case borrowing) them\n" -"- Each variable only holds values of a single type. In our example, `stdin` " -"is\n" -" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut " -"dyn Read`\n" +"- Each variable only holds values of a single type. In our example, `stdin` is\n" +" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut dyn Read`\n" "- Each borrowed value outlives all the references borrowed from it" msgstr "" -"- Tutte le variabili vengono inizializzate prima di utilizzarle (in questo " -"caso prendendole in prestito).\n" -"- Ogni variabile contiene solo valori di un singolo tipo. Nel nostro " -"esempio, `stdin` è\n" -" di tipo `Stdin`, `file` è di tipo `File` e `readable` è di tipo `&mut dyn " -"Read`\n" -"- Ogni valore preso in prestito sopravvive a tutti i riferimenti presi in " -"prestito da esso" +"- Tutte le variabili vengono inizializzate prima di utilizzarle (in questo caso prendendole in prestito).\n" +"- Ogni variabile contiene solo valori di un singolo tipo. Nel nostro esempio, `stdin` è\n" +" di tipo `Stdin`, `file` è di tipo `File` e `readable` è di tipo `&mut dyn Read`\n" +"- Ogni valore preso in prestito sopravvive a tutti i riferimenti presi in prestito da esso" #: src\idioms/on-stack-dyn-dispatch.md:85 #, fuzzy msgid "" "- [Finalisation in destructors](dtor-finally.md) and\n" -" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight " -"control over\n" +" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight control over\n" " lifetimes.\n" "- For conditionally filled `Option<&T>`s of (mutable) references, one can\n" -" initialize an `Option` directly and use its [`.as_ref()`] method to get " -"an\n" +" initialize an `Option` directly and use its [`.as_ref()`] method to get an\n" " optional reference." msgstr "" "- [Finalizzazione nei distruttori](dtor-finally.md) e\n" -" [Le guardie RAII](../patterns/behavioural/RAII.md) possono beneficiare di " -"uno stretto controllo su\n" +" [Le guardie RAII](../patterns/behavioural/RAII.md) possono beneficiare di uno stretto controllo su\n" " vite.\n" -"- Per i riferimenti `Option<&T>` riempiti in modo condizionale di " -"riferimenti (mutabili), si può\n" -" inizializzare un `Option` direttamente e utilizzare il suo metodo " -"[`.as_ref()`] per ottenere un\n" +"- Per i riferimenti `Option<&T>` riempiti in modo condizionale di riferimenti (mutabili), si può\n" +" inizializzare un `Option` direttamente e utilizzare il suo metodo [`.as_ref()`] per ottenere un\n" " riferimento facoltativo." #: src\idioms/ffi/intro.md:1 @@ -2066,16 +1756,13 @@ msgid "" "traps for inexperienced users of `unsafe` Rust." msgstr "" "Scrivere il codice FFI è un intero corso in sé.\n" -"Tuttavia, ci sono diversi idiomi qui che possono fungere da puntatori ed " -"evitare\n" +"Tuttavia, ci sono diversi idiomi qui che possono fungere da puntatori ed evitare\n" "trappole per utenti inesperti di \"non sicuro\" Rust." #: src\idioms/ffi/intro.md:7 #, fuzzy msgid "This section contains idioms that may be useful when doing FFI." -msgstr "" -"Questa sezione contiene espressioni idiomatiche che possono essere utili " -"quando si fa FFI." +msgstr "Questa sezione contiene espressioni idiomatiche che possono essere utili quando si fa FFI." #: src\idioms/ffi/intro.md:9 #, fuzzy @@ -2087,8 +1774,7 @@ msgid "" "\n" "3. [Passing Strings](./passing-strings.md) to FFI functions" msgstr "" -"1. [Errori idiomatici](./errors.md) - Gestione degli errori con codici " -"interi e\n" +"1. [Errori idiomatici](./errors.md) - Gestione degli errori con codici interi e\n" " valori di ritorno sentinella (come i puntatori `NULL`)\n" "\n" "2. [Accepting Strings](./accepting-strings.md) con codice non sicuro minimo\n" @@ -2107,42 +1793,33 @@ msgid "" "However, Rust's type system allows much more rich error information to be\n" "captured and propogated through a full type." msgstr "" -"In lingue straniere come il C, gli errori sono rappresentati da codici di " -"ritorno.\n" -"Tuttavia, il sistema di tipi di Rust consente di avere informazioni sugli " -"errori molto più ricche\n" +"In lingue straniere come il C, gli errori sono rappresentati da codici di ritorno.\n" +"Tuttavia, il sistema di tipi di Rust consente di avere informazioni sugli errori molto più ricche\n" "catturato e propagato attraverso un tipo completo." #: src\idioms/ffi/errors.md:9 #, fuzzy msgid "" -"This best practice shows different kinds of error codes, and how to expose " -"them\n" +"This best practice shows different kinds of error codes, and how to expose them\n" "in a usable way:" msgstr "" -"Questa procedura consigliata mostra diversi tipi di codici di errore e come " -"esporli\n" +"Questa procedura consigliata mostra diversi tipi di codici di errore e come esporli\n" "in modo utilizzabile:" #: src\idioms/ffi/errors.md:12 #, fuzzy msgid "" "1. Flat Enums should be converted to integers and returned as codes.\n" -"2. Structured Enums should be converted to an integer code with a string " -"error\n" +"2. Structured Enums should be converted to an integer code with a string error\n" " message for detail.\n" "3. Custom Error Types should become \"transparent\", with a C representation." msgstr "" -"1. Gli enum flat devono essere convertiti in numeri interi e restituiti come " -"codici.\n" -"2. Gli enum strutturati devono essere convertiti in un codice intero con un " -"errore di stringa\n" +"1. Gli enum flat devono essere convertiti in numeri interi e restituiti come codici.\n" +"2. Gli enum strutturati devono essere convertiti in un codice intero con un errore di stringa\n" " messaggio per i dettagli.\n" -"3. I tipi di errore personalizzati dovrebbero diventare \"trasparenti\", con " -"una rappresentazione C." +"3. I tipi di errore personalizzati dovrebbero diventare \"trasparenti\", con una rappresentazione C." -#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 -#: src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 +#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 #: src\patterns/ffi/wrappers.md:23 #, fuzzy msgid "## Code Example" @@ -2205,8 +1882,7 @@ msgid "" " ) -> *mut libc::c_char {\n" "\n" " let error: &DatabaseError = unsafe {\n" -" // SAFETY: pointer lifetime is greater than the current stack " -"frame\n" +" // SAFETY: pointer lifetime is greater than the current stack frame\n" " &*e\n" " };\n" "\n" @@ -2225,8 +1901,7 @@ msgid "" " let c_error = unsafe {\n" " // SAFETY: copying error_str to an allocated buffer with a NUL\n" " // character at the end\n" -" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as " -"*mut _;\n" +" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as *mut _;\n" "\n" " if malloc.is_null() {\n" " return std::ptr::null_mut();\n" @@ -2283,12 +1958,10 @@ msgstr "" #: src\idioms/ffi/errors.md:133 #, fuzzy msgid "" -"This ensures that the foreign language has clear access to error " -"information\n" +"This ensures that the foreign language has clear access to error information\n" "while not compromising the Rust code's API at all." msgstr "" -"Ciò garantisce che la lingua straniera abbia un chiaro accesso alle " -"informazioni sugli errori\n" +"Ciò garantisce che la lingua straniera abbia un chiaro accesso alle informazioni sugli errori\n" "pur non compromettendo affatto l'API del codice Rust." #: src\idioms/ffi/errors.md:138 @@ -2297,8 +1970,7 @@ msgid "" "It's a lot of typing, and some types may not be able to be converted easily\n" "to C." msgstr "" -"È un sacco di digitazione e alcuni tipi potrebbero non essere convertiti " -"facilmente\n" +"È un sacco di digitazione e alcuni tipi potrebbero non essere convertiti facilmente\n" "a c." #: src\idioms/ffi/accepting-strings.md:1 @@ -2309,71 +1981,53 @@ msgstr "# Accettazione di stringhe" #: src\idioms/ffi/accepting-strings.md:5 #, fuzzy msgid "" -"When accepting strings via FFI through pointers, there are two principles " -"that\n" +"When accepting strings via FFI through pointers, there are two principles that\n" "should be followed:" msgstr "" -"Quando si accettano stringhe tramite FFI tramite puntatori, esistono due " -"principi che\n" +"Quando si accettano stringhe tramite FFI tramite puntatori, esistono due principi che\n" "dovrebbe essere seguito:" #: src\idioms/ffi/accepting-strings.md:8 #, fuzzy msgid "" "1. Keep foreign strings \"borrowed\", rather than copying them directly.\n" -"2. Minimize the amount of complexity and `unsafe` code involved in " -"converting\n" +"2. Minimize the amount of complexity and `unsafe` code involved in converting\n" " from a C-style string to native Rust strings." msgstr "" -"1. Mantieni le stringhe straniere \"prese in prestito\", piuttosto che " -"copiarle direttamente.\n" -"2. Ridurre al minimo la complessità e il codice \"non sicuro\" coinvolti " -"nella conversione\n" +"1. Mantieni le stringhe straniere \"prese in prestito\", piuttosto che copiarle direttamente.\n" +"2. Ridurre al minimo la complessità e il codice \"non sicuro\" coinvolti nella conversione\n" " da una stringa in stile C alle stringhe Rust native." #: src\idioms/ffi/accepting-strings.md:14 #, fuzzy -msgid "" -"The strings used in C have different behaviours to those used in Rust, " -"namely:" -msgstr "" -"Le stringhe usate in C hanno comportamenti diversi da quelle usate in Rust, " -"ovvero:" +msgid "The strings used in C have different behaviours to those used in Rust, namely:" +msgstr "Le stringhe usate in C hanno comportamenti diversi da quelle usate in Rust, ovvero:" #: src\idioms/ffi/accepting-strings.md:16 #, fuzzy msgid "" "- C strings are null-terminated while Rust strings store their length\n" -"- C strings can contain any arbitrary non-zero byte while Rust strings must " -"be\n" +"- C strings can contain any arbitrary non-zero byte while Rust strings must be\n" " UTF-8\n" "- C strings are accessed and manipulated using `unsafe` pointer operations\n" " while interactions with Rust strings go through safe methods" msgstr "" -"- Le stringhe C hanno terminazione null mentre le stringhe Rust memorizzano " -"la loro lunghezza\n" -"- Le stringhe C possono contenere qualsiasi byte arbitrario diverso da zero " -"mentre le stringhe Rust devono esserlo\n" +"- Le stringhe C hanno terminazione null mentre le stringhe Rust memorizzano la loro lunghezza\n" +"- Le stringhe C possono contenere qualsiasi byte arbitrario diverso da zero mentre le stringhe Rust devono esserlo\n" " UTF-8\n" -"- Le stringhe C sono accessibili e manipolate usando operazioni di puntatore " -"`unsafe`\n" +"- Le stringhe C sono accessibili e manipolate usando operazioni di puntatore `unsafe`\n" " mentre le interazioni con le stringhe Rust passano attraverso metodi sicuri" #: src\idioms/ffi/accepting-strings.md:22 #, fuzzy msgid "" -"The Rust standard library comes with C equivalents of Rust's `String` and " -"`&str`\n" -"called `CString` and `&CStr`, that allow us to avoid a lot of the " -"complexity\n" +"The Rust standard library comes with C equivalents of Rust's `String` and `&str`\n" +"called `CString` and `&CStr`, that allow us to avoid a lot of the complexity\n" "and `unsafe` code involved in converting between C strings and Rust strings." msgstr "" -"La libreria standard di Rust viene fornita con gli equivalenti C di `String` " -"e `&str` di Rust\n" -"chiamate `CString` e `&CStr`, che ci permettono di evitare gran parte della " -"complessità\n" -"e il codice \"non sicuro\" coinvolto nella conversione tra stringhe C e " -"stringhe Rust." +"La libreria standard di Rust viene fornita con gli equivalenti C di `String` e `&str` di Rust\n" +"chiamate `CString` e `&CStr`, che ci permettono di evitare gran parte della complessità\n" +"e il codice \"non sicuro\" coinvolto nella conversione tra stringhe C e stringhe Rust." #: src\idioms/ffi/accepting-strings.md:26 #, fuzzy @@ -2381,8 +2035,7 @@ msgid "" "The `&CStr` type also allows us to work with borrowed data, meaning passing\n" "strings between Rust and C is a zero-cost operation." msgstr "" -"Il tipo `&CStr` ci permette anche di lavorare con dati presi in prestito, " -"ovvero di passaggio\n" +"Il tipo `&CStr` ci permette anche di lavorare con dati presi in prestito, ovvero di passaggio\n" "stringhe tra Rust e C è un'operazione a costo zero." #: src\idioms/ffi/accepting-strings.md:31 @@ -2438,15 +2091,13 @@ msgid "" " reference" msgstr "" "1. Il blocco \"non sicuro\" è il più piccolo possibile.\n" -"2. Il puntatore con una durata \"non tracciata\" diventa un condiviso " -"\"tracciato\".\n" +"2. Il puntatore con una durata \"non tracciata\" diventa un condiviso \"tracciato\".\n" " riferimento" #: src\idioms/ffi/accepting-strings.md:76 #, fuzzy msgid "Consider an alternative, where the string is actually copied:" -msgstr "" -"Considera un'alternativa, in cui la stringa viene effettivamente copiata:" +msgstr "Considera un'alternativa, in cui la stringa viene effettivamente copiata:" #: src\idioms/ffi/accepting-strings.md:78 msgid "" @@ -2455,8 +2106,7 @@ msgid "" "\n" " // other module content\n" "\n" -" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: " -"libc::c_int) {\n" +" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: libc::c_int) {\n" " // DO NOT USE THIS CODE.\n" " // IT IS UGLY, VERBOSE, AND CONTAINS A SUBTLE BUG.\n" "\n" @@ -2502,14 +2152,12 @@ msgstr "Questo codice è inferiore all'originale sotto due aspetti:" #: src\idioms/ffi/accepting-strings.md:122 #, fuzzy msgid "" -"1. There is much more `unsafe` code, and more importantly, more invariants " -"it\n" +"1. There is much more `unsafe` code, and more importantly, more invariants it\n" " must uphold.\n" "2. Due to the extensive arithmetic required, there is a bug in this version\n" " that cases Rust `undefined behaviour`." msgstr "" -"1. C'è molto più codice \"non sicuro\" e, cosa più importante, più " -"invarianti\n" +"1. C'è molto più codice \"non sicuro\" e, cosa più importante, più invarianti\n" " deve sostenere.\n" "2. A causa dell'ampia aritmetica richiesta, c'è un bug in questa versione\n" " che causa il \"comportamento indefinito\" di Rust." @@ -2517,51 +2165,41 @@ msgstr "" #: src\idioms/ffi/accepting-strings.md:127 #, fuzzy msgid "" -"The bug here is a simple mistake in pointer arithmetic: the string was " -"copied,\n" +"The bug here is a simple mistake in pointer arithmetic: the string was copied,\n" "all `msg_len` bytes of it. However, the `NUL` terminator at the end was not." msgstr "" -"Il bug qui è un semplice errore nell'aritmetica del puntatore: la stringa è " -"stata copiata,\n" -"tutti i byte `msg_len` di esso. Tuttavia, il terminatore \"NUL\" alla fine " -"non lo era." +"Il bug qui è un semplice errore nell'aritmetica del puntatore: la stringa è stata copiata,\n" +"tutti i byte `msg_len` di esso. Tuttavia, il terminatore \"NUL\" alla fine non lo era." #: src\idioms/ffi/accepting-strings.md:130 #, fuzzy msgid "" -"The Vector then had its size _set_ to the length of the _zero padded string_ " -"--\n" +"The Vector then had its size _set_ to the length of the _zero padded string_ --\n" "rather than _resized_ to it, which could have added a zero at the end.\n" "As a result, the last byte in the Vector is uninitialized memory.\n" "When the `CString` is created at the bottom of the block, its read of the\n" "Vector will cause `undefined behaviour`!" msgstr "" -"Il vettore aveva quindi la sua dimensione _impostata_ sulla lunghezza della " -"_stringa imbottita zero_ --\n" -"piuttosto che _ridimensionato_ ad esso, che avrebbe potuto aggiungere uno " -"zero alla fine.\n" +"Il vettore aveva quindi la sua dimensione _impostata_ sulla lunghezza della _stringa imbottita zero_ --\n" +"piuttosto che _ridimensionato_ ad esso, che avrebbe potuto aggiungere uno zero alla fine.\n" "Di conseguenza, l'ultimo byte nel vettore è memoria non inizializzata.\n" -"Quando \"CString\" viene creato nella parte inferiore del blocco, viene " -"letto il file\n" +"Quando \"CString\" viene creato nella parte inferiore del blocco, viene letto il file\n" "Il vettore causerà un `comportamento indefinito`!" #: src\idioms/ffi/accepting-strings.md:136 #, fuzzy msgid "" "Like many such issues, this would be difficult issue to track down.\n" -"Sometimes it would panic because the string was not `UTF-8`, sometimes it " -"would\n" +"Sometimes it would panic because the string was not `UTF-8`, sometimes it would\n" "put a weird character at the end of the string, sometimes it would just\n" "completely crash." msgstr "" -"Come molti di questi problemi, questo sarebbe un problema difficile da " -"rintracciare.\n" +"Come molti di questi problemi, questo sarebbe un problema difficile da rintracciare.\n" "A volte andava nel panico perché la stringa non era \"UTF-8\", a volte sì\n" "metti un carattere strano alla fine della stringa, a volte sarebbe solo\n" "crollare completamente." -#: src\idioms/ffi/accepting-strings.md:143 -#: src\idioms/ffi/passing-strings.md:105 +#: src\idioms/ffi/accepting-strings.md:143 src\idioms/ffi/passing-strings.md:105 #, fuzzy msgid "None?" msgstr "Nessuno?" @@ -2574,12 +2212,10 @@ msgstr "# Passaggio di stringhe" #: src\idioms/ffi/passing-strings.md:5 #, fuzzy msgid "" -"When passing strings to FFI functions, there are four principles that should " -"be\n" +"When passing strings to FFI functions, there are four principles that should be\n" "followed:" msgstr "" -"Quando si passano stringhe alle funzioni FFI, ci sono quattro principi che " -"dovrebbero essere\n" +"Quando si passano stringhe alle funzioni FFI, ci sono quattro principi che dovrebbero essere\n" "seguito:" #: src\idioms/ffi/passing-strings.md:8 @@ -2587,31 +2223,25 @@ msgstr "" msgid "" "1. Make the lifetime of owned strings as long as possible.\n" "2. Minimize `unsafe` code during the conversion.\n" -"3. If the C code can modify the string data, use `Vec` instead of " -"`CString`.\n" +"3. If the C code can modify the string data, use `Vec` instead of `CString`.\n" "4. Unless the Foreign Function API requires it, the ownership of the string\n" " should not transfer to the callee." msgstr "" "1. Aumentare il più possibile la durata delle stringhe possedute.\n" "2. Ridurre al minimo il codice \"non sicuro\" durante la conversione.\n" -"3. Se il codice C può modificare i dati della stringa, utilizzare \"Vec\" " -"invece di \"CString\".\n" -"4. A meno che l'API della funzione esterna non lo richieda, la proprietà " -"della stringa\n" +"3. Se il codice C può modificare i dati della stringa, utilizzare \"Vec\" invece di \"CString\".\n" +"4. A meno che l'API della funzione esterna non lo richieda, la proprietà della stringa\n" " non deve essere trasferito al chiamato." #: src\idioms/ffi/passing-strings.md:16 #, fuzzy msgid "" "Rust has built-in support for C-style strings with its `CString` and `CStr`\n" -"types. However, there are different approaches one can take with strings " -"that\n" +"types. However, there are different approaches one can take with strings that\n" "are being sent to a foreign function call from a Rust function." msgstr "" -"Rust ha il supporto integrato per le stringhe in stile C con i suoi " -"`CString` e `CStr`\n" -"tipi. Tuttavia, ci sono diversi approcci che si possono adottare con " -"stringhe che\n" +"Rust ha il supporto integrato per le stringhe in stile C con i suoi `CString` e `CStr`\n" +"tipi. Tuttavia, ci sono diversi approcci che si possono adottare con stringhe che\n" "vengono inviati a una chiamata di funzione esterna da una funzione Rust." #: src\idioms/ffi/passing-strings.md:20 @@ -2619,16 +2249,13 @@ msgstr "" msgid "" "The best practice is simple: use `CString` in such a way as to minimize\n" "`unsafe` code. However, a secondary caveat is that\n" -"_the object must live long enough_, meaning the lifetime should be " -"maximized.\n" -"In addition, the documentation explains that \"round-tripping\" a `CString` " -"after\n" +"_the object must live long enough_, meaning the lifetime should be maximized.\n" +"In addition, the documentation explains that \"round-tripping\" a `CString` after\n" "modification is UB, so additional work is necessary in that case." msgstr "" "La migliore pratica è semplice: usa `CString` in modo tale da minimizzare\n" "codice \"non sicuro\". Tuttavia, un avvertimento secondario è quello\n" -"_l'oggetto deve vivere abbastanza a lungo_, il che significa che la durata " -"dovrebbe essere massimizzata.\n" +"_l'oggetto deve vivere abbastanza a lungo_, il che significa che la durata dovrebbe essere massimizzata.\n" "Inoltre, la documentazione spiega che \"round-tripping\" a `CString` after\n" "la modifica è UB, quindi in tal caso è necessario ulteriore lavoro." @@ -2641,8 +2268,7 @@ msgid "" "\n" " extern \"C\" {\n" " fn seterr(message: *const libc::c_char);\n" -" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> " -"libc::c_int;\n" +" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> libc::c_int;\n" " }\n" "\n" " fn report_error_to_ffi>(\n" @@ -2651,8 +2277,7 @@ msgid "" " let c_err = std::ffi::CString::new(err.into())?;\n" "\n" " unsafe {\n" -" // SAFETY: calling an FFI whose documentation says the pointer " -"is\n" +" // SAFETY: calling an FFI whose documentation says the pointer is\n" " // const, so no modification should occur\n" " seterr(c_err.as_ptr());\n" " }\n" @@ -2709,8 +2334,7 @@ msgid "" "\n" " // other module content\n" "\n" -" fn report_error>(err: S) -> Result<(), " -"std::ffi::NulError> {\n" +" fn report_error>(err: S) -> Result<(), std::ffi::NulError> {\n" " unsafe {\n" " // SAFETY: whoops, this contains a dangling pointer!\n" " seterr(std::ffi::CString::new(err.into())?.as_ptr());\n" @@ -2725,34 +2349,25 @@ msgstr "" #, fuzzy msgid "" "This code will result in a dangling pointer, because the lifetime of the\n" -"`CString` is not extended by the pointer creation, unlike if a reference " -"were\n" +"`CString` is not extended by the pointer creation, unlike if a reference were\n" "created." msgstr "" -"Questo codice si tradurrà in un puntatore penzolante, perché la durata del " -"file\n" -"`CString` non viene esteso dalla creazione del puntatore, a differenza di un " -"riferimento\n" +"Questo codice si tradurrà in un puntatore penzolante, perché la durata del file\n" +"`CString` non viene esteso dalla creazione del puntatore, a differenza di un riferimento\n" "creato." #: src\idioms/ffi/passing-strings.md:98 #, fuzzy msgid "" -"Another issue frequently raised is that the initialization of a 1k vector " -"of\n" +"Another issue frequently raised is that the initialization of a 1k vector of\n" "zeroes is \"slow\". However, recent versions of Rust actually optimize that\n" -"particular macro to a call to `zmalloc`, meaning it is as fast as the " -"operating\n" +"particular macro to a call to `zmalloc`, meaning it is as fast as the operating\n" "system's ability to return zeroed memory (which is quite fast)." msgstr "" -"Un altro problema spesso sollevato è che l'inizializzazione di un vettore 1k " -"di\n" -"zeri è \"lento\". Tuttavia, le versioni recenti di Rust lo ottimizzano " -"effettivamente\n" -"particolare macro a una chiamata a `zmalloc`, il che significa che è veloce " -"quanto l'operazione\n" -"la capacità del sistema di restituire la memoria azzerata (che è abbastanza " -"veloce)." +"Un altro problema spesso sollevato è che l'inizializzazione di un vettore 1k di\n" +"zeri è \"lento\". Tuttavia, le versioni recenti di Rust lo ottimizzano effettivamente\n" +"particolare macro a una chiamata a `zmalloc`, il che significa che è veloce quanto l'operazione\n" +"la capacità del sistema di restituire la memoria azzerata (che è abbastanza veloce)." #: src\idioms/option-iter.md:1 #, fuzzy @@ -2770,8 +2385,7 @@ msgstr "" "elemento. In particolare, implementa il tratto `IntoIterator`, e come tale\n" "può essere utilizzato con codice generico che necessita di tale tipo." -#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 -#: src\patterns/structural/unsafe-mods.md:22 +#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 src\patterns/structural/unsafe-mods.md:22 #, fuzzy msgid "## Examples" msgstr "## Esempi" @@ -2782,8 +2396,7 @@ msgid "" "Since `Option` implements `IntoIterator`, it can be used as an argument to\n" "[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" msgstr "" -"Poiché `Option` implementa `IntoIterator`, può essere utilizzato come " -"argomento per\n" +"Poiché `Option` implementa `IntoIterator`, può essere utilizzato come argomento per\n" "[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" #: src\idioms/option-iter.md:14 @@ -2805,13 +2418,10 @@ msgstr "" #, fuzzy msgid "" "If you need to tack an `Option` to the end of an existing iterator, you can\n" -"pass it to " -"[`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +"pass it to [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" msgstr "" -"Se devi aggiungere un'opzione alla fine di un iteratore esistente, puoi " -"farlo\n" -"passalo a " -"[`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +"Se devi aggiungere un'opzione alla fine di un iteratore esistente, puoi farlo\n" +"passalo a [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" #: src\idioms/option-iter.md:29 msgid "" @@ -2828,8 +2438,7 @@ msgstr "" #: src\idioms/option-iter.md:38 #, fuzzy msgid "" -"Note that if the `Option` is always `Some`, then it is more idiomatic to " -"use\n" +"Note that if the `Option` is always `Some`, then it is more idiomatic to use\n" "[`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) on the\n" "element instead." msgstr "" @@ -2840,10 +2449,8 @@ msgstr "" #: src\idioms/option-iter.md:42 #, fuzzy msgid "" -"Also, since `Option` implements `IntoIterator`, it's possible to iterate " -"over\n" -"it using a `for` loop. This is equivalent to matching it with `if let " -"Some(..)`,\n" +"Also, since `Option` implements `IntoIterator`, it's possible to iterate over\n" +"it using a `for` loop. This is equivalent to matching it with `if let Some(..)`,\n" "and in most cases you should prefer the latter." msgstr "" "Inoltre, poiché `Option` implementa `IntoIterator`, è possibile iterare\n" @@ -2853,42 +2460,31 @@ msgstr "" #: src\idioms/option-iter.md:48 #, fuzzy msgid "" -"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is " -"an\n" -" iterator which yields exactly one element. It's a more readable " -"alternative to\n" +"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is an\n" +" iterator which yields exactly one element. It's a more readable alternative to\n" " `Some(foo).into_iter()`.\n" "\n" -"- " -"[`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" -" is a version of " -"[`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" is a version of [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" " specialized to mapping functions which return `Option`.\n" "\n" -"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides " -"functions\n" +"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" " for converting an `Option` to a zero- or one-element slice.\n" "\n" -"- [Documentation for " -"`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +"- [Documentation for `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" msgstr "" "- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) è un\n" -" iteratore che restituisce esattamente un elemento. È un'alternativa più " -"leggibile a\n" +" iteratore che restituisce esattamente un elemento. È un'alternativa più leggibile a\n" " `Alcuni(foo).into_iter()`.\n" "\n" -"- " -"[`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" -" è una versione di " -"[`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" è una versione di [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" " specializzato per mappare funzioni che restituiscono `Opzione`.\n" "\n" -"- Il crate [`ref_slice`](https://crates.io/crates/ref_slice) fornisce " -"funzioni\n" +"- Il crate [`ref_slice`](https://crates.io/crates/ref_slice) fornisce funzioni\n" " per convertire una `Opzione` in una fetta con zero o un elemento.\n" "\n" -"- [Documentazione per " -"`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +"- [Documentazione per `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" #: src\idioms/pass-var-to-closure.md:1 #, fuzzy @@ -2899,18 +2495,13 @@ msgstr "# Passa le variabili alla chiusura" #, fuzzy msgid "" "By default, closures capture their environment by borrowing. Or you can use\n" -"`move`-closure to move whole environment. However, often you want to move " -"just\n" -"some variables to closure, give it copy of some data, pass it by reference, " -"or\n" +"`move`-closure to move whole environment. However, often you want to move just\n" +"some variables to closure, give it copy of some data, pass it by reference, or\n" "perform some other transformation." msgstr "" -"Per impostazione predefinita, le chiusure catturano il loro ambiente " -"prendendo in prestito. Oppure puoi usare\n" -"`move`-chiusura per spostare l'intero ambiente. Tuttavia, spesso vuoi " -"muoverti solo\n" -"alcune variabili alla chiusura, dagli una copia di alcuni dati, passalo per " -"riferimento o\n" +"Per impostazione predefinita, le chiusure catturano il loro ambiente prendendo in prestito. Oppure puoi usare\n" +"`move`-chiusura per spostare l'intero ambiente. Tuttavia, spesso vuoi muoverti solo\n" +"alcune variabili alla chiusura, dagli una copia di alcuni dati, passalo per riferimento o\n" "eseguire qualche altra trasformazione." #: src\idioms/pass-var-to-closure.md:10 @@ -2967,27 +2558,21 @@ msgstr "" #: src\idioms/pass-var-to-closure.md:50 #, fuzzy msgid "" -"Copied data are grouped together with closure definition, so their purpose " -"is\n" -"more clear, and they will be dropped immediately even if they are not " -"consumed\n" +"Copied data are grouped together with closure definition, so their purpose is\n" +"more clear, and they will be dropped immediately even if they are not consumed\n" "by closure." msgstr "" -"I dati copiati sono raggruppati insieme alla definizione di chiusura, quindi " -"il loro scopo è\n" -"più chiari, e verranno immediatamente eliminati anche se non vengono " -"consumati\n" +"I dati copiati sono raggruppati insieme alla definizione di chiusura, quindi il loro scopo è\n" +"più chiari, e verranno immediatamente eliminati anche se non vengono consumati\n" "per chiusura." #: src\idioms/pass-var-to-closure.md:54 #, fuzzy msgid "" -"Closure uses same variable names as surrounding code whether data are copied " -"or\n" +"Closure uses same variable names as surrounding code whether data are copied or\n" "moved." msgstr "" -"La chiusura utilizza gli stessi nomi di variabile del codice circostante " -"indipendentemente dal fatto che i dati vengano copiati o\n" +"La chiusura utilizza gli stessi nomi di variabile del codice circostante indipendentemente dal fatto che i dati vengano copiati o\n" "mosso." #: src\idioms/pass-var-to-closure.md:59 @@ -3003,16 +2588,12 @@ msgstr "# `#[non_esaustivo]` e campi privati per l'estensibilità" #: src\idioms/priv-extend.md:5 #, fuzzy msgid "" -"A small set of scenarios exist where a library author may want to add " -"public\n" -"fields to a public struct or new variants to an enum without breaking " -"backwards\n" +"A small set of scenarios exist where a library author may want to add public\n" +"fields to a public struct or new variants to an enum without breaking backwards\n" "compatibility." msgstr "" -"Esiste un piccolo insieme di scenari in cui un autore di libreria potrebbe " -"voler aggiungere public\n" -"campi a una struttura pubblica o nuove varianti a un'enumerazione senza " -"andare all'indietro\n" +"Esiste un piccolo insieme di scenari in cui un autore di libreria potrebbe voler aggiungere public\n" +"campi a una struttura pubblica o nuove varianti a un'enumerazione senza andare all'indietro\n" "Compatibilità." #: src\idioms/priv-extend.md:9 @@ -3024,22 +2605,18 @@ msgstr "Rust offre due soluzioni a questo problema:" #, fuzzy msgid "" "- Use `#[non_exhaustive]` on `struct`s, `enum`s, and `enum` variants.\n" -" For extensive documentation on all the places where `#[non_exhaustive]` " -"can be\n" -" used, see [the " -"docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +" For extensive documentation on all the places where `#[non_exhaustive]` can be\n" +" used, see [the docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" "\n" "- You may add a private field to a struct to prevent it from being directly\n" " instantiated or matched against (see Alternative)" msgstr "" "- Usa `#[non_exhaustive]` sulle varianti `struct`s, `enum`s e `enum`.\n" -" Per un'ampia documentazione su tutti i luoghi in cui può essere " -"`#[non_esauriente]`\n" -" utilizzato, vedere [la " -"documentazione](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +" Per un'ampia documentazione su tutti i luoghi in cui può essere `#[non_esauriente]`\n" +" utilizzato, vedere [la documentazione](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-" +"attribute).\n" "\n" -"- Puoi aggiungere un campo privato a una struttura per evitare che sia " -"diretta\n" +"- Puoi aggiungere un campo privato a una struttura per evitare che sia diretta\n" " istanziato o confrontato (vedi Alternativa)" #: src\idioms/priv-extend.md:20 @@ -3101,45 +2678,33 @@ msgstr "" msgid "" "Adding a field to a struct is a mostly backwards compatible change.\n" "However, if a client uses a pattern to deconstruct a struct instance, they\n" -"might name all the fields in the struct and adding a new one would break " -"that\n" +"might name all the fields in the struct and adding a new one would break that\n" "pattern.\n" -"The client could name some fields and use `..` in the pattern, in which case " -"adding\n" +"The client could name some fields and use `..` in the pattern, in which case adding\n" "another field is backwards compatible.\n" -"Making at least one of the struct's fields private forces clients to use the " -"latter\n" +"Making at least one of the struct's fields private forces clients to use the latter\n" "form of patterns, ensuring that the struct is future-proof." msgstr "" -"L'aggiunta di un campo a una struttura è una modifica per lo più compatibile " -"con le versioni precedenti.\n" -"Tuttavia, se un client utilizza un modello per decostruire un'istanza " -"struct, essi\n" -"potrebbe nominare tutti i campi nella struttura e aggiungerne uno nuovo lo " -"interromperebbe\n" +"L'aggiunta di un campo a una struttura è una modifica per lo più compatibile con le versioni precedenti.\n" +"Tuttavia, se un client utilizza un modello per decostruire un'istanza struct, essi\n" +"potrebbe nominare tutti i campi nella struttura e aggiungerne uno nuovo lo interromperebbe\n" "modello.\n" -"Il client potrebbe nominare alcuni campi e utilizzare `..` nel pattern, nel " -"qual caso aggiungendo\n" +"Il client potrebbe nominare alcuni campi e utilizzare `..` nel pattern, nel qual caso aggiungendo\n" "un altro campo è retrocompatibile.\n" -"Rendere privato almeno uno dei campi della struttura obbliga i client a " -"utilizzare quest'ultimo\n" +"Rendere privato almeno uno dei campi della struttura obbliga i client a utilizzare quest'ultimo\n" "forma di modelli, assicurando che la struttura sia a prova di futuro." #: src\idioms/priv-extend.md:71 #, fuzzy msgid "" -"The downside of this approach is that you might need to add an otherwise " -"unneeded\n" +"The downside of this approach is that you might need to add an otherwise unneeded\n" "field to the struct.\n" -"You can use the `()` type so that there is no runtime overhead and prepend " -"`_` to\n" +"You can use the `()` type so that there is no runtime overhead and prepend `_` to\n" "the field name to avoid the unused field warning." msgstr "" -"Lo svantaggio di questo approccio è che potrebbe essere necessario " -"aggiungere un file altrimenti non necessario\n" +"Lo svantaggio di questo approccio è che potrebbe essere necessario aggiungere un file altrimenti non necessario\n" "campo alla struttura.\n" -"Puoi usare il tipo `()` in modo che non ci sia sovraccarico di runtime e " -"anteporre `_` a\n" +"Puoi usare il tipo `()` in modo che non ci sia sovraccarico di runtime e anteporre `_` a\n" "il nome del campo per evitare l'avviso di campo inutilizzato." #: src\idioms/priv-extend.md:76 @@ -3147,8 +2712,7 @@ msgid "" "```rust\n" "pub struct S {\n" " pub a: i32,\n" -" // Because `b` is private, you cannot match on `S` without using `..` " -"and `S`\n" +" // Because `b` is private, you cannot match on `S` without using `..` and `S`\n" " // cannot be directly instantiated or matched against\n" " _b: ()\n" "}\n" @@ -3158,60 +2722,44 @@ msgstr "" #: src\idioms/priv-extend.md:87 #, fuzzy msgid "" -"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a " -"backwards\n" +"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a backwards\n" "compatible way.\n" -"It will also prevent clients from using the struct constructor, even if all " -"the\n" +"It will also prevent clients from using the struct constructor, even if all the\n" "fields are public.\n" -"This may be helpful, but it's worth considering if you _want_ an additional " -"field\n" -"to be found by clients as a compiler error rather than something that may be " -"silently\n" +"This may be helpful, but it's worth considering if you _want_ an additional field\n" +"to be found by clients as a compiler error rather than something that may be silently\n" "undiscovered." msgstr "" -"Su `struct`s, `#[non_exhaustive]` consente di aggiungere ulteriori campi in " -"un modo all'indietro\n" +"Su `struct`s, `#[non_exhaustive]` consente di aggiungere ulteriori campi in un modo all'indietro\n" "modo compatibile.\n" -"Impedirà inoltre ai client di utilizzare il costruttore struct, anche se " -"tutti i file\n" +"Impedirà inoltre ai client di utilizzare il costruttore struct, anche se tutti i file\n" "i campi sono pubblici\n" -"Questo può essere utile, ma vale la pena considerare se _vuoi_ un campo " -"aggiuntivo\n" -"essere trovato dai client come un errore del compilatore piuttosto che " -"qualcosa che potrebbe essere nascosto\n" +"Questo può essere utile, ma vale la pena considerare se _vuoi_ un campo aggiuntivo\n" +"essere trovato dai client come un errore del compilatore piuttosto che qualcosa che potrebbe essere nascosto\n" "non scoperto." #: src\idioms/priv-extend.md:95 #, fuzzy msgid "" "`#[non_exhaustive]` can be applied to enum variants as well.\n" -"A `#[non_exhaustive]` variant behaves in the same way as a " -"`#[non_exhaustive]` struct." +"A `#[non_exhaustive]` variant behaves in the same way as a `#[non_exhaustive]` struct." msgstr "" "`#[non_exhaustive]` può essere applicato anche alle varianti enum.\n" -"Una variante `#[non_exhaustive]` si comporta allo stesso modo di una " -"struttura `#[non_exhaustive]`." +"Una variante `#[non_exhaustive]` si comporta allo stesso modo di una struttura `#[non_exhaustive]`." #: src\idioms/priv-extend.md:98 #, fuzzy msgid "" -"Use this deliberately and with caution: incrementing the major version when " -"adding\n" +"Use this deliberately and with caution: incrementing the major version when adding\n" "fields or variants is often a better option.\n" -"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an " -"external\n" -"resource that may change out-of-sync with your library, but is not a general " -"purpose\n" +"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an external\n" +"resource that may change out-of-sync with your library, but is not a general purpose\n" "tool." msgstr "" -"Usalo deliberatamente e con cautela: incrementare la versione principale " -"durante l'aggiunta\n" +"Usalo deliberatamente e con cautela: incrementare la versione principale durante l'aggiunta\n" "campi o varianti è spesso un'opzione migliore.\n" -"\"#[non_exhaustive]\" può essere appropriato in scenari in cui stai " -"modellando un esterno\n" -"risorsa che potrebbe cambiare in modo non sincronizzato con la tua libreria, " -"ma non è uno scopo generale\n" +"\"#[non_exhaustive]\" può essere appropriato in scenari in cui stai modellando un esterno\n" +"risorsa che potrebbe cambiare in modo non sincronizzato con la tua libreria, ma non è uno scopo generale\n" "attrezzo." #: src\idioms/priv-extend.md:104 @@ -3222,44 +2770,36 @@ msgstr "### Svantaggi" #: src\idioms/priv-extend.md:106 #, fuzzy msgid "" -"`#[non_exhaustive]` can make your code much less ergonomic to use, " -"especially when\n" +"`#[non_exhaustive]` can make your code much less ergonomic to use, especially when\n" "forced to handle unknown enum variants.\n" -"It should only be used when these sorts of evolutions are required " -"**without**\n" +"It should only be used when these sorts of evolutions are required **without**\n" "incrementing the major version." msgstr "" -"`#[non_exhaustive]` può rendere il tuo codice molto meno ergonomico da " -"usare, specialmente quando\n" +"`#[non_exhaustive]` può rendere il tuo codice molto meno ergonomico da usare, specialmente quando\n" "costretto a gestire varianti enum sconosciute.\n" -"Dovrebbe essere usato solo quando sono richiesti questi tipi di evoluzioni " -"**senza**\n" +"Dovrebbe essere usato solo quando sono richiesti questi tipi di evoluzioni **senza**\n" "incrementando la versione principale." #: src\idioms/priv-extend.md:111 msgid "" -"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle " -"a\n" +"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle a\n" "wildcard variant.\n" -"If there is no sensible action to take in this case, this may lead to " -"awkward\n" +"If there is no sensible action to take in this case, this may lead to awkward\n" "code and code paths that are only executed in extremely rare circumstances.\n" -"If a client decides to `panic!()` in this scenario, it may have been better " -"to\n" +"If a client decides to `panic!()` in this scenario, it may have been better to\n" "expose this error at compile time.\n" -"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" " -"case;\n" +"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" case;\n" "there is rarely a sensible action to take in this scenario." msgstr "" #: src\idioms/priv-extend.md:122 #, fuzzy msgid "" -"- [RFC introducing #[non_exhaustive] attribute for enums and " -"structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-exhaustive.md)" +"- [RFC introducing #[non_exhaustive] attribute for enums and structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" msgstr "" -"- [RFC introduce l'attributo #[non_exhaustive] per enum e " -"struct](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-exhaustive.md)" +"- [RFC introduce l'attributo #[non_exhaustive] per enum e struct](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" #: src\idioms/rustdoc-init.md:1 #, fuzzy @@ -3269,16 +2809,12 @@ msgstr "# Facile inizializzazione dei documenti\r" #: src\idioms/rustdoc-init.md:5 #, fuzzy msgid "" -"If a struct takes significant effort to initialize when writing docs, it can " -"be\r\n" -"quicker to wrap your example with a helper function which takes the struct " -"as an\r\n" +"If a struct takes significant effort to initialize when writing docs, it can be\r\n" +"quicker to wrap your example with a helper function which takes the struct as an\r\n" "argument." msgstr "" -"Se una struttura richiede uno sforzo significativo per l'inizializzazione " -"durante la scrittura di documenti, può esserlo\r\n" -"più veloce per avvolgere il tuo esempio con una funzione di supporto che " -"prende la struttura come un\r\n" +"Se una struttura richiede uno sforzo significativo per l'inizializzazione durante la scrittura di documenti, può esserlo\r\n" +"più veloce per avvolgere il tuo esempio con una funzione di supporto che prende la struttura come un\r\n" "discussione." #: src\idioms/rustdoc-init.md:9 @@ -3289,8 +2825,7 @@ msgstr "## Motivazione\r" #: src\idioms/rustdoc-init.md:11 #, fuzzy msgid "" -"Sometimes there is a struct with multiple or complicated parameters and " -"several\r\n" +"Sometimes there is a struct with multiple or complicated parameters and several\r\n" "methods. Each of these methods should have examples." msgstr "" "A volte c'è una struttura con parametri multipli o complicati e diversi\r\n" @@ -3316,10 +2851,8 @@ msgid "" " /// ```no_run\r\n" " /// # // Boilerplate are required to get an example working.\r\n" " /// # let stream = TcpStream::connect(\"127.0.0.1:34254\");\r\n" -" /// # let connection = Connection { name: \"foo\".to_owned(), stream " -"};\r\n" -" /// # let request = Request::new(\"RequestId\", RequestType::Get, " -"\"payload\");\r\n" +" /// # let connection = Connection { name: \"foo\".to_owned(), stream };\r\n" +" /// # let request = Request::new(\"RequestId\", RequestType::Get, \"payload\");\r\n" " /// let response = connection.send_request(request);\r\n" " /// assert!(response.is_ok());\r\n" " /// ```\r\n" @@ -3344,14 +2877,11 @@ msgstr "## Esempio\r" #, fuzzy msgid "" "Instead of typing all of this boilerplate to create a `Connection` and\r\n" -"`Request`, it is easier to just create a wrapping helper function which " -"takes\r\n" +"`Request`, it is easier to just create a wrapping helper function which takes\r\n" "them as arguments:" msgstr "" -"Invece di digitare tutto questo boilerplate per creare una \"Connessione\" " -"e\r\n" -"`Request`, è più facile creare semplicemente una funzione di supporto per il " -"wrapping che accetta\r\n" +"Invece di digitare tutto questo boilerplate per creare una \"Connessione\" e\r\n" +"`Request`, è più facile creare semplicemente una funzione di supporto per il wrapping che accetta\r\n" "loro come argomenti:" #: src\idioms/rustdoc-init.md:51 @@ -3381,8 +2911,7 @@ msgstr "" #: src\idioms/rustdoc-init.md:73 msgid "" -"**Note** in the above example the line `assert!(response.is_ok());` will " -"not\r\n" +"**Note** in the above example the line `assert!(response.is_ok());` will not\r\n" "actually run while testing because it is inside a function which is never\r\n" "invoked." msgstr "" @@ -3405,19 +2934,13 @@ msgstr "## Svantaggi\r" #: src\idioms/rustdoc-init.md:83 #, fuzzy msgid "" -"As example is in a function, the code will not be tested. Though it will " -"still be\r\n" -"checked to make sure it compiles when running a `cargo test`. So this " -"pattern is\r\n" -"most useful when you need `no_run`. With this, you do not need to add " -"`no_run`." +"As example is in a function, the code will not be tested. Though it will still be\r\n" +"checked to make sure it compiles when running a `cargo test`. So this pattern is\r\n" +"most useful when you need `no_run`. With this, you do not need to add `no_run`." msgstr "" -"Poiché l'esempio è in una funzione, il codice non verrà testato. Anche se lo " -"sarà ancora\r\n" -"controllato per assicurarsi che venga compilato durante l'esecuzione di un " -"`cargo test`. Quindi questo modello è\r\n" -"molto utile quando hai bisogno di `no_run`. Con questo, non è necessario " -"aggiungere `no_run`." +"Poiché l'esempio è in una funzione, il codice non verrà testato. Anche se lo sarà ancora\r\n" +"controllato per assicurarsi che venga compilato durante l'esecuzione di un `cargo test`. Quindi questo modello è\r\n" +"molto utile quando hai bisogno di `no_run`. Con questo, non è necessario aggiungere `no_run`." #: src\idioms/rustdoc-init.md:87 #, fuzzy @@ -3432,20 +2955,14 @@ msgstr "Se le asserzioni non sono richieste, questo modello funziona bene." #: src\idioms/rustdoc-init.md:91 #, fuzzy msgid "" -"If they are, an alternative can be to create a public method to create a " -"helper\r\n" -"instance which is annotated with `#[doc(hidden)]` (so that users won't see " -"it).\r\n" -"Then this method can be called inside of rustdoc because it is part of " -"the\r\n" +"If they are, an alternative can be to create a public method to create a helper\r\n" +"instance which is annotated with `#[doc(hidden)]` (so that users won't see it).\r\n" +"Then this method can be called inside of rustdoc because it is part of the\r\n" "crate's public API." msgstr "" -"Se lo sono, un'alternativa può essere quella di creare un metodo pubblico " -"per creare un helper\r\n" -"istanza che è annotata con `#[doc(hidden)]` (in modo che gli utenti non la " -"vedano).\r\n" -"Quindi questo metodo può essere chiamato all'interno di rustdoc perché fa " -"parte del file\r\n" +"Se lo sono, un'alternativa può essere quella di creare un metodo pubblico per creare un helper\r\n" +"istanza che è annotata con `#[doc(hidden)]` (in modo che gli utenti non la vedano).\r\n" +"Quindi questo metodo può essere chiamato all'interno di rustdoc perché fa parte del file\r\n" "API pubblica di crate." #: src\idioms/temporary-mutability.md:1 @@ -3456,27 +2973,21 @@ msgstr "# Mutabilità temporanea" #: src\idioms/temporary-mutability.md:5 #, fuzzy msgid "" -"Often it is necessary to prepare and process some data, but after that data " -"are\n" -"only inspected and never modified. The intention can be made explicit by " -"redefining\n" +"Often it is necessary to prepare and process some data, but after that data are\n" +"only inspected and never modified. The intention can be made explicit by redefining\n" "the mutable variable as immutable." msgstr "" -"Spesso è necessario preparare ed elaborare alcuni dati, ma poi i dati lo " -"sono\n" -"solo revisionata e mai modificata. L'intenzione può essere resa esplicita " -"ridefinendo\n" +"Spesso è necessario preparare ed elaborare alcuni dati, ma poi i dati lo sono\n" +"solo revisionata e mai modificata. L'intenzione può essere resa esplicita ridefinendo\n" "la variabile mutabile come immutabile." #: src\idioms/temporary-mutability.md:9 #, fuzzy msgid "" -"It can be done either by processing data within a nested block or by " -"redefining\n" +"It can be done either by processing data within a nested block or by redefining\n" "the variable." msgstr "" -"Può essere fatto elaborando i dati all'interno di un blocco nidificato o " -"ridefinendo\n" +"Può essere fatto elaborando i dati all'interno di un blocco nidificato o ridefinendo\n" "la variabile." #: src\idioms/temporary-mutability.md:14 @@ -3520,11 +3031,8 @@ msgstr "" #: src\idioms/temporary-mutability.md:40 #, fuzzy -msgid "" -"Compiler ensures that you don't accidentally mutate data after some point." -msgstr "" -"Il compilatore garantisce di non modificare accidentalmente i dati dopo un " -"certo punto." +msgid "Compiler ensures that you don't accidentally mutate data after some point." +msgstr "Il compilatore garantisce di non modificare accidentalmente i dati dopo un certo punto." #: src\idioms/temporary-mutability.md:44 #, fuzzy @@ -3543,12 +3051,10 @@ msgstr "# Restituisce l'argomento consumato in caso di errore" #: src\idioms/return-consumed-arg-on-error.md:5 #, fuzzy msgid "" -"If a fallible function consumes (moves) an argument, return that argument " -"back inside\n" +"If a fallible function consumes (moves) an argument, return that argument back inside\n" "an error." msgstr "" -"Se una funzione fallibile consuma (sposta) un argomento, riporta " -"quell'argomento all'interno\n" +"Se una funzione fallibile consuma (sposta) un argomento, riporta quell'argomento all'interno\n" "un errore." #: src\idioms/return-consumed-arg-on-error.md:10 @@ -3558,8 +3064,7 @@ msgid "" " println!(\"using {value} in a meaningful way\");\n" " // Simulate non-deterministic fallible action.\n" " use std::time::SystemTime;\n" -" let period = " -"SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" +" let period = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" " if period.subsec_nanos() % 2 == 1 {\n" " Ok(())\n" " } else {\n" @@ -3597,8 +3102,7 @@ msgid "" "is not very efficient." msgstr "" "In caso di errore potresti voler provare un modo alternativo o per\n" -"riprovare l'azione in caso di funzione non deterministica. Ma se " -"l'argomento\n" +"riprovare l'azione in caso di funzione non deterministica. Ma se l'argomento\n" "è sempre consumato, sei costretto a clonarlo ad ogni chiamata, quale\n" "non è molto efficiente." @@ -3610,20 +3114,15 @@ msgid "" "is returned.\n" "You can get original vector back using `FromUtf8Error::into_bytes` method." msgstr "" -"La libreria standard utilizza questo approccio ad es. Metodo " -"`String::from_utf8`.\n" -"Quando viene fornito un vettore che non contiene UTF-8 valido, viene " -"visualizzato un `FromUtf8Error`\n" +"La libreria standard utilizza questo approccio ad es. Metodo `String::from_utf8`.\n" +"Quando viene fornito un vettore che non contiene UTF-8 valido, viene visualizzato un `FromUtf8Error`\n" "viene restituito.\n" -"Puoi recuperare il vettore originale usando il metodo " -"`FromUtf8Error::into_bytes`." +"Puoi recuperare il vettore originale usando il metodo `FromUtf8Error::into_bytes`." #: src\idioms/return-consumed-arg-on-error.md:57 #, fuzzy msgid "Better performance because of moving arguments whenever possible." -msgstr "" -"Migliori prestazioni grazie allo spostamento degli argomenti quando " -"possibile." +msgstr "Migliori prestazioni grazie allo spostamento degli argomenti quando possibile." #: src\idioms/return-consumed-arg-on-error.md:61 #, fuzzy @@ -3638,54 +3137,38 @@ msgstr "# Modelli di progettazione" #: src\patterns/index.md:3 #, fuzzy msgid "" -"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) " -"are\n" +"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) are\n" "\"general reusable solutions to a commonly occurring problem within a given\n" -"context in software design\". Design patterns are a great way to describe " -"the\n" -"culture of a programming language. Design patterns are very " -"language-specific -\n" +"context in software design\". Design patterns are a great way to describe the\n" +"culture of a programming language. Design patterns are very language-specific -\n" "what is a pattern in one language may be unnecessary in another due to a\n" "language feature, or impossible to express due to a missing feature." msgstr "" -"[Modelli di " -"progettazione](https://en.wikipedia.org/wiki/Software_design_pattern) lo " -"sono\n" -"\"soluzioni generali riutilizzabili a un problema che si verifica " -"comunemente all'interno di un dato\n" -"contesto nella progettazione del software\". I modelli di progettazione sono " -"un ottimo modo per descrivere il\n" -"cultura di un linguaggio di programmazione. I modelli di progettazione sono " -"molto specifici della lingua -\n" -"quello che è uno schema in una lingua potrebbe non essere necessario in " -"un'altra a causa di a\n" -"caratteristica della lingua, o impossibile da esprimere a causa di una " -"caratteristica mancante." +"[Modelli di progettazione](https://en.wikipedia.org/wiki/Software_design_pattern) lo sono\n" +"\"soluzioni generali riutilizzabili a un problema che si verifica comunemente all'interno di un dato\n" +"contesto nella progettazione del software\". I modelli di progettazione sono un ottimo modo per descrivere il\n" +"cultura di un linguaggio di programmazione. I modelli di progettazione sono molto specifici della lingua -\n" +"quello che è uno schema in una lingua potrebbe non essere necessario in un'altra a causa di a\n" +"caratteristica della lingua, o impossibile da esprimere a causa di una caratteristica mancante." #: src\patterns/index.md:10 #, fuzzy msgid "" "If overused, design patterns can add unnecessary complexity to programs.\n" -"However, they are a great way to share intermediate and advanced level " -"knowledge\n" +"However, they are a great way to share intermediate and advanced level knowledge\n" "about a programming language." msgstr "" -"Se abusati, i design pattern possono aggiungere inutili complessità ai " -"programmi.\n" -"Tuttavia, sono un ottimo modo per condividere conoscenze di livello " -"intermedio e avanzato\n" +"Se abusati, i design pattern possono aggiungere inutili complessità ai programmi.\n" +"Tuttavia, sono un ottimo modo per condividere conoscenze di livello intermedio e avanzato\n" "su un linguaggio di programmazione." #: src\patterns/index.md:16 #, fuzzy msgid "" -"Rust has many unique features. These features give us great benefit by " -"removing\n" -"whole classes of problems. Some of them are also patterns that are _unique_ " -"to Rust." +"Rust has many unique features. These features give us great benefit by removing\n" +"whole classes of problems. Some of them are also patterns that are _unique_ to Rust." msgstr "" -"Rust ha molte caratteristiche uniche. Queste funzionalità ci danno un grande " -"vantaggio rimuovendo\n" +"Rust ha molte caratteristiche uniche. Queste funzionalità ci danno un grande vantaggio rimuovendo\n" "intere classi di problemi. Alcuni di essi sono anche modelli _unici_ di Rust." #: src\patterns/index.md:19 @@ -3700,32 +3183,23 @@ msgid "" "It's a vital software design principle to apply as you write code." msgstr "" "YAGNI è un acronimo che sta per `You Are not Going to Need It`.\n" -"È un principio di progettazione software fondamentale da applicare durante " -"la scrittura del codice." +"È un principio di progettazione software fondamentale da applicare durante la scrittura del codice." #: src\patterns/index.md:24 #, fuzzy msgid "> The best code I ever wrote was code I never wrote." -msgstr "" -"> Il miglior codice che abbia mai scritto è stato un codice che non ho mai " -"scritto." +msgstr "> Il miglior codice che abbia mai scritto è stato un codice che non ho mai scritto." #: src\patterns/index.md:26 #, fuzzy msgid "" -"If we apply YAGNI to design patterns, we see that the features of Rust allow " -"us to\n" -"throw out many patterns. For instance, there is no need for the [strategy " -"pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"in Rust because we can just use " -"[traits](https://doc.rust-lang.org/book/traits.html)." +"If we apply YAGNI to design patterns, we see that the features of Rust allow us to\n" +"throw out many patterns. For instance, there is no need for the [strategy pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"in Rust because we can just use [traits](https://doc.rust-lang.org/book/traits.html)." msgstr "" -"Se applichiamo YAGNI ai modelli di design, vediamo che le caratteristiche di " -"Rust ce lo consentono\n" -"buttare via molti modelli. Ad esempio, non è necessario il [modello " -"strategico](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"in Rust perché possiamo semplicemente usare " -"[traits](https://doc.rust-lang.org/book/traits.html)." +"Se applichiamo YAGNI ai modelli di design, vediamo che le caratteristiche di Rust ce lo consentono\n" +"buttare via molti modelli. Ad esempio, non è necessario il [modello strategico](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"in Rust perché possiamo semplicemente usare [traits](https://doc.rust-lang.org/book/traits.html)." #: src\patterns/behavioural/intro.md:1 #, fuzzy @@ -3740,15 +3214,11 @@ msgstr "Da [Wikipedia](https://en.wikipedia.org/wiki/Behavioral_pattern):" #: src\patterns/behavioural/intro.md:5 #, fuzzy msgid "" -"> Design patterns that identify common communication patterns among " -"objects.\n" -"> By doing so, these patterns increase flexibility in carrying out " -"communication." +"> Design patterns that identify common communication patterns among objects.\n" +"> By doing so, these patterns increase flexibility in carrying out communication." msgstr "" -"> Modelli di design che identificano modelli di comunicazione comuni tra gli " -"oggetti.\n" -"> In tal modo, questi modelli aumentano la flessibilità nell'effettuare la " -"comunicazione." +"> Modelli di design che identificano modelli di comunicazione comuni tra gli oggetti.\n" +"> In tal modo, questi modelli aumentano la flessibilità nell'effettuare la comunicazione." #: src\patterns/behavioural/command.md:1 #, fuzzy @@ -3758,8 +3228,7 @@ msgstr "# Comando" #: src\patterns/behavioural/command.md:5 #, fuzzy msgid "" -"The basic idea of the Command pattern is to separate out actions into its " -"own\n" +"The basic idea of the Command pattern is to separate out actions into its own\n" "objects and pass them as parameters." msgstr "" "L'idea di base del modello di comando è separare le azioni nelle proprie\n" @@ -3768,56 +3237,36 @@ msgstr "" #: src\patterns/behavioural/command.md:10 #, fuzzy msgid "" -"Suppose we have a sequence of actions or transactions encapsulated as " -"objects.\n" -"We want these actions or commands to be executed or invoked in some order " -"later\n" -"at different time. These commands may also be triggered as a result of some " -"event.\n" +"Suppose we have a sequence of actions or transactions encapsulated as objects.\n" +"We want these actions or commands to be executed or invoked in some order later\n" +"at different time. These commands may also be triggered as a result of some event.\n" "For example, when a user pushes a button, or on arrival of a data packet.\n" "In addition, these commands might be undoable. This may come in useful for\n" -"operations of an editor. We might want to store logs of executed commands so " -"that\n" +"operations of an editor. We might want to store logs of executed commands so that\n" "we could reapply the changes later if the system crashes." msgstr "" -"Supponiamo di avere una sequenza di azioni o transazioni incapsulate come " -"oggetti.\n" -"Vogliamo che queste azioni o comandi vengano eseguiti o richiamati in un " -"certo ordine in un secondo momento\n" -"in tempi diversi. Questi comandi possono anche essere attivati a seguito di " -"qualche evento.\n" -"Ad esempio, quando un utente preme un pulsante o all'arrivo di un pacchetto " -"di dati.\n" -"Inoltre, questi comandi potrebbero essere annullabili. Questo può tornare " -"utile per\n" -"operazioni di un editore. Potremmo voler memorizzare i log dei comandi " -"eseguiti in modo che\n" -"potremmo riapplicare le modifiche in un secondo momento se il sistema va in " -"crash." +"Supponiamo di avere una sequenza di azioni o transazioni incapsulate come oggetti.\n" +"Vogliamo che queste azioni o comandi vengano eseguiti o richiamati in un certo ordine in un secondo momento\n" +"in tempi diversi. Questi comandi possono anche essere attivati a seguito di qualche evento.\n" +"Ad esempio, quando un utente preme un pulsante o all'arrivo di un pacchetto di dati.\n" +"Inoltre, questi comandi potrebbero essere annullabili. Questo può tornare utile per\n" +"operazioni di un editore. Potremmo voler memorizzare i log dei comandi eseguiti in modo che\n" +"potremmo riapplicare le modifiche in un secondo momento se il sistema va in crash." #: src\patterns/behavioural/command.md:20 #, fuzzy msgid "" -"Define two database operations `create table` and `add field`. Each of " -"these\n" -"operations is a command which knows how to undo the command, e.g., `drop " -"table`\n" -"and `remove field`. When a user invokes a database migration operation then " -"each\n" -"command is executed in the defined order, and when the user invokes the " -"rollback\n" +"Define two database operations `create table` and `add field`. Each of these\n" +"operations is a command which knows how to undo the command, e.g., `drop table`\n" +"and `remove field`. When a user invokes a database migration operation then each\n" +"command is executed in the defined order, and when the user invokes the rollback\n" "operation then the whole set of commands is invoked in reverse order." msgstr "" -"Definisci due operazioni di database \"crea tabella\" e \"aggiungi campo\". " -"Ognuno di questi\n" -"operations è un comando che sa come annullare il comando, ad esempio `drop " -"table`\n" -"e `rimuovi campo`. Quando un utente richiama un'operazione di migrazione del " -"database, each\n" -"Il comando viene eseguito nell'ordine definito e quando l'utente richiama il " -"rollback\n" -"operazione allora l'intera serie di comandi viene richiamata in ordine " -"inverso." +"Definisci due operazioni di database \"crea tabella\" e \"aggiungi campo\". Ognuno di questi\n" +"operations è un comando che sa come annullare il comando, ad esempio `drop table`\n" +"e `rimuovi campo`. Quando un utente richiama un'operazione di migrazione del database, each\n" +"Il comando viene eseguito nell'ordine definito e quando l'utente richiama il rollback\n" +"operazione allora l'intera serie di comandi viene richiamata in ordine inverso." #: src\patterns/behavioural/command.md:26 #, fuzzy @@ -3830,10 +3279,8 @@ msgid "" "We define a common trait which encapsulates our command with two operations\n" "`execute` and `rollback`. All command `structs` must implement this trait." msgstr "" -"Definiamo un tratto comune che incapsula il nostro comando con due " -"operazioni\n" -"`esegui` e `rollback`. Tutti i comandi `structs` devono implementare questa " -"caratteristica." +"Definiamo un tratto comune che incapsula il nostro comando con due operazioni\n" +"`esegui` e `rollback`. Tutti i comandi `structs` devono implementare questa caratteristica." #: src\patterns/behavioural/command.md:31 msgid "" @@ -3911,20 +3358,15 @@ msgstr "## Approccio: utilizzo dei puntatori di funzione" #, fuzzy msgid "" "We could follow another approach by creating each individual command as\n" -"a different function and store function pointers to invoke these functions " -"later\n" -"at a different time. Since function pointers implement all three traits " -"`Fn`,\n" +"a different function and store function pointers to invoke these functions later\n" +"at a different time. Since function pointers implement all three traits `Fn`,\n" "`FnMut`, and `FnOnce` we could as well pass and store closures instead of\n" "function pointers." msgstr "" "Potremmo seguire un altro approccio creando ogni singolo comando come\n" -"una funzione diversa e memorizza i puntatori a funzione per richiamare " -"queste funzioni in un secondo momento\n" -"in un momento diverso. Poiché i puntatori di funzione implementano tutti e " -"tre i tratti `Fn`,\n" -"`FnMut` e `FnOnce` potremmo anche passare e memorizzare le chiusure invece " -"di\n" +"una funzione diversa e memorizza i puntatori a funzione per richiamare queste funzioni in un secondo momento\n" +"in un momento diverso. Poiché i puntatori di funzione implementano tutti e tre i tratti `Fn`,\n" +"`FnMut` e `FnOnce` potremmo anche passare e memorizzare le chiusure invece di\n" "puntatori di funzione." #: src\patterns/behavioural/command.md:103 @@ -3969,8 +3411,7 @@ msgid "" "\n" "fn main() {\n" " let mut schema = Schema::new();\n" -" schema.add_migration(|| \"create table\".to_string(), || \"drop " -"table\".to_string());\n" +" schema.add_migration(|| \"create table\".to_string(), || \"drop table\".to_string());\n" " schema.add_migration(add_field, remove_field);\n" " assert_eq!(vec![\"create table\", \"add field\"], schema.execute());\n" " assert_eq!(vec![\"remove field\", \"drop table\"], schema.rollback());\n" @@ -3989,8 +3430,7 @@ msgid "" "Finally, instead of defining a common command trait we could store\n" "each command implementing the `Fn` trait separately in vectors." msgstr "" -"Infine, invece di definire un tratto di comando comune, potremmo " -"memorizzare\n" +"Infine, invece di definire un tratto di comando comune, potremmo memorizzare\n" "ogni comando implementa il tratto `Fn` separatamente nei vettori." #: src\patterns/behavioural/command.md:155 @@ -4047,61 +3487,47 @@ msgstr "" #: src\patterns/behavioural/command.md:205 #, fuzzy msgid "" -"If our commands are small and may be defined as functions or passed as a " -"closure\n" +"If our commands are small and may be defined as functions or passed as a closure\n" "then using function pointers might be preferable since it does not exploit\n" -"dynamic dispatch. But if our command is a whole struct with a bunch of " -"functions\n" +"dynamic dispatch. But if our command is a whole struct with a bunch of functions\n" "and variables defined as seperated module then using trait objects would be\n" -"more suitable. A case of application can be found in " -"[`actix`](https://actix.rs/),\n" +"more suitable. A case of application can be found in [`actix`](https://actix.rs/),\n" "which uses trait objects when it registers a handler function for routes.\n" -"In case of using `Fn` trait objects we can create and use commands in the " -"same\n" +"In case of using `Fn` trait objects we can create and use commands in the same\n" "way as we used in case of function pointers." msgstr "" -"Se i nostri comandi sono piccoli e possono essere definiti come funzioni o " -"passati come chiusura\n" -"quindi l'utilizzo di puntatori a funzione potrebbe essere preferibile poiché " -"non sfrutta\n" -"invio dinamico. Ma se il nostro comando è un'intera struttura con un mucchio " -"di funzioni\n" -"e le variabili definite come modulo separato sarebbero allora utilizzando " -"gli oggetti tratto\n" -"più adatto. Un caso di applicazione può essere trovato in " -"[`actix`](https://actix.rs/),\n" -"che utilizza oggetti tratto quando registra una funzione di gestione per le " -"rotte.\n" -"In caso di utilizzo di oggetti tratto `Fn` possiamo creare e utilizzare " -"comandi nello stesso\n" +"Se i nostri comandi sono piccoli e possono essere definiti come funzioni o passati come chiusura\n" +"quindi l'utilizzo di puntatori a funzione potrebbe essere preferibile poiché non sfrutta\n" +"invio dinamico. Ma se il nostro comando è un'intera struttura con un mucchio di funzioni\n" +"e le variabili definite come modulo separato sarebbero allora utilizzando gli oggetti tratto\n" +"più adatto. Un caso di applicazione può essere trovato in [`actix`](https://actix.rs/),\n" +"che utilizza oggetti tratto quando registra una funzione di gestione per le rotte.\n" +"In caso di utilizzo di oggetti tratto `Fn` possiamo creare e utilizzare comandi nello stesso\n" "modo come abbiamo usato in caso di puntatori a funzione." #: src\patterns/behavioural/command.md:214 #, fuzzy msgid "" "As performance, there is always a trade-off between performance and code\n" -"simplicity and organisation. Static dispatch gives faster performance, " -"while\n" +"simplicity and organisation. Static dispatch gives faster performance, while\n" "dynamic dispatch provides flexibility when we structure our application." msgstr "" "Come prestazioni, c'è sempre un compromesso tra prestazioni e codice\n" -"semplicità e organizzazione. L'invio statico offre prestazioni più veloci, " -"mentre\n" -"l'invio dinamico fornisce flessibilità quando strutturiamo la nostra " -"applicazione." +"semplicità e organizzazione. L'invio statico offre prestazioni più veloci, mentre\n" +"l'invio dinamico fornisce flessibilità quando strutturiamo la nostra applicazione." #: src\patterns/behavioural/command.md:220 #, fuzzy msgid "" "- [Command pattern](https://en.wikipedia.org/wiki/Command_pattern)\n" "\n" -"- [Another example for the `command` " -"pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-rust)" +"- [Another example for the `command` pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-" +"pattern-rust)" msgstr "" "- [Modello di comando](https://en.wikipedia.org/wiki/Command_pattern)\n" "\n" -"- [Un altro esempio per il pattern " -"`command`](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-rust)" +"- [Un altro esempio per il pattern `command`](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-" +"pattern-rust)" #: src\patterns/behavioural/interpreter.md:1 #, fuzzy @@ -4111,20 +3537,14 @@ msgstr "# Interprete" #: src\patterns/behavioural/interpreter.md:5 #, fuzzy msgid "" -"If a problem occurs very often and requires long and repetitive steps to " -"solve\n" -"it, then the problem instances might be expressed in a simple language and " -"an\n" -"interpreter object could solve it by interpreting the sentences written in " -"this\n" +"If a problem occurs very often and requires long and repetitive steps to solve\n" +"it, then the problem instances might be expressed in a simple language and an\n" +"interpreter object could solve it by interpreting the sentences written in this\n" "simple language." msgstr "" -"Se un problema si verifica molto spesso e richiede passaggi lunghi e " -"ripetitivi per essere risolto\n" -"it, allora le istanze del problema potrebbero essere espresse in un " -"linguaggio semplice e un\n" -"oggetto interprete potrebbe risolverlo interpretando le frasi scritte in " -"questo\n" +"Se un problema si verifica molto spesso e richiede passaggi lunghi e ripetitivi per essere risolto\n" +"it, allora le istanze del problema potrebbero essere espresse in un linguaggio semplice e un\n" +"oggetto interprete potrebbe risolverlo interpretando le frasi scritte in questo\n" "linguaggio semplice." #: src\patterns/behavioural/interpreter.md:10 @@ -4135,33 +3555,26 @@ msgstr "In sostanza, per qualsiasi tipo di problema definiamo:" #: src\patterns/behavioural/interpreter.md:12 #, fuzzy msgid "" -"- A [domain specific " -"language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- A [domain specific language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" "- A grammar for this language,\n" "- An interpreter that solves the problem instances." msgstr "" -"- Una [lingua specifica del " -"dominio](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- Una [lingua specifica del dominio](https://en.wikipedia.org/wiki/Domain-specific_language),\n" "- Una grammatica per questa lingua,\n" "- Un interprete che risolve le istanze del problema." #: src\patterns/behavioural/interpreter.md:18 #, fuzzy msgid "" -"Our goal is to translate simple mathematical expressions into postfix " -"expressions\n" -"(or [Reverse Polish " -"notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Our goal is to translate simple mathematical expressions into postfix expressions\n" +"(or [Reverse Polish notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" "For simplicity, our expressions consist of ten digits `0`, ..., `9` and two\n" "operations `+`, `-`. For example, the expression `2 + 4` is translated into\n" "`2 4 +`." msgstr "" -"Il nostro obiettivo è tradurre semplici espressioni matematiche in " -"espressioni postfisse\n" -"(o [notazione polacca " -"inversa](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" -"Per semplicità, le nostre espressioni sono composte da dieci cifre `0`, ..., " -"`9` e due\n" +"Il nostro obiettivo è tradurre semplici espressioni matematiche in espressioni postfisse\n" +"(o [notazione polacca inversa](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Per semplicità, le nostre espressioni sono composte da dieci cifre `0`, ..., `9` e due\n" "operazioni `+`, `-`. Ad esempio, l'espressione \"2 + 4\" è tradotta in\n" "`2 4 +`." @@ -4173,16 +3586,12 @@ msgstr "## Grammatica senza contesto per il nostro problema" #: src\patterns/behavioural/interpreter.md:26 #, fuzzy msgid "" -"Our task is translating infix expressions into postfix ones. Let's define a " -"context\n" -"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and " -"`-`,\n" +"Our task is translating infix expressions into postfix ones. Let's define a context\n" +"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and `-`,\n" "where:" msgstr "" -"Il nostro compito è tradurre le espressioni infisse in postfisse. Definiamo " -"un contesto\n" -"grammatica libera per un insieme di espressioni infisse su `0`, ..., `9`, " -"`+` e `-`,\n" +"Il nostro compito è tradurre le espressioni infisse in postfisse. Definiamo un contesto\n" +"grammatica libera per un insieme di espressioni infisse su `0`, ..., `9`, `+` e `-`,\n" "Dove:" #: src\patterns/behavioural/interpreter.md:30 @@ -4211,20 +3620,16 @@ msgstr "" #: src\patterns/behavioural/interpreter.md:42 #, fuzzy msgid "" -"**NOTE:** This grammar should be further transformed depending on what we " -"are going\n" -"to do with it. For example, we might need to remove left recursion. For " -"more\n" -"details please see [Compilers: Principles,Techniques, and " -"Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools)\n" +"**NOTE:** This grammar should be further transformed depending on what we are going\n" +"to do with it. For example, we might need to remove left recursion. For more\n" +"details please see [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques," +"_and_Tools)\n" "(aka Dragon Book)." msgstr "" -"**NOTA:** Questa grammatica dovrebbe essere ulteriormente trasformata a " -"seconda di cosa stiamo andando\n" -"a che fare con esso. Ad esempio, potremmo dover rimuovere la ricorsione a " -"sinistra. Per più\n" -"dettagli vedere [Compilers: Principles,Techniques, and " -"Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools)\n" +"**NOTA:** Questa grammatica dovrebbe essere ulteriormente trasformata a seconda di cosa stiamo andando\n" +"a che fare con esso. Ad esempio, potremmo dover rimuovere la ricorsione a sinistra. Per più\n" +"dettagli vedere [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques," +"_and_Tools)\n" "(alias Libro del Drago)." #: src\patterns/behavioural/interpreter.md:47 @@ -4235,16 +3640,12 @@ msgstr "## Soluzione" #: src\patterns/behavioural/interpreter.md:49 #, fuzzy msgid "" -"We simply implement a recursive descent parser. For simplicity's sake, the " -"code\n" -"panics when an expression is syntactically wrong (for example `2-34` or " -"`2+5-`\n" +"We simply implement a recursive descent parser. For simplicity's sake, the code\n" +"panics when an expression is syntactically wrong (for example `2-34` or `2+5-`\n" "are wrong according to the grammar definition)." msgstr "" -"Implementiamo semplicemente un parser di discesa ricorsivo. Per semplicità, " -"il codice\n" -"va in panico quando un'espressione è sintatticamente errata (ad esempio " -"`2-34` o `2+5-`\n" +"Implementiamo semplicemente un parser di discesa ricorsivo. Per semplicità, il codice\n" +"va in panico quando un'espressione è sintatticamente errata (ad esempio `2-34` o `2+5-`\n" "sono errate secondo la definizione grammaticale)." #: src\patterns/behavioural/interpreter.md:53 @@ -4303,28 +3704,18 @@ msgstr "" #: src\patterns/behavioural/interpreter.md:105 #, fuzzy msgid "" -"There may be a wrong perception that the Interpreter design pattern is about " -"design\n" -"grammars for formal languages and implementation of parsers for these " -"grammars.\n" -"In fact, this pattern is about expressing problem instances in a more " -"specific\n" -"way and implementing functions/classes/structs that solve these problem " -"instances.\n" -"Rust language has `macro_rules!` that allow us to define special syntax and " -"rules\n" +"There may be a wrong perception that the Interpreter design pattern is about design\n" +"grammars for formal languages and implementation of parsers for these grammars.\n" +"In fact, this pattern is about expressing problem instances in a more specific\n" +"way and implementing functions/classes/structs that solve these problem instances.\n" +"Rust language has `macro_rules!` that allow us to define special syntax and rules\n" "on how to expand this syntax into source code." msgstr "" -"Potrebbe esserci una percezione errata che il modello di progettazione di " -"Interpreter riguardi il design\n" -"grammatiche per linguaggi formali e implementazione di parser per queste " -"grammatiche.\n" -"In effetti, questo modello riguarda l'espressione di istanze problematiche " -"in modo più specifico\n" -"modo e implementando funzioni/classi/strutture che risolvono queste istanze " -"del problema.\n" -"Il linguaggio Rust ha `macro_rules!` che ci permettono di definire sintassi " -"e regole speciali\n" +"Potrebbe esserci una percezione errata che il modello di progettazione di Interpreter riguardi il design\n" +"grammatiche per linguaggi formali e implementazione di parser per queste grammatiche.\n" +"In effetti, questo modello riguarda l'espressione di istanze problematiche in modo più specifico\n" +"modo e implementando funzioni/classi/strutture che risolvono queste istanze del problema.\n" +"Il linguaggio Rust ha `macro_rules!` che ci permettono di definire sintassi e regole speciali\n" "su come espandere questa sintassi nel codice sorgente." #: src\patterns/behavioural/interpreter.md:112 @@ -4332,19 +3723,14 @@ msgstr "" msgid "" "In the following example we create a simple `macro_rules!` that computes\n" "[Euclidean length](https://en.wikipedia.org/wiki/Euclidean_distance) of `n`\n" -"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and " -"more\n" -"efficient than packing `x,1,2` into a `Vec` and calling a function " -"computing\n" +"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and more\n" +"efficient than packing `x,1,2` into a `Vec` and calling a function computing\n" "the length." msgstr "" "Nell'esempio seguente creiamo un semplice `macro_rules!` che calcola\n" -"[Lunghezza euclidea](https://en.wikipedia.org/wiki/Euclidean_distance) di " -"`n`\n" -"vettori dimensionali. Scrivere `norma!(x,1,2)` potrebbe essere più facile da " -"esprimere e altro ancora\n" -"efficiente che comprimere `x,1,2` in un `Vec` e chiamare una funzione di " -"calcolo\n" +"[Lunghezza euclidea](https://en.wikipedia.org/wiki/Euclidean_distance) di `n`\n" +"vettori dimensionali. Scrivere `norma!(x,1,2)` potrebbe essere più facile da esprimere e altro ancora\n" +"efficiente che comprimere `x,1,2` in un `Vec` e chiamare una funzione di calcolo\n" "la lunghezza." #: src\patterns/behavioural/interpreter.md:118 @@ -4378,14 +3764,11 @@ msgstr "" #, fuzzy msgid "" "- [Interpreter pattern](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" -"- [Context free " -"grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [Context free grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" "- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" msgstr "" -"- [Modello " -"dell'interprete](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" -"- [Grammatica senza " -"contesto](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [Modello dell'interprete](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" +"- [Grammatica senza contesto](https://en.wikipedia.org/wiki/Context-free_grammar)\n" "- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" #: src\patterns/behavioural/newtype.md:1 @@ -4400,45 +3783,36 @@ msgid "" "enforce some behaviour at compile time when using only type aliases would\n" "not be enough?" msgstr "" -"Cosa succede se in alcuni casi vogliamo che un tipo si comporti in modo " -"simile a un altro tipo o\n" -"applicare alcuni comportamenti in fase di compilazione quando si utilizzano " -"solo alias di tipo\n" +"Cosa succede se in alcuni casi vogliamo che un tipo si comporti in modo simile a un altro tipo o\n" +"applicare alcuni comportamenti in fase di compilazione quando si utilizzano solo alias di tipo\n" "non essere abbastanza?" #: src\patterns/behavioural/newtype.md:7 #, fuzzy msgid "" -"For example, if we want to create a custom `Display` implementation for " -"`String`\n" +"For example, if we want to create a custom `Display` implementation for `String`\n" "due to security considerations (e.g. passwords)." msgstr "" -"Ad esempio, se vogliamo creare un'implementazione `Display` personalizzata " -"per `String`\n" +"Ad esempio, se vogliamo creare un'implementazione `Display` personalizzata per `String`\n" "per motivi di sicurezza (ad es. password)." #: src\patterns/behavioural/newtype.md:10 #, fuzzy msgid "" -"For such cases we could use the `Newtype` pattern to provide **type " -"safety**\n" +"For such cases we could use the `Newtype` pattern to provide **type safety**\n" "and **encapsulation**." msgstr "" -"Per questi casi potremmo usare il modello `Newtype` per fornire **sicurezza " -"del tipo**\n" +"Per questi casi potremmo usare il modello `Newtype` per fornire **sicurezza del tipo**\n" "e **incapsulamento**." #: src\patterns/behavioural/newtype.md:15 #, fuzzy msgid "" -"Use a tuple struct with a single field to make an opaque wrapper for a " -"type.\n" +"Use a tuple struct with a single field to make an opaque wrapper for a type.\n" "This creates a new type, rather than an alias to a type (`type` items)." msgstr "" -"Usa una struttura di tupla con un singolo campo per creare un wrapper opaco " -"per un tipo.\n" -"Questo crea un nuovo tipo, piuttosto che un alias di un tipo (elementi " -"`type`)." +"Usa una struttura di tupla con un singolo campo per creare un wrapper opaco per un tipo.\n" +"Questo crea un nuovo tipo, piuttosto che un alias di un tipo (elementi `type`)." #: src\patterns/behavioural/newtype.md:20 msgid "" @@ -4483,20 +3857,14 @@ msgstr "" #, fuzzy msgid "" "The primary motivation for newtypes is abstraction. It allows you to share\n" -"implementation details between types while precisely controlling the " -"interface.\n" -"By using a newtype rather than exposing the implementation type as part of " -"an\n" +"implementation details between types while precisely controlling the interface.\n" +"By using a newtype rather than exposing the implementation type as part of an\n" "API, it allows you to change implementation backwards compatibly." msgstr "" -"La motivazione principale per i newtype è l'astrazione. Ti permette di " -"condividere\n" -"dettagli di implementazione tra i tipi controllando con precisione " -"l'interfaccia.\n" -"Usando un newtype piuttosto che esporre il tipo di implementazione come " -"parte di un\n" -"API, consente di modificare l'implementazione in modo compatibile con le " -"versioni precedenti." +"La motivazione principale per i newtype è l'astrazione. Ti permette di condividere\n" +"dettagli di implementazione tra i tipi controllando con precisione l'interfaccia.\n" +"Usando un newtype piuttosto che esporre il tipo di implementazione come parte di un\n" +"API, consente di modificare l'implementazione in modo compatibile con le versioni precedenti." #: src\patterns/behavioural/newtype.md:63 #, fuzzy @@ -4504,90 +3872,69 @@ msgid "" "Newtypes can be used for distinguishing units, e.g., wrapping `f64` to give\n" "distinguishable `Miles` and `Kilometres`." msgstr "" -"I newtype possono essere usati per distinguere le unità, ad esempio " -"avvolgendo `f64` per dare\n" +"I newtype possono essere usati per distinguere le unità, ad esempio avvolgendo `f64` per dare\n" "distinguibili `Miglia` e `Chilometri`." #: src\patterns/behavioural/newtype.md:68 #, fuzzy msgid "" "The wrapped and wrapper types are not type compatible (as opposed to using\n" -"`type`), so users of the newtype will never 'confuse' the wrapped and " -"wrapper\n" +"`type`), so users of the newtype will never 'confuse' the wrapped and wrapper\n" "types." msgstr "" -"I tipi wrapper e wrapper non sono compatibili con i tipi (al contrario di " -"using\n" -"`type`), quindi gli utenti del newtype non 'confonderanno' mai il wrapper e " -"il wrapper\n" +"I tipi wrapper e wrapper non sono compatibili con i tipi (al contrario di using\n" +"`type`), quindi gli utenti del newtype non 'confonderanno' mai il wrapper e il wrapper\n" "tipi." #: src\patterns/behavioural/newtype.md:72 #, fuzzy msgid "Newtypes are a zero-cost abstraction - there is no runtime overhead." -msgstr "" -"I newtype sono un'astrazione a costo zero: non vi è alcun sovraccarico di " -"runtime." +msgstr "I newtype sono un'astrazione a costo zero: non vi è alcun sovraccarico di runtime." #: src\patterns/behavioural/newtype.md:74 #, fuzzy msgid "" -"The privacy system ensures that users cannot access the wrapped type (if " -"the\n" +"The privacy system ensures that users cannot access the wrapped type (if the\n" "field is private, which it is by default)." msgstr "" -"Il sistema di privacy garantisce che gli utenti non possano accedere al tipo " -"avvolto (se il file\n" +"Il sistema di privacy garantisce che gli utenti non possano accedere al tipo avvolto (se il file\n" "campo è privato, che è per impostazione predefinita)." #: src\patterns/behavioural/newtype.md:79 #, fuzzy msgid "" -"The downside of newtypes (especially compared with type aliases), is that " -"there\n" -"is no special language support. This means there can be _a lot_ of " -"boilerplate.\n" +"The downside of newtypes (especially compared with type aliases), is that there\n" +"is no special language support. This means there can be _a lot_ of boilerplate.\n" "You need a 'pass through' method for every method you want to expose on the\n" -"wrapped type, and an impl for every trait you want to also be implemented " -"for\n" +"wrapped type, and an impl for every trait you want to also be implemented for\n" "the wrapper type." msgstr "" -"Lo svantaggio dei newtype (soprattutto rispetto agli alias di tipo) è che " -"esiste\n" -"non è un supporto linguistico speciale. Ciò significa che ci possono essere " -"_molti_ standard.\n" -"È necessario un metodo \"pass through\" per ogni metodo che si desidera " -"esporre sul file\n" +"Lo svantaggio dei newtype (soprattutto rispetto agli alias di tipo) è che esiste\n" +"non è un supporto linguistico speciale. Ciò significa che ci possono essere _molti_ standard.\n" +"È necessario un metodo \"pass through\" per ogni metodo che si desidera esporre sul file\n" "tipo avvolto e un impl per ogni tratto per cui vuoi essere implementato\n" "il tipo di involucro." #: src\patterns/behavioural/newtype.md:87 #, fuzzy msgid "" -"Newtypes are very common in Rust code. Abstraction or representing units are " -"the\n" +"Newtypes are very common in Rust code. Abstraction or representing units are the\n" "most common uses, but they can be used for other reasons:" msgstr "" -"I newtype sono molto comuni nel codice Rust. Le unità di astrazione o di " -"rappresentazione sono le\n" +"I newtype sono molto comuni nel codice Rust. Le unità di astrazione o di rappresentazione sono le\n" "usi più comuni, ma possono essere utilizzati per altri motivi:" #: src\patterns/behavioural/newtype.md:90 #, fuzzy msgid "" -"- restricting functionality (reduce the functions exposed or traits " -"implemented),\n" +"- restricting functionality (reduce the functions exposed or traits implemented),\n" "- making a type with copy semantics have move semantics,\n" -"- abstraction by providing a more concrete type and thus hiding internal " -"types,\n" +"- abstraction by providing a more concrete type and thus hiding internal types,\n" " e.g.," msgstr "" -"- limitare la funzionalità (ridurre le funzioni esposte o i tratti " -"implementati),\n" -"- fare in modo che un tipo con semantica di copia abbia semantica di " -"spostamento,\n" -"- astrazione fornendo un tipo più concreto e quindi nascondendo i tipi " -"interni,\n" +"- limitare la funzionalità (ridurre le funzioni esposte o i tratti implementati),\n" +"- fare in modo che un tipo con semantica di copia abbia semantica di spostamento,\n" +"- astrazione fornendo un tipo più concreto e quindi nascondendo i tipi interni,\n" " per esempio.," #: src\patterns/behavioural/newtype.md:95 @@ -4600,47 +3947,34 @@ msgstr "" #: src\patterns/behavioural/newtype.md:99 #, fuzzy msgid "" -"Here, `Bar` might be some public, generic type and `T1` and `T2` are some " -"internal\n" -"types. Users of our module shouldn't know that we implement `Foo` by using a " -"`Bar`,\n" -"but what we're really hiding here is the types `T1` and `T2`, and how they " -"are used\n" +"Here, `Bar` might be some public, generic type and `T1` and `T2` are some internal\n" +"types. Users of our module shouldn't know that we implement `Foo` by using a `Bar`,\n" +"but what we're really hiding here is the types `T1` and `T2`, and how they are used\n" "with `Bar`." msgstr "" -"Qui, \"Bar\" potrebbe essere un tipo generico pubblico e \"T1\" e \"T2\" " -"sono interni\n" -"tipi. Gli utenti del nostro modulo non dovrebbero sapere che implementiamo " -"`Foo` utilizzando un `Bar`,\n" -"ma quello che in realtà stiamo nascondendo qui sono i tipi `T1` e `T2`, e " -"come vengono usati\n" +"Qui, \"Bar\" potrebbe essere un tipo generico pubblico e \"T1\" e \"T2\" sono interni\n" +"tipi. Gli utenti del nostro modulo non dovrebbero sapere che implementiamo `Foo` utilizzando un `Bar`,\n" +"ma quello che in realtà stiamo nascondendo qui sono i tipi `T1` e `T2`, e come vengono usati\n" "con \"Barra\"." #: src\patterns/behavioural/newtype.md:106 #, fuzzy msgid "" -"- [Advanced Types in the " -"book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-type-safety-and-abstraction)\n" +"- [Advanced Types in the book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-" +"for-type-safety-and-abstraction)\n" "- [Newtypes in Haskell](https://wiki.haskell.org/Newtype)\n" -"- [Type " -"aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" -"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving " -"many\n" +"- [Type aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving many\n" " builtin traits on newtypes.\n" -"- [The Newtype Pattern In " -"Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +"- [The Newtype Pattern In Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" msgstr "" -"- [Tipi avanzati nel " -"libro](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-type-safety " -"-e-astrazione)\n" +"- [Tipi avanzati nel libro](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-" +"type-safety -e-astrazione)\n" "- [Newtype in Haskell](https://wiki.haskell.org/Newtype)\n" -"- [Alias di " -"tipo](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" -"- [derive_more](https://crates.io/crates/derive_more), una cassa per " -"derivare molti\n" +"- [Alias di tipo](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), una cassa per derivare molti\n" " tratti incorporati su newtypes.\n" -"- [Il modello Newtype in " -"Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +"- [Il modello Newtype in Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" #: src\patterns/behavioural/RAII.md:1 #, fuzzy @@ -4650,37 +3984,25 @@ msgstr "# RAII con le guardie" #: src\patterns/behavioural/RAII.md:5 #, fuzzy msgid "" -"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" " -"which is a\n" -"terrible name. The essence of the pattern is that resource initialisation is " -"done\n" -"in the constructor of an object and finalisation in the destructor. This " -"pattern\n" -"is extended in Rust by using a RAII object as a guard of some resource and " -"relying\n" -"on the type system to ensure that access is always mediated by the guard " -"object." -msgstr "" -"[RAII][wikipedia] sta per \"Resource Acquisition is Initialisation\" che è " -"a\n" -"nome terribile. L'essenza del modello è che l'inizializzazione della risorsa " -"è stata eseguita\n" -"nel costruttore di un oggetto e la finalizzazione nel distruttore. Questo " -"modello\n" -"è esteso in Rust utilizzando un oggetto RAII come protezione di alcune " -"risorse e facendo affidamento\n" -"sul sistema di tipo per garantire che l'accesso sia sempre mediato " -"dall'oggetto di guardia." +"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" which is a\n" +"terrible name. The essence of the pattern is that resource initialisation is done\n" +"in the constructor of an object and finalisation in the destructor. This pattern\n" +"is extended in Rust by using a RAII object as a guard of some resource and relying\n" +"on the type system to ensure that access is always mediated by the guard object." +msgstr "" +"[RAII][wikipedia] sta per \"Resource Acquisition is Initialisation\" che è a\n" +"nome terribile. L'essenza del modello è che l'inizializzazione della risorsa è stata eseguita\n" +"nel costruttore di un oggetto e la finalizzazione nel distruttore. Questo modello\n" +"è esteso in Rust utilizzando un oggetto RAII come protezione di alcune risorse e facendo affidamento\n" +"sul sistema di tipo per garantire che l'accesso sia sempre mediato dall'oggetto di guardia." #: src\patterns/behavioural/RAII.md:13 #, fuzzy msgid "" -"Mutex guards are the classic example of this pattern from the std library " -"(this\n" +"Mutex guards are the classic example of this pattern from the std library (this\n" "is a simplified version of the real implementation):" msgstr "" -"Le guardie mutex sono il classico esempio di questo modello dalla libreria " -"std (this\n" +"Le guardie mutex sono il classico esempio di questo modello dalla libreria std (this\n" "è una versione semplificata dell'implementazione reale):" #: src\patterns/behavioural/RAII.md:16 @@ -4734,12 +4056,10 @@ msgid "" "fn baz(x: Mutex) {\n" " let xx = x.lock();\n" " xx.foo(); // foo is a method on Foo.\n" -" // The borrow checker ensures we can't store a reference to the " -"underlying\n" +" // The borrow checker ensures we can't store a reference to the underlying\n" " // Foo which will outlive the guard xx.\n" "\n" -" // x is unlocked when we exit this function and xx's destructor is " -"executed.\n" +" // x is unlocked when we exit this function and xx's destructor is executed.\n" "}\n" "```" msgstr "" @@ -4748,65 +4068,49 @@ msgstr "" #, fuzzy msgid "" "Where a resource must be finalised after use, RAII can be used to do this\n" -"finalisation. If it is an error to access that resource after finalisation, " -"then\n" +"finalisation. If it is an error to access that resource after finalisation, then\n" "this pattern can be used to prevent such errors." msgstr "" -"Laddove una risorsa deve essere finalizzata dopo l'uso, RAII può essere " -"utilizzata per farlo\n" -"finalizzazione. Se è un errore accedere a quella risorsa dopo la " -"finalizzazione, allora\n" +"Laddove una risorsa deve essere finalizzata dopo l'uso, RAII può essere utilizzata per farlo\n" +"finalizzazione. Se è un errore accedere a quella risorsa dopo la finalizzazione, allora\n" "questo modello può essere utilizzato per prevenire tali errori." #: src\patterns/behavioural/RAII.md:80 #, fuzzy msgid "" -"Prevents errors where a resource is not finalised and where a resource is " -"used\n" +"Prevents errors where a resource is not finalised and where a resource is used\n" "after finalisation." msgstr "" -"Previene gli errori in cui una risorsa non è finalizzata e in cui viene " -"utilizzata una risorsa\n" +"Previene gli errori in cui una risorsa non è finalizzata e in cui viene utilizzata una risorsa\n" "dopo la finalizzazione." #: src\patterns/behavioural/RAII.md:85 #, fuzzy msgid "" "RAII is a useful pattern for ensuring resources are properly deallocated or\n" -"finalised. We can make use of the borrow checker in Rust to statically " -"prevent\n" +"finalised. We can make use of the borrow checker in Rust to statically prevent\n" "errors stemming from using resources after finalisation takes place." msgstr "" -"RAII è un modello utile per garantire che le risorse siano adeguatamente " -"deallocate o\n" -"finalizzato. Possiamo utilizzare il controllo del prestito in Rust per " -"prevenire staticamente\n" +"RAII è un modello utile per garantire che le risorse siano adeguatamente deallocate o\n" +"finalizzato. Possiamo utilizzare il controllo del prestito in Rust per prevenire staticamente\n" "errori derivanti dall'utilizzo delle risorse dopo la finalizzazione." #: src\patterns/behavioural/RAII.md:89 #, fuzzy msgid "" -"The core aim of the borrow checker is to ensure that references to data do " -"not\n" +"The core aim of the borrow checker is to ensure that references to data do not\n" "outlive that data. The RAII guard pattern works because the guard object\n" "contains a reference to the underlying resource and only exposes such\n" -"references. Rust ensures that the guard cannot outlive the underlying " -"resource\n" -"and that references to the resource mediated by the guard cannot outlive " -"the\n" -"guard. To see how this works it is helpful to examine the signature of " -"`deref`\n" +"references. Rust ensures that the guard cannot outlive the underlying resource\n" +"and that references to the resource mediated by the guard cannot outlive the\n" +"guard. To see how this works it is helpful to examine the signature of `deref`\n" "without lifetime elision:" msgstr "" -"L'obiettivo principale del controllo del prestito è garantire che i " -"riferimenti ai dati non lo facciano\n" -"sopravvivere a quei dati. Il modello di guardia RAII funziona perché " -"l'oggetto di guardia\n" +"L'obiettivo principale del controllo del prestito è garantire che i riferimenti ai dati non lo facciano\n" +"sopravvivere a quei dati. Il modello di guardia RAII funziona perché l'oggetto di guardia\n" "contiene un riferimento alla risorsa sottostante ed espone solo tale\n" -"Riferimenti. Rust assicura che la guardia non possa sopravvivere alla " -"risorsa sottostante\n" -"e che i riferimenti alla risorsa mediati dalla guardia non possono " -"sopravvivere\n" +"Riferimenti. Rust assicura che la guardia non possa sopravvivere alla risorsa sottostante\n" +"e che i riferimenti alla risorsa mediati dalla guardia non possono sopravvivere\n" "guardia. Per vedere come funziona è utile esaminare la firma di `deref`\n" "senza elisione a vita:" @@ -4822,59 +4126,46 @@ msgstr "" #: src\patterns/behavioural/RAII.md:103 #, fuzzy msgid "" -"The returned reference to the resource has the same lifetime as `self` " -"(`'a`).\n" -"The borrow checker therefore ensures that the lifetime of the reference to " -"`T`\n" +"The returned reference to the resource has the same lifetime as `self` (`'a`).\n" +"The borrow checker therefore ensures that the lifetime of the reference to `T`\n" "is shorter than the lifetime of `self`." msgstr "" -"Il riferimento restituito alla risorsa ha la stessa durata di `self` " -"(`'a`).\n" -"Il controllo del prestito assicura quindi che la durata del riferimento a " -"\"T\".\n" +"Il riferimento restituito alla risorsa ha la stessa durata di `self` (`'a`).\n" +"Il controllo del prestito assicura quindi che la durata del riferimento a \"T\".\n" "è più breve della durata di `self`." #: src\patterns/behavioural/RAII.md:107 #, fuzzy msgid "" -"Note that implementing `Deref` is not a core part of this pattern, it only " -"makes\n" -"using the guard object more ergonomic. Implementing a `get` method on the " -"guard\n" +"Note that implementing `Deref` is not a core part of this pattern, it only makes\n" +"using the guard object more ergonomic. Implementing a `get` method on the guard\n" "works just as well." msgstr "" -"Si noti che l'implementazione di \"Deref\" non è una parte fondamentale di " -"questo modello, lo fa solo\n" -"utilizzando l'oggetto di protezione più ergonomico. Implementazione di un " -"metodo `get` in guardia\n" +"Si noti che l'implementazione di \"Deref\" non è una parte fondamentale di questo modello, lo fa solo\n" +"utilizzando l'oggetto di protezione più ergonomico. Implementazione di un metodo `get` in guardia\n" "funziona altrettanto bene." #: src\patterns/behavioural/RAII.md:113 #, fuzzy msgid "[Finalisation in destructors idiom](../../idioms/dtor-finally.md)" -msgstr "" -"[Finalizzazione nell'idioma dei distruttori](../../idioms/dtor-finally.md)" +msgstr "[Finalizzazione nell'idioma dei distruttori](../../idioms/dtor-finally.md)" #: src\patterns/behavioural/RAII.md:115 #, fuzzy msgid "" -"RAII is a common pattern in C++: " -"[cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"RAII is a common pattern in C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" "[wikipedia][wikipedia]." msgstr "" -"RAII è un modello comune in C++: " -"[cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"RAII è un modello comune in C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" "[wikipedia][wikipedia]." #: src\patterns/behavioural/RAII.md:120 #, fuzzy msgid "" -"[Style guide " -"entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"[Style guide entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" "(currently just a placeholder)." msgstr "" -"[Voce della guida di " -"stile](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"[Voce della guida di stile](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" "(attualmente solo un segnaposto)." #: src\patterns/behavioural/strategy.md:1 @@ -4885,93 +4176,68 @@ msgstr "# Strategia (ovvero Politica)" #: src\patterns/behavioural/strategy.md:5 #, fuzzy msgid "" -"The [Strategy design " -"pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"The [Strategy design pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" "is a technique that enables separation of concerns.\n" -"It also allows to decouple software modules through [Dependency " -"Inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +"It also allows to decouple software modules through [Dependency Inversion](https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." msgstr "" -"Il [modello di progettazione della " -"strategia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"Il [modello di progettazione della strategia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" "è una tecnica che consente la separazione delle preoccupazioni.\n" -"Consente inoltre di disaccoppiare i moduli software tramite [Dependency " -"Inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +"Consente inoltre di disaccoppiare i moduli software tramite [Dependency Inversion](https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." #: src\patterns/behavioural/strategy.md:9 #, fuzzy msgid "" -"The basic idea behind the Strategy pattern is that, given an algorithm " -"solving\n" -"a particular problem, we define only the skeleton of the algorithm at an " -"abstract\n" -"level, and we separate the specific algorithm’s implementation into " -"different parts." +"The basic idea behind the Strategy pattern is that, given an algorithm solving\n" +"a particular problem, we define only the skeleton of the algorithm at an abstract\n" +"level, and we separate the specific algorithm’s implementation into different parts." msgstr "" -"L'idea di base alla base del modello di strategia è che, data la risoluzione " -"di un algoritmo\n" -"un problema particolare, definiamo solo lo scheletro dell'algoritmo in " -"astratto\n" -"livello e separiamo l'implementazione dell'algoritmo specifico in parti " -"diverse." +"L'idea di base alla base del modello di strategia è che, data la risoluzione di un algoritmo\n" +"un problema particolare, definiamo solo lo scheletro dell'algoritmo in astratto\n" +"livello e separiamo l'implementazione dell'algoritmo specifico in parti diverse." #: src\patterns/behavioural/strategy.md:13 #, fuzzy msgid "" -"In this way, a client using the algorithm may choose a specific " -"implementation,\n" -"while the general algorithm workflow remains the same. In other words, the " -"abstract\n" -"specification of the class does not depend on the specific implementation of " -"the\n" -"derived class, but specific implementation must adhere to the abstract " -"specification.\n" +"In this way, a client using the algorithm may choose a specific implementation,\n" +"while the general algorithm workflow remains the same. In other words, the abstract\n" +"specification of the class does not depend on the specific implementation of the\n" +"derived class, but specific implementation must adhere to the abstract specification.\n" "This is why we call it \"Dependency Inversion\"." msgstr "" -"In questo modo, un client che utilizza l'algoritmo può scegliere " -"un'implementazione specifica,\n" -"mentre il flusso di lavoro generale dell'algoritmo rimane lo stesso. In " -"altre parole, l'astratto\n" +"In questo modo, un client che utilizza l'algoritmo può scegliere un'implementazione specifica,\n" +"mentre il flusso di lavoro generale dell'algoritmo rimane lo stesso. In altre parole, l'astratto\n" "la specifica della classe non dipende dall'implementazione specifica del\n" -"classe derivata, ma l'implementazione specifica deve aderire alla specifica " -"astratta.\n" +"classe derivata, ma l'implementazione specifica deve aderire alla specifica astratta.\n" "Questo è il motivo per cui lo chiamiamo \"Dependency Inversion\"." #: src\patterns/behavioural/strategy.md:21 #, fuzzy msgid "" "Imagine we are working on a project that generates reports every month.\n" -"We need the reports to be generated in different formats (strategies), " -"e.g.,\n" +"We need the reports to be generated in different formats (strategies), e.g.,\n" "in `JSON` or `Plain Text` formats.\n" -"But things vary over time, and we don't know what kind of requirement we may " -"get\n" -"in the future. For example, we may need to generate our report in a " -"completely new\n" +"But things vary over time, and we don't know what kind of requirement we may get\n" +"in the future. For example, we may need to generate our report in a completely new\n" "format, or just modify one of the existing formats." msgstr "" "Immagina di lavorare a un progetto che genera report ogni mese.\n" -"Abbiamo bisogno che i report siano generati in diversi formati (strategie), " -"ad es.\n" +"Abbiamo bisogno che i report siano generati in diversi formati (strategie), ad es.\n" "nei formati `JSON` o `Plain Text`.\n" -"Ma le cose variano nel tempo e non sappiamo che tipo di requisiti potremmo " -"ottenere\n" -"in futuro. Ad esempio, potremmo aver bisogno di generare il nostro report in " -"un formato completamente nuovo\n" +"Ma le cose variano nel tempo e non sappiamo che tipo di requisiti potremmo ottenere\n" +"in futuro. Ad esempio, potremmo aver bisogno di generare il nostro report in un formato completamente nuovo\n" "formato, o semplicemente modificare uno dei formati esistenti." #: src\patterns/behavioural/strategy.md:30 #, fuzzy msgid "" -"In this example our invariants (or abstractions) are `Context`, " -"`Formatter`,\n" -"and `Report`, while `Text` and `Json` are our strategy structs. These " -"strategies\n" +"In this example our invariants (or abstractions) are `Context`, `Formatter`,\n" +"and `Report`, while `Text` and `Json` are our strategy structs. These strategies\n" "have to implement the `Formatter` trait." msgstr "" -"In questo esempio le nostre invarianti (o astrazioni) sono `Context`, " -"`Formatter`,\n" -"e `Report`, mentre `Text` e `Json` sono le nostre strutture strategiche. " -"Queste strategie\n" +"In questo esempio le nostre invarianti (o astrazioni) sono `Context`, `Formatter`,\n" +"e `Report`, mentre `Text` e `Json` sono le nostre strutture strategiche. Queste strategie\n" "devono implementare il tratto `Formatter`." #: src\patterns/behavioural/strategy.md:34 @@ -4988,8 +4254,7 @@ msgid "" "struct Report;\n" "\n" "impl Report {\n" -" // Write should be used but we kept it as String to ignore error " -"handling\n" +" // Write should be used but we kept it as String to ignore error handling\n" " fn generate(g: T, s: &mut String) {\n" " // backend operations...\n" " let mut data = HashMap::new();\n" @@ -5004,8 +4269,7 @@ msgid "" "impl Formatter for Text {\n" " fn format(&self, data: &Data, buf: &mut String) {\n" " for (k, v) in data {\n" -" let entry = format!(\"{} {}\\n" -"\", k, v);\n" +" let entry = format!(\"{} {}\\n\", k, v);\n" " buf.push_str(&entry);\n" " }\n" " }\n" @@ -5044,39 +4308,28 @@ msgstr "" #: src\patterns/behavioural/strategy.md:98 #, fuzzy msgid "" -"The main advantage is separation of concerns. For example, in this case " -"`Report`\n" +"The main advantage is separation of concerns. For example, in this case `Report`\n" "does not know anything about specific implementations of `Json` and `Text`,\n" -"whereas the output implementations does not care about how data is " -"preprocessed,\n" -"stored, and fetched. The only thing they have to know is context and a " -"specific\n" +"whereas the output implementations does not care about how data is preprocessed,\n" +"stored, and fetched. The only thing they have to know is context and a specific\n" "trait and method to implement, i.e,`Formatter` and `run`." msgstr "" -"Il vantaggio principale è la separazione delle preoccupazioni. Ad esempio, " -"in questo caso `Report`\n" +"Il vantaggio principale è la separazione delle preoccupazioni. Ad esempio, in questo caso `Report`\n" "non sa nulla di specifiche implementazioni di `Json` e `Text`,\n" -"considerando che le implementazioni di output non si preoccupano di come i " -"dati vengono preelaborati,\n" -"memorizzato e recuperato. L'unica cosa che devono sapere è il contesto e uno " -"specifico\n" +"considerando che le implementazioni di output non si preoccupano di come i dati vengono preelaborati,\n" +"memorizzato e recuperato. L'unica cosa che devono sapere è il contesto e uno specifico\n" "tratto e metodo da implementare, ad esempio `Formatter` e `run`." #: src\patterns/behavioural/strategy.md:106 #, fuzzy msgid "" -"For each strategy there must be implemented at least one module, so number " -"of modules\n" -"increases with number of strategies. If there are many strategies to choose " -"from\n" +"For each strategy there must be implemented at least one module, so number of modules\n" +"increases with number of strategies. If there are many strategies to choose from\n" "then users have to know how strategies differ from one another." msgstr "" -"Per ogni strategia deve essere implementato almeno un modulo, quindi numero " -"di moduli\n" -"aumenta con il numero di strategie. Se ci sono molte strategie tra cui " -"scegliere\n" -"quindi gli utenti devono sapere in che modo le strategie differiscono l'una " -"dall'altra." +"Per ogni strategia deve essere implementato almeno un modulo, quindi numero di moduli\n" +"aumenta con il numero di strategie. Se ci sono molte strategie tra cui scegliere\n" +"quindi gli utenti devono sapere in che modo le strategie differiscono l'una dall'altra." #: src\patterns/behavioural/strategy.md:112 #, fuzzy @@ -5084,72 +4337,51 @@ msgid "" "In the previous example all strategies are implemented in a single file.\n" "Ways of providing different strategies includes:" msgstr "" -"Nell'esempio precedente tutte le strategie sono implementate in un singolo " -"file.\n" +"Nell'esempio precedente tutte le strategie sono implementate in un singolo file.\n" "I modi per fornire diverse strategie includono:" #: src\patterns/behavioural/strategy.md:115 #, fuzzy msgid "" -"- All in one file (as shown in this example, similar to being separated as " -"modules)\n" -"- Separated as modules, E.g. `formatter::json` module, `formatter::text` " -"module\n" +"- All in one file (as shown in this example, similar to being separated as modules)\n" +"- Separated as modules, E.g. `formatter::json` module, `formatter::text` module\n" "- Use compiler feature flags, E.g. `json` feature, `text` feature\n" "- Separated as crates, E.g. `json` crate, `text` crate" msgstr "" -"- Tutto in un file (come mostrato in questo esempio, simile all'essere " -"separati come moduli)\n" -"- Separati come moduli, ad es. modulo `formatter::json`, modulo " -"`formatter::text`\n" -"- Usa i flag delle funzionalità del compilatore, ad es. Funzionalità " -"\"json\", funzionalità \"testo\".\n" +"- Tutto in un file (come mostrato in questo esempio, simile all'essere separati come moduli)\n" +"- Separati come moduli, ad es. modulo `formatter::json`, modulo `formatter::text`\n" +"- Usa i flag delle funzionalità del compilatore, ad es. Funzionalità \"json\", funzionalità \"testo\".\n" "- Separati come casse, ad es. cassa `json`, cassa `text`" #: src\patterns/behavioural/strategy.md:120 #, fuzzy msgid "" -"Serde crate is a good example of the `Strategy` pattern in action. Serde " -"allows\n" -"[full customization](https://serde.rs/custom-serialization.html) of the " -"serialization\n" -"behavior by manually implementing `Serialize` and `Deserialize` traits for " -"our\n" -"type. For example, we could easily swap `serde_json` with `serde_cbor` since " -"they\n" -"expose similar methods. Having this makes the helper crate `serde_transcode` " -"much\n" +"Serde crate is a good example of the `Strategy` pattern in action. Serde allows\n" +"[full customization](https://serde.rs/custom-serialization.html) of the serialization\n" +"behavior by manually implementing `Serialize` and `Deserialize` traits for our\n" +"type. For example, we could easily swap `serde_json` with `serde_cbor` since they\n" +"expose similar methods. Having this makes the helper crate `serde_transcode` much\n" "more useful and ergonomic." msgstr "" -"Serde crate è un buon esempio del modello \"Strategia\" in azione. Serde " -"consente\n" -"[personalizzazione completa](https://serde.rs/custom-serialization.html) " -"della serializzazione\n" -"comportamento implementando manualmente i tratti `Serialize` e `Deserialize` " -"per il nostro\n" -"tipo. Ad esempio, potremmo facilmente scambiare `serde_json` con " -"`serde_cbor` poiché loro\n" -"esporre metodi simili. Avere questo rende l'helper crate `serde_transcode` " -"molto\n" +"Serde crate è un buon esempio del modello \"Strategia\" in azione. Serde consente\n" +"[personalizzazione completa](https://serde.rs/custom-serialization.html) della serializzazione\n" +"comportamento implementando manualmente i tratti `Serialize` e `Deserialize` per il nostro\n" +"tipo. Ad esempio, potremmo facilmente scambiare `serde_json` con `serde_cbor` poiché loro\n" +"esporre metodi simili. Avere questo rende l'helper crate `serde_transcode` molto\n" "più utile ed ergonomico." #: src\patterns/behavioural/strategy.md:127 #, fuzzy -msgid "" -"However, we don't need to use traits in order to design this pattern in Rust." -msgstr "" -"Tuttavia, non abbiamo bisogno di utilizzare i tratti per progettare questo " -"modello in Rust." +msgid "However, we don't need to use traits in order to design this pattern in Rust." +msgstr "Tuttavia, non abbiamo bisogno di utilizzare i tratti per progettare questo modello in Rust." #: src\patterns/behavioural/strategy.md:129 #, fuzzy msgid "" -"The following toy example demonstrates the idea of the Strategy pattern " -"using Rust\n" +"The following toy example demonstrates the idea of the Strategy pattern using Rust\n" "`closures`:" msgstr "" -"Il seguente esempio di giocattolo dimostra l'idea del pattern Strategy " -"usando Rust\n" +"Il seguente esempio di giocattolo dimostra l'idea del pattern Strategy usando Rust\n" "`chiusure`:" #: src\patterns/behavioural/strategy.md:132 @@ -5207,16 +4439,12 @@ msgstr "" #, fuzzy msgid "" "- [Strategy Pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"- [Dependency " -"Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" -"- [Policy Based " -"Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +"- [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Policy Based Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" msgstr "" "- [Modello strategico](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"- [Iniezione di " -"dipendenza](https://en.wikipedia.org/wiki/Dependency_injection)\n" -"- [Progettazione basata su " -"criteri](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +"- [Iniezione di dipendenza](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Progettazione basata su criteri](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" #: src\patterns/behavioural/visitor.md:1 #, fuzzy @@ -5227,8 +4455,7 @@ msgstr "# Visitatore" #, fuzzy msgid "" "A visitor encapsulates an algorithm that operates over a heterogeneous\n" -"collection of objects. It allows multiple different algorithms to be " -"written\n" +"collection of objects. It allows multiple different algorithms to be written\n" "over the same data without having to modify the data (or their primary\n" "behaviour)." msgstr "" @@ -5243,8 +4470,7 @@ msgid "" "Furthermore, the visitor pattern allows separating the traversal of\n" "a collection of objects from the operations performed on each object." msgstr "" -"Inoltre, il modello del visitatore consente di separare l'attraversamento " -"di\n" +"Inoltre, il modello del visitatore consente di separare l'attraversamento di\n" "una raccolta di oggetti dalle operazioni eseguite su ciascun oggetto." #: src\patterns/behavioural/visitor.md:15 @@ -5282,8 +4508,7 @@ msgid "" "use visit::*;\n" "use ast::*;\n" "\n" -"// An example concrete implementation - walks the AST interpreting it as " -"code.\n" +"// An example concrete implementation - walks the AST interpreting it as code.\n" "struct Interpreter;\n" "impl Visitor for Interpreter {\n" " fn visit_name(&mut self, n: &Name) -> i64 { panic!() }\n" @@ -5297,10 +4522,8 @@ msgid "" " fn visit_expr(&mut self, e: &Expr) -> i64 {\n" " match *e {\n" " Expr::IntLit(n) => n,\n" -" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + " -"self.visit_expr(rhs),\n" -" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - " -"self.visit_expr(rhs),\n" +" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + self.visit_expr(rhs),\n" +" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - self.visit_expr(rhs),\n" " }\n" " }\n" "}\n" @@ -5310,49 +4533,37 @@ msgstr "" #: src\patterns/behavioural/visitor.md:69 #, fuzzy msgid "" -"One could implement further visitors, for example a type checker, without " -"having\n" +"One could implement further visitors, for example a type checker, without having\n" "to modify the AST data." msgstr "" -"Si potrebbero implementare ulteriori visitatori, ad esempio un controllo di " -"tipo, senza avere\n" +"Si potrebbero implementare ulteriori visitatori, ad esempio un controllo di tipo, senza avere\n" "per modificare i dati AST." #: src\patterns/behavioural/visitor.md:74 #, fuzzy msgid "" -"The visitor pattern is useful anywhere that you want to apply an algorithm " -"to\n" -"heterogeneous data. If data is homogeneous, you can use an iterator-like " -"pattern.\n" -"Using a visitor object (rather than a functional approach) allows the " -"visitor to\n" +"The visitor pattern is useful anywhere that you want to apply an algorithm to\n" +"heterogeneous data. If data is homogeneous, you can use an iterator-like pattern.\n" +"Using a visitor object (rather than a functional approach) allows the visitor to\n" "be stateful and thus communicate information between nodes." msgstr "" "Il modello visitatore è utile ovunque tu voglia applicare un algoritmo\n" -"dati eterogenei. Se i dati sono omogenei, puoi utilizzare un modello simile " -"a un iteratore.\n" -"L'utilizzo di un oggetto visitatore (piuttosto che un approccio funzionale) " -"consente al visitatore di\n" +"dati eterogenei. Se i dati sono omogenei, puoi utilizzare un modello simile a un iteratore.\n" +"L'utilizzo di un oggetto visitatore (piuttosto che un approccio funzionale) consente al visitatore di\n" "essere stateful e quindi comunicare informazioni tra i nodi." #: src\patterns/behavioural/visitor.md:81 #, fuzzy msgid "" "It is common for the `visit_*` methods to return void (as opposed to in the\n" -"example). In that case it is possible to factor out the traversal code and " -"share\n" -"it between algorithms (and also to provide noop default methods). In Rust, " -"the\n" +"example). In that case it is possible to factor out the traversal code and share\n" +"it between algorithms (and also to provide noop default methods). In Rust, the\n" "common way to do this is to provide `walk_*` functions for each datum. For\n" "example," msgstr "" -"È comune che i metodi `visit_*` restituiscano void (al contrario di quanto " -"accade nel\n" -"esempio). In tal caso è possibile scomporre il codice di attraversamento e " -"condividerlo\n" -"it tra algoritmi (e anche per fornire metodi predefiniti noop). In Ruggine, " -"il\n" +"È comune che i metodi `visit_*` restituiscano void (al contrario di quanto accade nel\n" +"esempio). In tal caso è possibile scomporre il codice di attraversamento e condividerlo\n" +"it tra algoritmi (e anche per fornire metodi predefiniti noop). In Ruggine, il\n" "un modo comune per farlo è fornire funzioni `walk_*` per ogni dato. Per\n" "esempio," @@ -5378,20 +4589,16 @@ msgstr "" #: src\patterns/behavioural/visitor.md:103 #, fuzzy msgid "" -"In other languages (e.g., Java) it is common for data to have an `accept` " -"method\n" +"In other languages (e.g., Java) it is common for data to have an `accept` method\n" "which performs the same duty." msgstr "" -"In altri linguaggi (ad esempio, Java) è comune che i dati abbiano un metodo " -"`accept`\n" +"In altri linguaggi (ad esempio, Java) è comune che i dati abbiano un metodo `accept`\n" "che svolge lo stesso compito." #: src\patterns/behavioural/visitor.md:108 #, fuzzy msgid "The visitor pattern is a common pattern in most OO languages." -msgstr "" -"Il modello del visitatore è un modello comune nella maggior parte delle " -"lingue OO." +msgstr "Il modello del visitatore è un modello comune nella maggior parte delle lingue OO." #: src\patterns/behavioural/visitor.md:110 #, fuzzy @@ -5401,8 +4608,7 @@ msgstr "[Articolo di Wikipedia](https://en.wikipedia.org/wiki/Visitor_pattern)" #: src\patterns/behavioural/visitor.md:112 #, fuzzy msgid "" -"The [fold](../creational/fold.md) pattern is similar to visitor but " -"produces\n" +"The [fold](../creational/fold.md) pattern is similar to visitor but produces\n" "a new version of the visited data structure." msgstr "" "Il modello [fold](../creational/fold.md) è simile al visitatore ma produce\n" @@ -5421,22 +4627,15 @@ msgstr "Da [Wikipedia](https://en.wikipedia.org/wiki/Creational_pattern):" #: src\patterns/creational/intro.md:5 #, fuzzy msgid "" -"> Design patterns that deal with object creation mechanisms, trying to " -"create objects\n" -"> in a manner suitable to the situation. The basic form of object creation " -"could\n" -"> result in design problems or in added complexity to the design. Creational " -"design\n" +"> Design patterns that deal with object creation mechanisms, trying to create objects\n" +"> in a manner suitable to the situation. The basic form of object creation could\n" +"> result in design problems or in added complexity to the design. Creational design\n" "> patterns solve this problem by somehow controlling this object creation." msgstr "" -"> Design pattern che si occupano di meccanismi di creazione di oggetti, " -"cercando di creare oggetti\n" -"> in modo adeguato alla situazione. La forma base della creazione di oggetti " -"potrebbe\n" -"> comportare problemi di progettazione o una maggiore complessità del " -"progetto. Progettazione creazionale\n" -"> i modelli risolvono questo problema controllando in qualche modo la " -"creazione di questo oggetto." +"> Design pattern che si occupano di meccanismi di creazione di oggetti, cercando di creare oggetti\n" +"> in modo adeguato alla situazione. La forma base della creazione di oggetti potrebbe\n" +"> comportare problemi di progettazione o una maggiore complessità del progetto. Progettazione creazionale\n" +"> i modelli risolvono questo problema controllando in qualche modo la creazione di questo oggetto." #: src\patterns/creational/builder.md:1 #, fuzzy @@ -5479,19 +4678,16 @@ msgid "" " }\n" "\n" " pub fn name(mut self, bar: String) -> FooBuilder {\n" -" // Set the name on the builder itself, and return the builder by " -"value.\n" +" // Set the name on the builder itself, and return the builder by value.\n" " self.bar = bar;\n" " self\n" " }\n" "\n" " // If we can get away with not consuming the Builder here, that is an\n" -" // advantage. It means we can use the FooBuilder as a template for " -"constructing\n" +" // advantage. It means we can use the FooBuilder as a template for constructing\n" " // many Foos.\n" " pub fn build(self) -> Foo {\n" -" // Create a Foo from the FooBuilder, applying all settings in " -"FooBuilder\n" +" // Create a Foo from the FooBuilder, applying all settings in FooBuilder\n" " // to Foo.\n" " Foo { bar: self.bar }\n" " }\n" @@ -5502,8 +4698,7 @@ msgid "" " let foo = Foo {\n" " bar: String::from(\"Y\"),\n" " };\n" -" let foo_from_builder: Foo = " -"FooBuilder::new().name(String::from(\"Y\")).build();\n" +" let foo_from_builder: Foo = FooBuilder::new().name(String::from(\"Y\")).build();\n" " assert_eq!(foo, foo_from_builder);\n" "}\n" "```" @@ -5530,81 +4725,57 @@ msgstr "Previene la proliferazione di costruttori." #: src\patterns/creational/builder.md:74 #, fuzzy -msgid "" -"Can be used for one-liner initialisation as well as more complex " -"construction." -msgstr "" -"Può essere utilizzato per l'inizializzazione one-liner e per costruzioni più " -"complesse." +msgid "Can be used for one-liner initialisation as well as more complex construction." +msgstr "Può essere utilizzato per l'inizializzazione one-liner e per costruzioni più complesse." #: src\patterns/creational/builder.md:78 #, fuzzy msgid "" -"More complex than creating a struct object directly, or a simple " -"constructor\n" +"More complex than creating a struct object directly, or a simple constructor\n" "function." msgstr "" -"Più complesso della creazione diretta di un oggetto struct o di un semplice " -"costruttore\n" +"Più complesso della creazione diretta di un oggetto struct o di un semplice costruttore\n" "funzione." #: src\patterns/creational/builder.md:83 #, fuzzy msgid "" -"This pattern is seen more frequently in Rust (and for simpler objects) than " -"in\n" -"many other languages because Rust lacks overloading. Since you can only have " -"a\n" -"single method with a given name, having multiple constructors is less nice " -"in\n" +"This pattern is seen more frequently in Rust (and for simpler objects) than in\n" +"many other languages because Rust lacks overloading. Since you can only have a\n" +"single method with a given name, having multiple constructors is less nice in\n" "Rust than in C++, Java, or others." msgstr "" -"Questo modello è visto più frequentemente in Rust (e per oggetti più " -"semplici) che in\n" -"molte altre lingue perché Rust manca di sovraccarico. Dal momento che puoi " -"avere solo un file\n" -"singolo metodo con un determinato nome, avere più costruttori è meno " -"piacevole\n" +"Questo modello è visto più frequentemente in Rust (e per oggetti più semplici) che in\n" +"molte altre lingue perché Rust manca di sovraccarico. Dal momento che puoi avere solo un file\n" +"singolo metodo con un determinato nome, avere più costruttori è meno piacevole\n" "Rust che in C++, Java o altri." #: src\patterns/creational/builder.md:88 #, fuzzy msgid "" -"This pattern is often used where the builder object is useful in its own " -"right,\n" +"This pattern is often used where the builder object is useful in its own right,\n" "rather than being just a builder. For example, see\n" "[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" -"is a builder for " -"[`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" -"(a process). In these cases, the `T` and `TBuilder` naming pattern is not " -"used." +"is a builder for [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(a process). In these cases, the `T` and `TBuilder` naming pattern is not used." msgstr "" -"Questo modello viene spesso utilizzato quando l'oggetto builder è utile di " -"per sé,\n" +"Questo modello viene spesso utilizzato quando l'oggetto builder è utile di per sé,\n" "piuttosto che essere solo un costruttore. Ad esempio, vedi\n" "[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" -"è un builder per " -"[`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" -"(un processo). In questi casi, il modello di denominazione \"T\" e " -"\"TBuilder\" non viene utilizzato." +"è un builder per [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(un processo). In questi casi, il modello di denominazione \"T\" e \"TBuilder\" non viene utilizzato." #: src\patterns/creational/builder.md:94 #, fuzzy msgid "" -"The example takes and returns the builder by value. It is often more " -"ergonomic\n" -"(and more efficient) to take and return the builder as a mutable reference. " -"The\n" -"borrow checker makes this work naturally. This approach has the advantage " -"that\n" +"The example takes and returns the builder by value. It is often more ergonomic\n" +"(and more efficient) to take and return the builder as a mutable reference. The\n" +"borrow checker makes this work naturally. This approach has the advantage that\n" "one can write code like" msgstr "" -"L'esempio accetta e restituisce il builder per valore. Spesso è più " -"ergonomico\n" -"(e più efficiente) per prendere e restituire il builder come riferimento " -"mutabile. IL\n" -"prendere in prestito checker rende questo lavoro naturale. Questo approccio " -"ha il vantaggio che\n" +"L'esempio accetta e restituisce il builder per valore. Spesso è più ergonomico\n" +"(e più efficiente) per prendere e restituire il builder come riferimento mutabile. IL\n" +"prendere in prestito checker rende questo lavoro naturale. Questo approccio ha il vantaggio che\n" "si può scrivere codice come" #: src\patterns/creational/builder.md:99 @@ -5625,29 +4796,23 @@ msgstr "così come lo stile `FooBuilder::new().a().b().build()`." #: src\patterns/creational/builder.md:110 #, fuzzy msgid "" -"- [Description in the style " -"guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" -"- [derive_builder](https://crates.io/crates/derive_builder), a crate for " -"automatically\n" +"- [Description in the style guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/" +"builders.html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), a crate for automatically\n" " implementing this pattern while avoiding the boilerplate.\n" -"- [Constructor pattern](../../idioms/ctor.md) for when construction is " -"simpler.\n" -"- [Builder pattern " -"(wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" -"- [Construction of complex " -"values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder)" -msgstr "" -"- [Descrizione nella guida di " -"stile](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" -"- [derive_builder](https://crates.io/crates/derive_builder), una cassa per " -"automaticamente\n" +"- [Constructor pattern](../../idioms/ctor.md) for when construction is simpler.\n" +"- [Builder pattern (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Construction of complex values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety." +"html#c-builder)" +msgstr "" +"- [Descrizione nella guida di stile](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/" +"builders.html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), una cassa per automaticamente\n" " implementare questo modello evitando il boilerplate.\n" -"- [Modello costruttore](../../idioms/ctor.md) per quando la costruzione è " -"più semplice.\n" -"- [Modello builder " -"(wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" -"- [Costruzione di valori " -"complessi](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder)" +"- [Modello costruttore](../../idioms/ctor.md) per quando la costruzione è più semplice.\n" +"- [Modello builder (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Costruzione di valori complessi](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety." +"html#c-builder)" #: src\patterns/creational/fold.md:1 #, fuzzy @@ -5657,27 +4822,22 @@ msgstr "# Piega" #: src\patterns/creational/fold.md:5 #, fuzzy msgid "" -"Run an algorithm over each item in a collection of data to create a new " -"item,\n" +"Run an algorithm over each item in a collection of data to create a new item,\n" "thus creating a whole new collection." msgstr "" -"Esegui un algoritmo su ogni elemento in una raccolta di dati per creare un " -"nuovo elemento,\n" +"Esegui un algoritmo su ogni elemento in una raccolta di dati per creare un nuovo elemento,\n" "creando così una collezione completamente nuova." #: src\patterns/creational/fold.md:8 #, fuzzy msgid "" "The etymology here is unclear to me. The terms 'fold' and 'folder' are used\n" -"in the Rust compiler, although it appears to me to be more like a map than " -"a\n" +"in the Rust compiler, although it appears to me to be more like a map than a\n" "fold in the usual sense. See the discussion below for more details." msgstr "" -"L'etimologia qui non mi è chiara. Vengono utilizzati i termini \"piega\" e " -"\"cartella\".\n" +"L'etimologia qui non mi è chiara. Vengono utilizzati i termini \"piega\" e \"cartella\".\n" "nel compilatore Rust, anche se mi sembra più simile a una mappa che a\n" -"piegare nel senso comune. Vedere la discussione di seguito per maggiori " -"dettagli." +"piegare nel senso comune. Vedere la discussione di seguito per maggiori dettagli." #: src\patterns/creational/fold.md:14 msgid "" @@ -5705,16 +4865,14 @@ msgid "" " use ast::*;\n" "\n" " pub trait Folder {\n" -" // A leaf node just returns the node itself. In some cases, we can " -"do this\n" +" // A leaf node just returns the node itself. In some cases, we can do this\n" " // to inner nodes too.\n" " fn fold_name(&mut self, n: Box) -> Box { n }\n" " // Create a new inner node by folding its children.\n" " fn fold_stmt(&mut self, s: Box) -> Box {\n" " match *s {\n" " Stmt::Expr(e) => Box::new(Stmt::Expr(self.fold_expr(e))),\n" -" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), " -"self.fold_expr(e))),\n" +" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), self.fold_expr(e))),\n" " }\n" " }\n" " fn fold_expr(&mut self, e: Box) -> Box { ... }\n" @@ -5738,120 +4896,89 @@ msgstr "" #: src\patterns/creational/fold.md:65 #, fuzzy msgid "" -"The result of running the `Renamer` on an AST is a new AST identical to the " -"old\n" -"one, but with every name changed to `foo`. A real life folder might have " -"some\n" +"The result of running the `Renamer` on an AST is a new AST identical to the old\n" +"one, but with every name changed to `foo`. A real life folder might have some\n" "state preserved between nodes in the struct itself." msgstr "" -"Il risultato dell'esecuzione di `Renamer` su un AST è un nuovo AST identico " -"al vecchio\n" -"uno, ma con ogni nome cambiato in `foo`. Una cartella della vita reale " -"potrebbe averne alcuni\n" +"Il risultato dell'esecuzione di `Renamer` su un AST è un nuovo AST identico al vecchio\n" +"uno, ma con ogni nome cambiato in `foo`. Una cartella della vita reale potrebbe averne alcuni\n" "stato preservato tra i nodi nella struttura stessa." #: src\patterns/creational/fold.md:69 #, fuzzy msgid "" "A folder can also be defined to map one data structure to a different (but\n" -"usually similar) data structure. For example, we could fold an AST into a " -"HIR\n" +"usually similar) data structure. For example, we could fold an AST into a HIR\n" "tree (HIR stands for high-level intermediate representation)." msgstr "" -"È inoltre possibile definire una cartella per mappare una struttura di dati " -"a un'altra (but\n" -"di solito simile) struttura dei dati. Ad esempio, potremmo piegare un AST in " -"un HIR\n" +"È inoltre possibile definire una cartella per mappare una struttura di dati a un'altra (but\n" +"di solito simile) struttura dei dati. Ad esempio, potremmo piegare un AST in un HIR\n" "albero (HIR sta per rappresentazione intermedia di alto livello)." #: src\patterns/creational/fold.md:75 #, fuzzy msgid "" -"It is common to want to map a data structure by performing some operation " -"on\n" -"each node in the structure. For simple operations on simple data " -"structures,\n" -"this can be done using `Iterator::map`. For more complex operations, " -"perhaps\n" -"where earlier nodes can affect the operation on later nodes, or where " -"iteration\n" +"It is common to want to map a data structure by performing some operation on\n" +"each node in the structure. For simple operations on simple data structures,\n" +"this can be done using `Iterator::map`. For more complex operations, perhaps\n" +"where earlier nodes can affect the operation on later nodes, or where iteration\n" "over the data structure is non-trivial, using the fold pattern is more\n" "appropriate." msgstr "" "È comune voler mappare una struttura dati eseguendo alcune operazioni su\n" -"ciascun nodo della struttura. Per operazioni semplici su strutture dati " -"semplici,\n" -"questo può essere fatto usando `Iterator::map`. Per operazioni più " -"complesse, forse\n" -"dove i nodi precedenti possono influenzare l'operazione sui nodi successivi " -"o dove l'iterazione\n" -"sopra la struttura dei dati non è banale, l'utilizzo del modello di " -"piegatura lo è di più\n" +"ciascun nodo della struttura. Per operazioni semplici su strutture dati semplici,\n" +"questo può essere fatto usando `Iterator::map`. Per operazioni più complesse, forse\n" +"dove i nodi precedenti possono influenzare l'operazione sui nodi successivi o dove l'iterazione\n" +"sopra la struttura dei dati non è banale, l'utilizzo del modello di piegatura lo è di più\n" "adeguata." #: src\patterns/creational/fold.md:82 #, fuzzy msgid "" -"Like the visitor pattern, the fold pattern allows us to separate traversal " -"of a\n" +"Like the visitor pattern, the fold pattern allows us to separate traversal of a\n" "data structure from the operations performed to each node." msgstr "" -"Come il modello del visitatore, il modello di piegatura ci consente di " -"separare l'attraversamento di a\n" +"Come il modello del visitatore, il modello di piegatura ci consente di separare l'attraversamento di a\n" "struttura dati dalle operazioni eseguite su ciascun nodo." #: src\patterns/creational/fold.md:87 #, fuzzy msgid "" -"Mapping data structures in this fashion is common in functional languages. " -"In OO\n" -"languages, it would be more common to mutate the data structure in place. " -"The\n" +"Mapping data structures in this fashion is common in functional languages. In OO\n" +"languages, it would be more common to mutate the data structure in place. The\n" "'functional' approach is common in Rust, mostly due to the preference for\n" -"immutability. Using fresh data structures, rather than mutating old ones, " -"makes\n" +"immutability. Using fresh data structures, rather than mutating old ones, makes\n" "reasoning about the code easier in most circumstances." msgstr "" -"La mappatura delle strutture dati in questo modo è comune nei linguaggi " -"funzionali. Nell'OO\n" +"La mappatura delle strutture dati in questo modo è comune nei linguaggi funzionali. Nell'OO\n" "lingue, sarebbe più comune mutare la struttura dei dati sul posto. IL\n" -"L'approccio \"funzionale\" è comune in Rust, principalmente a causa della " -"preferenza per\n" -"immutabilità. L'utilizzo di nuove strutture di dati, piuttosto che la " -"mutazione di quelle vecchie, rende\n" +"L'approccio \"funzionale\" è comune in Rust, principalmente a causa della preferenza per\n" +"immutabilità. L'utilizzo di nuove strutture di dati, piuttosto che la mutazione di quelle vecchie, rende\n" "ragionamento sul codice più facile nella maggior parte dei casi." #: src\patterns/creational/fold.md:93 #, fuzzy msgid "" -"The trade-off between efficiency and reusability can be tweaked by changing " -"how\n" +"The trade-off between efficiency and reusability can be tweaked by changing how\n" "nodes are accepted by the `fold_*` methods." msgstr "" -"Il compromesso tra efficienza e riusabilità può essere modificato " -"modificando il modo\n" +"Il compromesso tra efficienza e riusabilità può essere modificato modificando il modo\n" "i nodi sono accettati dai metodi `fold_*`." #: src\patterns/creational/fold.md:96 #, fuzzy msgid "" -"In the above example we operate on `Box` pointers. Since these own their " -"data\n" -"exclusively, the original copy of the data structure cannot be re-used. On " -"the\n" +"In the above example we operate on `Box` pointers. Since these own their data\n" +"exclusively, the original copy of the data structure cannot be re-used. On the\n" "other hand if a node is not changed, reusing it is very efficient." msgstr "" -"Nell'esempio sopra operiamo sui puntatori `Box`. Dal momento che questi " -"possiedono i loro dati\n" -"esclusivamente, la copia originale della struttura dati non può essere " -"riutilizzata. Sul\n" -"d'altra parte se un nodo non viene modificato, riutilizzarlo è molto " -"efficiente." +"Nell'esempio sopra operiamo sui puntatori `Box`. Dal momento che questi possiedono i loro dati\n" +"esclusivamente, la copia originale della struttura dati non può essere riutilizzata. Sul\n" +"d'altra parte se un nodo non viene modificato, riutilizzarlo è molto efficiente." #: src\patterns/creational/fold.md:100 msgid "" -"If we were to operate on borrowed references, the original data structure " -"can be\n" +"If we were to operate on borrowed references, the original data structure can be\n" "reused; however, a node must be cloned even if unchanged, which can be\n" "expensive." msgstr "" @@ -5859,66 +4986,49 @@ msgstr "" #: src\patterns/creational/fold.md:104 #, fuzzy msgid "" -"Using a reference counted pointer gives the best of both worlds - we can " -"reuse\n" -"the original data structure, and we don't need to clone unchanged nodes. " -"However,\n" +"Using a reference counted pointer gives the best of both worlds - we can reuse\n" +"the original data structure, and we don't need to clone unchanged nodes. However,\n" "they are less ergonomic to use and mean that the data structures cannot be\n" "mutable." msgstr "" -"L'uso di un puntatore contato di riferimento offre il meglio di entrambi i " -"mondi: possiamo riutilizzarlo\n" -"la struttura dati originale e non è necessario clonare nodi non modificati. " -"Tuttavia,\n" -"sono meno ergonomici da usare e significano che le strutture dati non " -"possono esserlo\n" +"L'uso di un puntatore contato di riferimento offre il meglio di entrambi i mondi: possiamo riutilizzarlo\n" +"la struttura dati originale e non è necessario clonare nodi non modificati. Tuttavia,\n" +"sono meno ergonomici da usare e significano che le strutture dati non possono esserlo\n" "mutevole." #: src\patterns/creational/fold.md:111 #, fuzzy msgid "" "Iterators have a `fold` method, however this folds a data structure into a\n" -"value, rather than into a new data structure. An iterator's `map` is more " -"like\n" +"value, rather than into a new data structure. An iterator's `map` is more like\n" "this fold pattern." msgstr "" -"Gli iteratori hanno un metodo `fold`, tuttavia questo ripiega una struttura " -"di dati in a\n" -"valore, piuttosto che in una nuova struttura di dati. La \"mappa\" di un " -"iteratore è più simile\n" +"Gli iteratori hanno un metodo `fold`, tuttavia questo ripiega una struttura di dati in a\n" +"valore, piuttosto che in una nuova struttura di dati. La \"mappa\" di un iteratore è più simile\n" "questo schema di piegatura." #: src\patterns/creational/fold.md:115 #, fuzzy msgid "" "In other languages, fold is usually used in the sense of Rust's iterators,\n" -"rather than this pattern. Some functional languages have powerful constructs " -"for\n" +"rather than this pattern. Some functional languages have powerful constructs for\n" "performing flexible maps over data structures." msgstr "" -"In altre lingue, fold è solitamente usato nel senso degli iteratori di " -"Rust,\n" -"piuttosto che questo modello. Alcuni linguaggi funzionali hanno potenti " -"costrutti per\n" +"In altre lingue, fold è solitamente usato nel senso degli iteratori di Rust,\n" +"piuttosto che questo modello. Alcuni linguaggi funzionali hanno potenti costrutti per\n" "eseguire mappe flessibili su strutture dati." #: src\patterns/creational/fold.md:119 #, fuzzy msgid "" -"The [visitor](../behavioural/visitor.md) pattern is closely related to " -"fold.\n" -"They share the concept of walking a data structure performing an operation " -"on\n" -"each node. However, the visitor does not create a new data structure nor " -"consume\n" +"The [visitor](../behavioural/visitor.md) pattern is closely related to fold.\n" +"They share the concept of walking a data structure performing an operation on\n" +"each node. However, the visitor does not create a new data structure nor consume\n" "the old one." msgstr "" -"Il pattern [visitor](../behavioural/visitor.md) è strettamente correlato a " -"fold.\n" -"Condividono il concetto di percorrere una struttura dati su cui eseguire " -"un'operazione\n" -"ciascun nodo. Tuttavia, il visitatore non crea una nuova struttura di dati " -"né consuma\n" +"Il pattern [visitor](../behavioural/visitor.md) è strettamente correlato a fold.\n" +"Condividono il concetto di percorrere una struttura dati su cui eseguire un'operazione\n" +"ciascun nodo. Tuttavia, il visitatore non crea una nuova struttura di dati né consuma\n" "quello vecchio." #: src\patterns/structural/intro.md:1 @@ -5934,12 +5044,10 @@ msgstr "Da [Wikipedia](https://en.wikipedia.org/wiki/Structural_pattern):" #: src\patterns/structural/intro.md:5 #, fuzzy msgid "" -"> Design patterns that ease the design by identifying a simple way to " -"realize relationships\n" +"> Design patterns that ease the design by identifying a simple way to realize relationships\n" "> among entities." msgstr "" -"> Design pattern che facilitano la progettazione individuando un modo " -"semplice per realizzare relazioni\n" +"> Design pattern che facilitano la progettazione individuando un modo semplice per realizzare relazioni\n" "> tra enti." #: src\patterns/structural/compose-structs.md:1 @@ -5955,25 +5063,18 @@ msgstr "TODO - questo non è un nome molto accattivante" #: src\patterns/structural/compose-structs.md:7 #, fuzzy msgid "" -"Sometimes a large struct will cause issues with the borrow checker - " -"although\n" -"fields can be borrowed independently, sometimes the whole struct ends up " -"being\n" -"used at once, preventing other uses. A solution might be to decompose the " -"struct\n" +"Sometimes a large struct will cause issues with the borrow checker - although\n" +"fields can be borrowed independently, sometimes the whole struct ends up being\n" +"used at once, preventing other uses. A solution might be to decompose the struct\n" "into several smaller structs. Then compose these together into the original\n" "struct. Then each struct can be borrowed separately and have more flexible\n" "behaviour." msgstr "" -"A volte una struttura di grandi dimensioni causerà problemi con il controllo " -"del prestito, anche se\n" -"i campi possono essere presi in prestito indipendentemente, a volte l'intera " -"struttura finisce per esserlo\n" -"utilizzato in una sola volta, impedendo altri usi. Una soluzione potrebbe " -"essere quella di scomporre la struct\n" +"A volte una struttura di grandi dimensioni causerà problemi con il controllo del prestito, anche se\n" +"i campi possono essere presi in prestito indipendentemente, a volte l'intera struttura finisce per esserlo\n" +"utilizzato in una sola volta, impedendo altri usi. Una soluzione potrebbe essere quella di scomporre la struct\n" "in diverse strutture più piccole. Quindi componili insieme nell'originale\n" -"struct. Quindi ogni struttura può essere presa in prestito separatamente e " -"avere una maggiore flessibilità\n" +"struct. Quindi ogni struttura può essere presa in prestito separatamente e avere una maggiore flessibilità\n" "comportamento." #: src\patterns/structural/compose-structs.md:14 @@ -5982,19 +5083,16 @@ msgid "" "This will often lead to a better design in other ways: applying this design\n" "pattern often reveals smaller units of functionality." msgstr "" -"Questo spesso porterà a un design migliore in altri modi: applicando questo " -"design\n" +"Questo spesso porterà a un design migliore in altri modi: applicando questo design\n" "pattern rivela spesso unità di funzionalità più piccole." #: src\patterns/structural/compose-structs.md:19 #, fuzzy msgid "" -"Here is a contrived example of where the borrow checker foils us in our plan " -"to\n" +"Here is a contrived example of where the borrow checker foils us in our plan to\n" "use a struct:" msgstr "" -"Ecco un esempio artificioso di dove il controllore del prestito ci sventa " -"nel nostro piano\n" +"Ecco un esempio artificioso di dove il controllore del prestito ci sventa nel nostro piano\n" "usa una struttura:" #: src\patterns/structural/compose-structs.md:22 @@ -6010,12 +5108,10 @@ msgid "" "fn bar(a: &mut A) -> u32 { a.f1 + a.f3 }\n" "\n" "fn baz(a: &mut A) {\n" -" // The later usage of x causes a to be borrowed for the rest of the " -"function.\n" +" // The later usage of x causes a to be borrowed for the rest of the function.\n" " let x = foo(a);\n" " // Borrow checker error:\n" -" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than " -"once\n" +" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than once\n" " // at a time\n" " println!(\"{}\", x);\n" "}\n" @@ -6025,12 +5121,10 @@ msgstr "" #: src\patterns/structural/compose-structs.md:42 #, fuzzy msgid "" -"We can apply this design pattern and refactor `A` into two smaller structs, " -"thus\n" +"We can apply this design pattern and refactor `A` into two smaller structs, thus\n" "solving the borrow checking issue:" msgstr "" -"Possiamo quindi applicare questo modello di progettazione e rifattorizzare " -"\"A\" in due strutture più piccole\n" +"Possiamo quindi applicare questo modello di progettazione e rifattorizzare \"A\" in due strutture più piccole\n" "risolvere il problema del controllo del prestito:" #: src\patterns/structural/compose-structs.md:45 @@ -6085,52 +5179,38 @@ msgstr "Porta a un codice più dettagliato." #: src\patterns/structural/compose-structs.md:85 #, fuzzy msgid "" -"Sometimes, the smaller structs are not good abstractions, and so we end up " -"with\n" -"a worse design. That is probably a 'code smell', indicating that the " -"program\n" +"Sometimes, the smaller structs are not good abstractions, and so we end up with\n" +"a worse design. That is probably a 'code smell', indicating that the program\n" "should be refactored in some way." msgstr "" -"A volte, le strutture più piccole non sono buone astrazioni, e quindi ci " -"ritroviamo\n" -"un design peggiore. Questo è probabilmente un \"odore di codice\", che " -"indica che il programma\n" +"A volte, le strutture più piccole non sono buone astrazioni, e quindi ci ritroviamo\n" +"un design peggiore. Questo è probabilmente un \"odore di codice\", che indica che il programma\n" "dovrebbe essere rifattorizzato in qualche modo." #: src\patterns/structural/compose-structs.md:91 #, fuzzy msgid "" -"This pattern is not required in languages that don't have a borrow checker, " -"so\n" -"in that sense is unique to Rust. However, making smaller units of " -"functionality\n" +"This pattern is not required in languages that don't have a borrow checker, so\n" +"in that sense is unique to Rust. However, making smaller units of functionality\n" "often leads to cleaner code: a widely acknowledged principle of software\n" "engineering, independent of the language." msgstr "" -"Questo modello non è richiesto nelle lingue che non hanno un controllo del " -"prestito, quindi\n" -"in questo senso è unico per Rust. Tuttavia, creando unità di funzionalità " -"più piccole\n" -"spesso porta a un codice più pulito: un principio del software ampiamente " -"riconosciuto\n" +"Questo modello non è richiesto nelle lingue che non hanno un controllo del prestito, quindi\n" +"in questo senso è unico per Rust. Tuttavia, creando unità di funzionalità più piccole\n" +"spesso porta a un codice più pulito: un principio del software ampiamente riconosciuto\n" "ingegneria, indipendente dalla lingua." #: src\patterns/structural/compose-structs.md:96 #, fuzzy msgid "" "This pattern relies on Rust's borrow checker to be able to borrow fields\n" -"independently of each other. In the example, the borrow checker knows that " -"`a.b`\n" -"and `a.c` are distinct and can be borrowed independently, it does not try " -"to\n" +"independently of each other. In the example, the borrow checker knows that `a.b`\n" +"and `a.c` are distinct and can be borrowed independently, it does not try to\n" "borrow all of `a`, which would make this pattern useless." msgstr "" -"Questo modello si basa sul controllo del prestito di Rust per poter prendere " -"in prestito i campi\n" -"indipendentemente l'uno dall'altro. Nell'esempio, il controllo del prestito " -"sa che `a.b`\n" -"e \"a.c\" sono distinti e possono essere presi in prestito " -"indipendentemente, non cerca di farlo\n" +"Questo modello si basa sul controllo del prestito di Rust per poter prendere in prestito i campi\n" +"indipendentemente l'uno dall'altro. Nell'esempio, il controllo del prestito sa che `a.b`\n" +"e \"a.c\" sono distinti e possono essere presi in prestito indipendentemente, non cerca di farlo\n" "prendi in prestito tutta la `a`, il che renderebbe questo modello inutile." #: src\patterns/structural/small-crates.md:1 @@ -6146,114 +5226,83 @@ msgstr "Preferisci piccole casse che fanno bene una cosa." #: src\patterns/structural/small-crates.md:7 #, fuzzy msgid "" -"Cargo and crates.io make it easy to add third-party libraries, much more so " -"than\n" -"in say C or C++. Moreover, since packages on crates.io cannot be edited or " -"removed\n" -"after publication, any build that works now should continue to work in the " -"future.\n" -"We should take advantage of this tooling, and use smaller, more fine-grained " -"dependencies." -msgstr "" -"Cargo e crates.io semplificano l'aggiunta di librerie di terze parti, molto " -"più di\n" -"diciamo in C o C++. Inoltre, poiché i pacchetti su crates.io non possono " -"essere modificati o rimossi\n" -"dopo la pubblicazione, qualsiasi build che funziona ora dovrebbe continuare " -"a funzionare in futuro.\n" -"Dovremmo trarre vantaggio da questi strumenti e utilizzare dipendenze più " -"piccole e più granulari." +"Cargo and crates.io make it easy to add third-party libraries, much more so than\n" +"in say C or C++. Moreover, since packages on crates.io cannot be edited or removed\n" +"after publication, any build that works now should continue to work in the future.\n" +"We should take advantage of this tooling, and use smaller, more fine-grained dependencies." +msgstr "" +"Cargo e crates.io semplificano l'aggiunta di librerie di terze parti, molto più di\n" +"diciamo in C o C++. Inoltre, poiché i pacchetti su crates.io non possono essere modificati o rimossi\n" +"dopo la pubblicazione, qualsiasi build che funziona ora dovrebbe continuare a funzionare in futuro.\n" +"Dovremmo trarre vantaggio da questi strumenti e utilizzare dipendenze più piccole e più granulari." #: src\patterns/structural/small-crates.md:14 #, fuzzy msgid "" "- Small crates are easier to understand, and encourage more modular code.\n" "- Crates allow for re-using code between projects.\n" -" For example, the `url` crate was developed as part of the Servo browser " -"engine,\n" +" For example, the `url` crate was developed as part of the Servo browser engine,\n" " but has since found wide use outside the project.\n" "- Since the compilation unit\n" -" of Rust is the crate, splitting a project into multiple crates can allow " -"more of\n" +" of Rust is the crate, splitting a project into multiple crates can allow more of\n" " the code to be built in parallel." msgstr "" -"- Le casse piccole sono più facili da capire e incoraggiano un codice più " -"modulare.\n" +"- Le casse piccole sono più facili da capire e incoraggiano un codice più modulare.\n" "- Le casse consentono di riutilizzare il codice tra i progetti.\n" -" Ad esempio, la cassa `url` è stata sviluppata come parte del motore del " -"browser Servo,\n" +" Ad esempio, la cassa `url` è stata sviluppata come parte del motore del browser Servo,\n" " ma da allora ha trovato ampio utilizzo al di fuori del progetto.\n" "- Dal momento che l'unità di compilazione\n" -" of Rust è la cassa, la suddivisione di un progetto in più casse può " -"consentirne di più\n" +" of Rust è la cassa, la suddivisione di un progetto in più casse può consentirne di più\n" " il codice da costruire in parallelo." #: src\patterns/structural/small-crates.md:24 #, fuzzy msgid "" -"- This can lead to \"dependency hell\", when a project depends on multiple " -"conflicting\n" -" versions of a crate at the same time. For example, the `url` crate has " -"both versions\n" -" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` " -"are\n" -" different types, an HTTP client that uses `url:0.5` would not accept `Url` " -"values\n" +"- This can lead to \"dependency hell\", when a project depends on multiple conflicting\n" +" versions of a crate at the same time. For example, the `url` crate has both versions\n" +" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` are\n" +" different types, an HTTP client that uses `url:0.5` would not accept `Url` values\n" " from a web scraper that uses `url:1.0`.\n" -"- Packages on crates.io are not curated. A crate may be poorly written, " -"have\n" +"- Packages on crates.io are not curated. A crate may be poorly written, have\n" " unhelpful documentation, or be outright malicious.\n" -"- Two small crates may be less optimized than one large one, since the " -"compiler\n" +"- Two small crates may be less optimized than one large one, since the compiler\n" " does not perform link-time optimization (LTO) by default." msgstr "" -"- Questo può portare a \"l'inferno della dipendenza\", quando un progetto " -"dipende da più conflitti\n" -" versioni di una cassa allo stesso tempo. Ad esempio, la cassa `url` ha " -"entrambe le versioni\n" +"- Questo può portare a \"l'inferno della dipendenza\", quando un progetto dipende da più conflitti\n" +" versioni di una cassa allo stesso tempo. Ad esempio, la cassa `url` ha entrambe le versioni\n" " 1.0 e 0.5. Poiché \"Url\" da \"url:1.0\" e \"Url\" da \"url:0.5\" sono\n" -" tipi diversi, un client HTTP che utilizza `url:0.5` non accetterebbe i " -"valori `Url`\n" +" tipi diversi, un client HTTP che utilizza `url:0.5` non accetterebbe i valori `Url`\n" " da un web scraper che utilizza `url:1.0`.\n" -"- I pacchetti su crates.io non sono curati. Una cassa può essere scritta " -"male, avere\n" +"- I pacchetti su crates.io non sono curati. Una cassa può essere scritta male, avere\n" " documentazione inutile o essere apertamente malizioso.\n" -"- Due piccole casse possono essere meno ottimizzate di una grande, poiché il " -"compilatore\n" -" non esegue l'ottimizzazione del tempo di collegamento (LTO) per " -"impostazione predefinita." +"- Due piccole casse possono essere meno ottimizzate di una grande, poiché il compilatore\n" +" non esegue l'ottimizzazione del tempo di collegamento (LTO) per impostazione predefinita." #: src\patterns/structural/small-crates.md:36 #, fuzzy msgid "" -"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides " -"functions\n" +"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" "for converting `&T` to `&[T]`." msgstr "" -"Il crate [`ref_slice`](https://crates.io/crates/ref_slice) fornisce " -"funzioni\n" +"Il crate [`ref_slice`](https://crates.io/crates/ref_slice) fornisce funzioni\n" "per convertire \"&T\" in \"&[T]\"." #: src\patterns/structural/small-crates.md:39 #, fuzzy msgid "" -"The [`url`](https://crates.io/crates/url) crate provides tools for working " -"with\n" +"The [`url`](https://crates.io/crates/url) crate provides tools for working with\n" "URLs." msgstr "" -"Il crate [`url`](https://crates.io/crates/url) fornisce gli strumenti per " -"lavorare con\n" +"Il crate [`url`](https://crates.io/crates/url) fornisce gli strumenti per lavorare con\n" "URL." #: src\patterns/structural/small-crates.md:42 #, fuzzy msgid "" -"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a " -"function to\n" +"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a function to\n" "query the number of CPUs on a machine." msgstr "" -"Il crate [`num_cpus`](https://crates.io/crates/num_cpus) fornisce una " -"funzione per\n" +"Il crate [`num_cpus`](https://crates.io/crates/num_cpus) fornisce una funzione per\n" "interrogare il numero di CPU su una macchina." #: src\patterns/structural/small-crates.md:47 @@ -6269,39 +5318,27 @@ msgstr "# Contenere la sicurezza in piccoli moduli" #: src\patterns/structural/unsafe-mods.md:5 #, fuzzy msgid "" -"If you have `unsafe` code, create the smallest possible module that can " -"uphold\n" -"the needed invariants to build a minimal safe interface upon the unsafety. " -"Embed\n" -"this into a larger module that contains only safe code and presents an " -"ergonomic\n" -"interface. Note that the outer module can contain unsafe functions and " -"methods\n" -"that call directly into the unsafe code. Users may use this to gain speed " -"benefits." -msgstr "" -"Se hai un codice \"non sicuro\", crea il modulo più piccolo possibile che " -"possa sostenere\n" -"gli invarianti necessari per costruire un'interfaccia sicura minima " -"sull'insicurezza. Incorporare\n" -"questo in un modulo più grande che contiene solo codice sicuro e presenta " -"un'ergonomia\n" -"interfaccia. Si noti che il modulo esterno può contenere funzioni e metodi " -"non sicuri\n" -"che chiamano direttamente nel codice non sicuro. Gli utenti possono " -"utilizzarlo per ottenere vantaggi in termini di velocità." +"If you have `unsafe` code, create the smallest possible module that can uphold\n" +"the needed invariants to build a minimal safe interface upon the unsafety. Embed\n" +"this into a larger module that contains only safe code and presents an ergonomic\n" +"interface. Note that the outer module can contain unsafe functions and methods\n" +"that call directly into the unsafe code. Users may use this to gain speed benefits." +msgstr "" +"Se hai un codice \"non sicuro\", crea il modulo più piccolo possibile che possa sostenere\n" +"gli invarianti necessari per costruire un'interfaccia sicura minima sull'insicurezza. Incorporare\n" +"questo in un modulo più grande che contiene solo codice sicuro e presenta un'ergonomia\n" +"interfaccia. Si noti che il modulo esterno può contenere funzioni e metodi non sicuri\n" +"che chiamano direttamente nel codice non sicuro. Gli utenti possono utilizzarlo per ottenere vantaggi in termini di velocità." #: src\patterns/structural/unsafe-mods.md:13 #, fuzzy msgid "" "- This restricts the unsafe code that must be audited\n" -"- Writing the outer module is much easier, since you can count on the " -"guarantees\n" +"- Writing the outer module is much easier, since you can count on the guarantees\n" " of the inner module" msgstr "" "- Questo limita il codice non sicuro che deve essere controllato\n" -"- Scrivere il modulo esterno è molto più semplice, dato che puoi contare " -"sulle garanzie\n" +"- Scrivere il modulo esterno è molto più semplice, dato che puoi contare sulle garanzie\n" " del modulo interno" #: src\patterns/structural/unsafe-mods.md:19 @@ -6316,39 +5353,26 @@ msgstr "" #: src\patterns/structural/unsafe-mods.md:24 #, fuzzy msgid "" -"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe " -"operations\n" +"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe operations\n" " in submodules, presenting a safe interface to users.\n" -"- `std`'s `String` class is a wrapper over `Vec` with the added " -"invariant\n" -" that the contents must be valid UTF-8. The operations on `String` ensure " -"this\n" +"- `std`'s `String` class is a wrapper over `Vec` with the added invariant\n" +" that the contents must be valid UTF-8. The operations on `String` ensure this\n" " behavior.\n" -" However, users have the option of using an `unsafe` method to create a " -"`String`,\n" -" in which case the onus is on them to guarantee the validity of the " -"contents." +" However, users have the option of using an `unsafe` method to create a `String`,\n" +" in which case the onus is on them to guarantee the validity of the contents." msgstr "" -"- Il crate [`toolshed`](https://docs.rs/toolshed) contiene le sue operazioni " -"non sicure\n" +"- Il crate [`toolshed`](https://docs.rs/toolshed) contiene le sue operazioni non sicure\n" " nei sottomoduli, presentando un'interfaccia sicura per gli utenti.\n" -"- La classe `String` di `std` è un wrapper su `Vec` con l'aggiunta " -"dell'invariante\n" -" che i contenuti devono essere UTF-8 validi. Le operazioni su \"Stringa\" " -"assicurano questo\n" +"- La classe `String` di `std` è un wrapper su `Vec` con l'aggiunta dell'invariante\n" +" che i contenuti devono essere UTF-8 validi. Le operazioni su \"Stringa\" assicurano questo\n" " comportamento.\n" -" Tuttavia, gli utenti hanno la possibilità di utilizzare un metodo \"non " -"sicuro\" per creare una \"Stringa\",\n" +" Tuttavia, gli utenti hanno la possibilità di utilizzare un metodo \"non sicuro\" per creare una \"Stringa\",\n" " in tal caso spetta a loro l'onere di garantire la validità dei contenuti." #: src\patterns/structural/unsafe-mods.md:34 #, fuzzy -msgid "" -"- [Ralf Jung's Blog about invariants in unsafe " -"code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" -msgstr "" -"- [Blog di Ralf Jung sulle invarianti nel codice non " -"sicuro](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgid "- [Ralf Jung's Blog about invariants in unsafe code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgstr "- [Blog di Ralf Jung sulle invarianti nel codice non sicuro](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" #: src\patterns/ffi/intro.md:1 #, fuzzy @@ -6359,39 +5383,31 @@ msgstr "# Modelli FFI" #, fuzzy msgid "" "Writing FFI code is an entire course in itself.\n" -"However, there are several idioms here that can act as pointers, and avoid " -"traps\n" +"However, there are several idioms here that can act as pointers, and avoid traps\n" "for inexperienced users of unsafe Rust." msgstr "" "Scrivere il codice FFI è un intero corso in sé.\n" -"Tuttavia, ci sono diversi idiomi qui che possono fungere da puntatori ed " -"evitare trappole\n" +"Tuttavia, ci sono diversi idiomi qui che possono fungere da puntatori ed evitare trappole\n" "per utenti inesperti di Rust non sicuro." #: src\patterns/ffi/intro.md:7 #, fuzzy msgid "This section contains design patterns that may be useful when doing FFI." -msgstr "" -"Questa sezione contiene modelli di progettazione che possono essere utili " -"durante l'esecuzione di FFI." +msgstr "Questa sezione contiene modelli di progettazione che possono essere utili durante l'esecuzione di FFI." #: src\patterns/ffi/intro.md:9 #, fuzzy msgid "" -"1. [Object-Based API](./export.md) design that has good memory safety " -"characteristics,\n" +"1. [Object-Based API](./export.md) design that has good memory safety characteristics,\n" " and a clean boundary of what is safe and what is unsafe\n" "\n" -"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust " -"types\n" +"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust types\n" " together into an opaque \"object\"" msgstr "" -"1. [API basata su oggetti](./export.md) design con buone caratteristiche di " -"sicurezza della memoria,\n" +"1. [API basata su oggetti](./export.md) design con buone caratteristiche di sicurezza della memoria,\n" " e un confine netto di ciò che è sicuro e ciò che non lo è\n" "\n" -"2. [Type Consolidation into Wrappers](./wrappers.md) - raggruppa più tipi di " -"Rust\n" +"2. [Type Consolidation into Wrappers](./wrappers.md) - raggruppa più tipi di Rust\n" " insieme in un \"oggetto\" opaco" #: src\patterns/ffi/export.md:1 @@ -6402,148 +5418,113 @@ msgstr "# API basate su oggetti" #: src\patterns/ffi/export.md:5 #, fuzzy msgid "" -"When designing APIs in Rust which are exposed to other languages, there are " -"some\n" +"When designing APIs in Rust which are exposed to other languages, there are some\n" "important design principles which are contrary to normal Rust API design:" msgstr "" -"Quando si progettano API in Rust che sono esposte ad altri linguaggi, ce ne " -"sono alcune\n" -"importanti principi di progettazione che sono contrari al normale design " -"dell'API di Rust:" +"Quando si progettano API in Rust che sono esposte ad altri linguaggi, ce ne sono alcune\n" +"importanti principi di progettazione che sono contrari al normale design dell'API di Rust:" #: src\patterns/ffi/export.md:8 #, fuzzy msgid "" "1. All Encapsulated types should be _owned_ by Rust, _managed_ by the user,\n" " and _opaque_.\n" -"2. All Transactional data types should be _owned_ by the user, and " -"_transparent_.\n" +"2. All Transactional data types should be _owned_ by the user, and _transparent_.\n" "3. All library behavior should be functions acting upon Encapsulated types.\n" -"4. All library behavior should be encapsulated into types not based on " -"structure,\n" +"4. All library behavior should be encapsulated into types not based on structure,\n" " but _provenance/lifetime_." msgstr "" -"1. Tutti i tipi Encapsulated dovrebbero essere _posseduti_ da Rust, " -"_gestiti_ dall'utente,\n" +"1. Tutti i tipi Encapsulated dovrebbero essere _posseduti_ da Rust, _gestiti_ dall'utente,\n" " e _opaco_.\n" -"2. Tutti i tipi di dati transazionali devono essere _di proprietà_ " -"dell'utente e _trasparenti_.\n" -"3. Tutti i comportamenti delle librerie dovrebbero essere funzioni che " -"agiscono sui tipi incapsulati.\n" -"4. Tutto il comportamento della libreria dovrebbe essere incapsulato in tipi " -"non basati sulla struttura,\n" +"2. Tutti i tipi di dati transazionali devono essere _di proprietà_ dell'utente e _trasparenti_.\n" +"3. Tutti i comportamenti delle librerie dovrebbero essere funzioni che agiscono sui tipi incapsulati.\n" +"4. Tutto il comportamento della libreria dovrebbe essere incapsulato in tipi non basati sulla struttura,\n" " ma _provenienza/vita_." #: src\patterns/ffi/export.md:17 #, fuzzy msgid "" "Rust has built-in FFI support to other languages.\n" -"It does this by providing a way for crate authors to provide C-compatible " -"APIs\n" +"It does this by providing a way for crate authors to provide C-compatible APIs\n" "through different ABIs (though that is unimportant to this practice)." msgstr "" "Rust ha il supporto FFI integrato per altre lingue.\n" -"Lo fa fornendo agli autori di crate un modo per fornire API compatibili con " -"C\n" +"Lo fa fornendo agli autori di crate un modo per fornire API compatibili con C\n" "attraverso diversi ABI (sebbene ciò non sia importante per questa pratica)." #: src\patterns/ffi/export.md:21 #, fuzzy msgid "" -"Well-designed Rust FFI follows C API design principles, while compromising " -"the\n" -"design in Rust as little as possible. There are three goals with any foreign " -"API:" +"Well-designed Rust FFI follows C API design principles, while compromising the\n" +"design in Rust as little as possible. There are three goals with any foreign API:" msgstr "" -"Rust FFI ben progettato segue i principi di progettazione dell'API C, " -"compromettendo al contempo il\n" -"progettare in Rust il meno possibile. Ci sono tre obiettivi con qualsiasi " -"API esterna:" +"Rust FFI ben progettato segue i principi di progettazione dell'API C, compromettendo al contempo il\n" +"progettare in Rust il meno possibile. Ci sono tre obiettivi con qualsiasi API esterna:" #: src\patterns/ffi/export.md:24 #, fuzzy msgid "" "1. Make it easy to use in the target language.\n" -"2. Avoid the API dictating internal unsafety on the Rust side as much as " -"possible.\n" -"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as " -"small\n" +"2. Avoid the API dictating internal unsafety on the Rust side as much as possible.\n" +"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as small\n" " as possible." msgstr "" "1. Rendilo facile da usare nella lingua di destinazione.\n" -"2. Evita il più possibile che l'API determini l'insicurezza interna sul lato " -"Rust.\n" -"3. Mantenere basso il potenziale di insicurezza della memoria e di " -"\"comportamento indefinito\" di Rust\n" +"2. Evita il più possibile che l'API determini l'insicurezza interna sul lato Rust.\n" +"3. Mantenere basso il potenziale di insicurezza della memoria e di \"comportamento indefinito\" di Rust\n" " possibile." #: src\patterns/ffi/export.md:29 #, fuzzy msgid "" -"Rust code must trust the memory safety of the foreign language beyond a " -"certain\n" -"point. However, every bit of `unsafe` code on the Rust side is an " -"opportunity for\n" +"Rust code must trust the memory safety of the foreign language beyond a certain\n" +"point. However, every bit of `unsafe` code on the Rust side is an opportunity for\n" "bugs, or to exacerbate `undefined behaviour`." msgstr "" -"Il codice Rust deve fidarsi della sicurezza della memoria della lingua " -"straniera oltre un certo\n" -"punto. Tuttavia, ogni bit di codice \"non sicuro\" sul lato Rust è " -"un'opportunità per\n" +"Il codice Rust deve fidarsi della sicurezza della memoria della lingua straniera oltre un certo\n" +"punto. Tuttavia, ogni bit di codice \"non sicuro\" sul lato Rust è un'opportunità per\n" "bug o per esacerbare il `comportamento indefinito`." #: src\patterns/ffi/export.md:33 #, fuzzy msgid "" -"For example, if a pointer provenance is wrong, that may be a segfault due " -"to\n" -"invalid memory access. But if it is manipulated by unsafe code, it could " -"become\n" +"For example, if a pointer provenance is wrong, that may be a segfault due to\n" +"invalid memory access. But if it is manipulated by unsafe code, it could become\n" "full-blown heap corruption." msgstr "" -"Ad esempio, se la provenienza di un puntatore è errata, potrebbe trattarsi " -"di un segfault dovuto a\n" -"accesso alla memoria non valido. Ma se viene manipolato da codice non " -"sicuro, potrebbe diventarlo\n" +"Ad esempio, se la provenienza di un puntatore è errata, potrebbe trattarsi di un segfault dovuto a\n" +"accesso alla memoria non valido. Ma se viene manipolato da codice non sicuro, potrebbe diventarlo\n" "corruzione completa dell'heap." #: src\patterns/ffi/export.md:37 #, fuzzy msgid "" -"The Object-Based API design allows for writing shims that have good memory " -"safety\n" +"The Object-Based API design allows for writing shims that have good memory safety\n" "characteristics, and a clean boundary of what is safe and what is `unsafe`." msgstr "" -"La progettazione dell'API basata su oggetti consente di scrivere shim con " -"una buona sicurezza della memoria\n" -"caratteristiche e un confine netto tra ciò che è sicuro e ciò che è \"non " -"sicuro\"." +"La progettazione dell'API basata su oggetti consente di scrivere shim con una buona sicurezza della memoria\n" +"caratteristiche e un confine netto tra ciò che è sicuro e ciò che è \"non sicuro\"." #: src\patterns/ffi/export.md:42 #, fuzzy msgid "" -"The POSIX standard defines the API to access an on-file database, known as " -"[DBM](https://web.archive.org/web/20210105035602/https://www.mankier.com/0p/ndbm.h).\n" +"The POSIX standard defines the API to access an on-file database, known as [DBM](https://web.archive.org/web/20210105035602/https://" +"www.mankier.com/0p/ndbm.h).\n" "It is an excellent example of an \"object-based\" API." msgstr "" -"Lo standard POSIX definisce l'API per accedere a un database su file, noto " -"come " -"[DBM](https://web.archive.org/web/20210105035602/https://www.mankier.com/0p/ndbm.h) " -".\n" +"Lo standard POSIX definisce l'API per accedere a un database su file, noto come [DBM](https://web.archive.org/web/20210105035602/" +"https://www.mankier.com/0p/ndbm.h) .\n" "È un eccellente esempio di API \"basata su oggetti\"." #: src\patterns/ffi/export.md:45 #, fuzzy msgid "" -"Here is the definition in C, which hopefully should be easy to read for " -"those\n" +"Here is the definition in C, which hopefully should be easy to read for those\n" "involved in FFI. The commentary below should help explain it for those who\n" "miss the subtleties." msgstr "" -"Ecco la definizione in C, che si spera dovrebbe essere facile da leggere per " -"quelli\n" -"coinvolti in FFI. Il commento qui sotto dovrebbe aiutare a spiegarlo per " -"coloro che\n" +"Ecco la definizione in C, che si spera dovrebbe essere facile da leggere per quelli\n" +"coinvolti in FFI. Il commento qui sotto dovrebbe aiutare a spiegarlo per coloro che\n" "perdere le sottigliezze." #: src\patterns/ffi/export.md:49 @@ -6573,54 +5554,42 @@ msgstr "Questa API definisce due tipi: `DBM` e `datum`." #, fuzzy msgid "" "The `DBM` type was called an \"encapsulated\" type above.\n" -"It is designed to contain internal state, and acts as an entry point for " -"the\n" +"It is designed to contain internal state, and acts as an entry point for the\n" "library's behavior." msgstr "" "Il tipo `DBM` è stato chiamato un tipo \"incapsulato\" sopra.\n" -"È progettato per contenere lo stato interno e funge da punto di ingresso per " -"il\n" +"È progettato per contenere lo stato interno e funge da punto di ingresso per il\n" "comportamento della biblioteca" #: src\patterns/ffi/export.md:70 #, fuzzy msgid "" -"It is completely opaque to the user, who cannot create a `DBM` themselves " -"since\n" -"they don't know its size or layout. Instead, they must call `dbm_open`, and " -"that\n" +"It is completely opaque to the user, who cannot create a `DBM` themselves since\n" +"they don't know its size or layout. Instead, they must call `dbm_open`, and that\n" "only gives them _a pointer to one_." msgstr "" -"È completamente opaco per l'utente, che da allora non può creare un " -"\"DBM\".\n" -"non ne conoscono le dimensioni o il layout. Invece, devono chiamare " -"\"dbm_open\" e così via\n" +"È completamente opaco per l'utente, che da allora non può creare un \"DBM\".\n" +"non ne conoscono le dimensioni o il layout. Invece, devono chiamare \"dbm_open\" e così via\n" "dà loro solo _un puntatore a uno_." #: src\patterns/ffi/export.md:74 #, fuzzy msgid "" "This means all `DBM`s are \"owned\" by the library in a Rust sense.\n" -"The internal state of unknown size is kept in memory controlled by the " -"library,\n" -"not the user. The user can only manage its life cycle with `open` and " -"`close`,\n" +"The internal state of unknown size is kept in memory controlled by the library,\n" +"not the user. The user can only manage its life cycle with `open` and `close`,\n" "and perform operations on it with the other functions." msgstr "" -"Ciò significa che tutti i `DBM` sono \"di proprietà\" della libreria in un " -"certo senso Rust.\n" -"Lo stato interno di dimensioni sconosciute viene mantenuto in memoria " -"controllato dalla libreria,\n" -"non l'utente. L'utente può gestire il suo ciclo di vita solo con `apri` e " -"`chiudi`,\n" +"Ciò significa che tutti i `DBM` sono \"di proprietà\" della libreria in un certo senso Rust.\n" +"Lo stato interno di dimensioni sconosciute viene mantenuto in memoria controllato dalla libreria,\n" +"non l'utente. L'utente può gestire il suo ciclo di vita solo con `apri` e `chiudi`,\n" "ed eseguire operazioni su di esso con le altre funzioni." #: src\patterns/ffi/export.md:79 #, fuzzy msgid "" "The `datum` type was called a \"transactional\" type above.\n" -"It is designed to facilitate the exchange of information between the library " -"and\n" +"It is designed to facilitate the exchange of information between the library and\n" "its user." msgstr "" "Il tipo `datum` era soprannominato tipo \"transazionale\".\n" @@ -6630,20 +5599,14 @@ msgstr "" #: src\patterns/ffi/export.md:83 #, fuzzy msgid "" -"The database is designed to store \"unstructured data\", with no pre-defined " -"length\n" -"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a " -"bunch\n" -"of bytes, and a count of how many there are. The main difference is that " -"there is\n" +"The database is designed to store \"unstructured data\", with no pre-defined length\n" +"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a bunch\n" +"of bytes, and a count of how many there are. The main difference is that there is\n" "no type information, which is what `void` indicates." msgstr "" -"Il database è progettato per memorizzare \"dati non strutturati\", senza una " -"lunghezza predefinita\n" -"o significato. Di conseguenza, il \"dato\" è l'equivalente in C di una fetta " -"di ruggine: un mucchio\n" -"di byte e un conteggio di quanti ce ne sono. La differenza principale è che " -"c'è\n" +"Il database è progettato per memorizzare \"dati non strutturati\", senza una lunghezza predefinita\n" +"o significato. Di conseguenza, il \"dato\" è l'equivalente in C di una fetta di ruggine: un mucchio\n" +"di byte e un conteggio di quanti ce ne sono. La differenza principale è che c'è\n" "nessuna informazione sul tipo, che è ciò che indica \"void\"." #: src\patterns/ffi/export.md:88 @@ -6651,29 +5614,23 @@ msgstr "" msgid "" "Keep in mind that this header is written from the library's point of view.\n" "The user likely has some type they are using, which has a known size.\n" -"But the library does not care, and by the rules of C casting, any type " -"behind a\n" +"But the library does not care, and by the rules of C casting, any type behind a\n" "pointer can be cast to `void`." msgstr "" -"Tieni presente che questa intestazione è scritta dal punto di vista della " -"biblioteca.\n" -"L'utente probabilmente ha un tipo che sta usando, che ha una dimensione " -"nota.\n" -"Ma alla libreria non interessa, e secondo le regole del casting C, qualsiasi " -"tipo dietro a\n" +"Tieni presente che questa intestazione è scritta dal punto di vista della biblioteca.\n" +"L'utente probabilmente ha un tipo che sta usando, che ha una dimensione nota.\n" +"Ma alla libreria non interessa, e secondo le regole del casting C, qualsiasi tipo dietro a\n" "il puntatore può essere lanciato su \"void\"." #: src\patterns/ffi/export.md:93 #, fuzzy msgid "" -"As noted earlier, this type is _transparent_ to the user. But also, this " -"type is\n" +"As noted earlier, this type is _transparent_ to the user. But also, this type is\n" "_owned_ by the user.\n" "This has subtle ramifications, due to that pointer inside it.\n" "The question is, who owns the memory that pointer points to?" msgstr "" -"Come notato in precedenza, questo tipo è _trasparente_ per l'utente. Ma " -"anche questo tipo lo è\n" +"Come notato in precedenza, questo tipo è _trasparente_ per l'utente. Ma anche questo tipo lo è\n" "_posseduto_ dall'utente.\n" "Questo ha sottili ramificazioni, a causa di quel puntatore al suo interno.\n" "La domanda è: chi possiede la memoria a cui punta il puntatore?" @@ -6682,20 +5639,15 @@ msgstr "" #, fuzzy msgid "" "The answer for best memory safety is, \"the user\".\n" -"But in cases such as retrieving a value, the user does not know how to " -"allocate\n" -"it correctly (since they don't know how long the value is). In this case, " -"the library\n" -"code is expected to use the heap that the user has access to -- such as the " -"C library\n" +"But in cases such as retrieving a value, the user does not know how to allocate\n" +"it correctly (since they don't know how long the value is). In this case, the library\n" +"code is expected to use the heap that the user has access to -- such as the C library\n" "`malloc` and `free` -- and then _transfer ownership_ in the Rust sense." msgstr "" "La risposta per la migliore sicurezza della memoria è \"l'utente\".\n" "Ma in casi come il recupero di un valore, l'utente non sa come allocare\n" -"correttamente (poiché non sanno quanto è lungo il valore). In questo caso, " -"la biblioteca\n" -"il codice dovrebbe utilizzare l'heap a cui l'utente ha accesso, come la " -"libreria C\n" +"correttamente (poiché non sanno quanto è lungo il valore). In questo caso, la biblioteca\n" +"il codice dovrebbe utilizzare l'heap a cui l'utente ha accesso, come la libreria C\n" "`malloc` e `free` -- e poi _trasferire la proprietà_ nel senso di Rust." #: src\patterns/ffi/export.md:104 @@ -6703,78 +5655,60 @@ msgstr "" msgid "" "This may all seem speculative, but this is what a pointer means in C.\n" "It means the same thing as Rust: \"user defined lifetime.\"\n" -"The user of the library needs to read the documentation in order to use it " -"correctly.\n" -"That said, there are some decisions that have fewer or greater consequences " -"if users\n" -"do it wrong. Minimizing those are what this best practice is about, and the " -"key\n" +"The user of the library needs to read the documentation in order to use it correctly.\n" +"That said, there are some decisions that have fewer or greater consequences if users\n" +"do it wrong. Minimizing those are what this best practice is about, and the key\n" "is to _transfer ownership of everything that is transparent_." msgstr "" -"Tutto questo può sembrare speculativo, ma questo è ciò che significa un " -"puntatore in C.\n" +"Tutto questo può sembrare speculativo, ma questo è ciò che significa un puntatore in C.\n" "Significa la stessa cosa di Rust: \"durata definita dall'utente\".\n" -"L'utente della libreria deve leggere la documentazione per poterla " -"utilizzare correttamente.\n" -"Detto questo, ci sono alcune decisioni che hanno conseguenze minori o " -"maggiori se gli utenti\n" -"fallo male. Ridurli al minimo è ciò di cui tratta questa best practice e la " -"chiave\n" +"L'utente della libreria deve leggere la documentazione per poterla utilizzare correttamente.\n" +"Detto questo, ci sono alcune decisioni che hanno conseguenze minori o maggiori se gli utenti\n" +"fallo male. Ridurli al minimo è ciò di cui tratta questa best practice e la chiave\n" "è _trasferire la proprietà di tutto ciò che è trasparente_." #: src\patterns/ffi/export.md:113 #, fuzzy msgid "" -"This minimizes the number of memory safety guarantees the user must uphold " -"to a\n" +"This minimizes the number of memory safety guarantees the user must uphold to a\n" "relatively small number:" msgstr "" -"Ciò riduce al minimo il numero di garanzie di sicurezza della memoria che " -"l'utente deve mantenere a\n" +"Ciò riduce al minimo il numero di garanzie di sicurezza della memoria che l'utente deve mantenere a\n" "numero relativamente piccolo:" #: src\patterns/ffi/export.md:116 #, fuzzy msgid "" -"1. Do not call any function with a pointer not returned by `dbm_open` " -"(invalid\n" +"1. Do not call any function with a pointer not returned by `dbm_open` (invalid\n" " access or corruption).\n" "2. Do not call any function on a pointer after close (use after free).\n" -"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of " -"memory\n" +"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of memory\n" " at the advertised length." msgstr "" -"1. Non chiamare alcuna funzione con un puntatore non restituito da " -"`dbm_open` (invalid\n" +"1. Non chiamare alcuna funzione con un puntatore non restituito da `dbm_open` (invalid\n" " accesso o corruzione).\n" -"2. Non chiamare alcuna funzione su un puntatore dopo la chiusura (usa dopo " -"free).\n" -"3. Il `dptr` su qualsiasi `dato` deve essere `NULL` o puntare a una fetta di " -"memoria valida\n" +"2. Non chiamare alcuna funzione su un puntatore dopo la chiusura (usa dopo free).\n" +"3. Il `dptr` su qualsiasi `dato` deve essere `NULL` o puntare a una fetta di memoria valida\n" " alla lunghezza pubblicizzata." #: src\patterns/ffi/export.md:122 #, fuzzy msgid "" "In addition, it avoids a lot of pointer provenance issues.\n" -"To understand why, let us consider an alternative in some depth: key " -"iteration." +"To understand why, let us consider an alternative in some depth: key iteration." msgstr "" "Inoltre, evita molti problemi di provenienza del puntatore.\n" -"Per capire perché, consideriamo un'alternativa in modo approfondito: " -"l'iterazione chiave." +"Per capire perché, consideriamo un'alternativa in modo approfondito: l'iterazione chiave." #: src\patterns/ffi/export.md:125 #, fuzzy msgid "" "Rust is well known for its iterators.\n" -"When implementing one, the programmer makes a separate type with a bounded " -"lifetime\n" +"When implementing one, the programmer makes a separate type with a bounded lifetime\n" "to its owner, and implements the `Iterator` trait." msgstr "" "Rust è ben noto per i suoi iteratori.\n" -"Quando ne implementa uno, il programmatore crea un tipo separato con una " -"durata limitata\n" +"Quando ne implementa uno, il programmatore crea un tipo separato con una durata limitata\n" "al suo proprietario e implementa il tratto `Iterator`." #: src\patterns/ffi/export.md:129 @@ -6815,21 +5749,18 @@ msgid "" "```rust,ignore\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_new(owner: *const Dbm) -> *mut DbmKeysIter {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_next(\n" " iter: *mut DbmKeysIter,\n" " key_out: *const datum\n" ") -> libc::c_int {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_del(*mut DbmKeysIter) {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "```" msgstr "" @@ -6837,27 +5768,20 @@ msgstr "" #: src\patterns/ffi/export.md:168 #, fuzzy msgid "" -"This API loses a key piece of information: the lifetime of the iterator must " -"not\n" -"exceed the lifetime of the `Dbm` object that owns it. A user of the library " -"could\n" -"use it in a way which causes the iterator to outlive the data it is " -"iterating on,\n" +"This API loses a key piece of information: the lifetime of the iterator must not\n" +"exceed the lifetime of the `Dbm` object that owns it. A user of the library could\n" +"use it in a way which causes the iterator to outlive the data it is iterating on,\n" "resulting in reading uninitialized memory." msgstr "" "Questa API perde un'informazione chiave: la durata dell'iteratore no\n" -"superare la durata dell'oggetto `Dbm` che lo possiede. Un utente della " -"biblioteca potrebbe\n" -"usalo in un modo che fa sì che l'iteratore sopravviva ai dati su cui sta " -"iterando,\n" +"superare la durata dell'oggetto `Dbm` che lo possiede. Un utente della biblioteca potrebbe\n" +"usalo in un modo che fa sì che l'iteratore sopravviva ai dati su cui sta iterando,\n" "con conseguente lettura della memoria non inizializzata." #: src\patterns/ffi/export.md:173 #, fuzzy -msgid "" -"This example written in C contains a bug that will be explained afterwards:" -msgstr "" -"Questo esempio scritto in C contiene un bug che verrà spiegato in seguito:" +msgid "This example written in C contains a bug that will be explained afterwards:" +msgstr "Questo esempio scritto in C contiene un bug che verrà spiegato in seguito:" #: src\patterns/ffi/export.md:175 msgid "" @@ -6873,8 +5797,7 @@ msgid "" " }\n" "\n" " int l;\n" -" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated " -"by -1\n" +" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated by -1\n" " free(key.dptr);\n" " len += key.dsize;\n" " if (l == 0) { // end of the iterator\n" @@ -6896,85 +5819,63 @@ msgid "" "This bug is a classic. Here's what happens when the iterator returns the\n" "end-of-iteration marker:" msgstr "" -"Questo bug è un classico. Ecco cosa succede quando l'iteratore restituisce " -"il\n" +"Questo bug è un classico. Ecco cosa succede quando l'iteratore restituisce il\n" "marcatore di fine iterazione:" #: src\patterns/ffi/export.md:205 #, fuzzy msgid "" -"1. The loop condition sets `l` to zero, and enters the loop because `0 >= " -"0`.\n" +"1. The loop condition sets `l` to zero, and enters the loop because `0 >= 0`.\n" "2. The length is incremented, in this case by zero.\n" -"3. The if statement is true, so the database is closed. There should be a " -"break\n" +"3. The if statement is true, so the database is closed. There should be a break\n" " statement here.\n" -"4. The loop condition executes again, causing a `next` call on the closed " -"object." +"4. The loop condition executes again, causing a `next` call on the closed object." msgstr "" -"1. La condizione del ciclo imposta \"l\" su zero ed entra nel ciclo perché " -"\"0 >= 0\".\n" +"1. La condizione del ciclo imposta \"l\" su zero ed entra nel ciclo perché \"0 >= 0\".\n" "2. La lunghezza viene incrementata, in questo caso di zero.\n" -"3. L'istruzione if è vera, quindi il database è chiuso. Dovrebbe esserci una " -"pausa\n" +"3. L'istruzione if è vera, quindi il database è chiuso. Dovrebbe esserci una pausa\n" " dichiarazione qui.\n" -"4. La condizione del ciclo viene eseguita di nuovo, causando una chiamata " -"`next` sull'oggetto chiuso." +"4. La condizione del ciclo viene eseguita di nuovo, causando una chiamata `next` sull'oggetto chiuso." #: src\patterns/ffi/export.md:211 #, fuzzy msgid "" "The worst part about this bug?\n" -"If the Rust implementation was careful, this code will work most of the " -"time!\n" -"If the memory for the `Dbm` object is not immediately reused, an internal " -"check\n" -"will almost certainly fail, resulting in the iterator returning a `-1` " -"indicating\n" -"an error. But occasionally, it will cause a segmentation fault, or even " -"worse,\n" +"If the Rust implementation was careful, this code will work most of the time!\n" +"If the memory for the `Dbm` object is not immediately reused, an internal check\n" +"will almost certainly fail, resulting in the iterator returning a `-1` indicating\n" +"an error. But occasionally, it will cause a segmentation fault, or even worse,\n" "nonsensical memory corruption!" msgstr "" "La parte peggiore di questo bug?\n" -"Se l'implementazione di Rust è stata attenta, questo codice funzionerà per " -"la maggior parte del tempo!\n" -"Se la memoria per l'oggetto `Dbm` non viene riutilizzata immediatamente, un " -"controllo interno\n" -"quasi sicuramente fallirà, con il risultato che l'iteratore restituirà un " -"`-1` che indica\n" -"un errore. Ma occasionalmente, causerà un errore di segmentazione o, peggio " -"ancora,\n" +"Se l'implementazione di Rust è stata attenta, questo codice funzionerà per la maggior parte del tempo!\n" +"Se la memoria per l'oggetto `Dbm` non viene riutilizzata immediatamente, un controllo interno\n" +"quasi sicuramente fallirà, con il risultato che l'iteratore restituirà un `-1` che indica\n" +"un errore. Ma occasionalmente, causerà un errore di segmentazione o, peggio ancora,\n" "corruzione della memoria senza senso!" #: src\patterns/ffi/export.md:218 #, fuzzy msgid "" "None of this can be avoided by Rust.\n" -"From its perspective, it put those objects on its heap, returned pointers to " -"them,\n" +"From its perspective, it put those objects on its heap, returned pointers to them,\n" "and gave up control of their lifetimes. The C code simply must \"play nice\"." msgstr "" "Niente di tutto questo può essere evitato da Rust.\n" -"Dal suo punto di vista, ha messo quegli oggetti nel suo heap, ha restituito " -"loro dei puntatori,\n" -"e ha rinunciato al controllo delle loro vite. Il codice C deve semplicemente " -"\"giocare bene\"." +"Dal suo punto di vista, ha messo quegli oggetti nel suo heap, ha restituito loro dei puntatori,\n" +"e ha rinunciato al controllo delle loro vite. Il codice C deve semplicemente \"giocare bene\"." #: src\patterns/ffi/export.md:222 #, fuzzy msgid "" "The programmer must read and understand the API documentation.\n" -"While some consider that par for the course in C, a good API design can " -"mitigate\n" -"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ " -"of\n" +"While some consider that par for the course in C, a good API design can mitigate\n" +"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ of\n" "the iterator with its parent:" msgstr "" "Il programmatore deve leggere e comprendere la documentazione dell'API.\n" -"Sebbene alcuni considerino la norma per il corso in C, una buona " -"progettazione dell'API può mitigare\n" -"questo rischio. L'API POSIX per `DBM` ha fatto questo _consolidando la " -"proprietà_ di\n" +"Sebbene alcuni considerino la norma per il corso in C, una buona progettazione dell'API può mitigare\n" +"questo rischio. L'API POSIX per `DBM` ha fatto questo _consolidando la proprietà_ di\n" "l'iteratore con il suo genitore:" #: src\patterns/ffi/export.md:227 @@ -6987,11 +5888,8 @@ msgstr "" #: src\patterns/ffi/export.md:232 #, fuzzy -msgid "" -"Thus, all the lifetimes were bound together, and such unsafety was prevented." -msgstr "" -"Così, tutte le vite sono state legate insieme e tale insicurezza è stata " -"prevenuta." +msgid "Thus, all the lifetimes were bound together, and such unsafety was prevented." +msgstr "Così, tutte le vite sono state legate insieme e tale insicurezza è stata prevenuta." #: src\patterns/ffi/export.md:236 #, fuzzy @@ -6999,72 +5897,56 @@ msgid "" "However, this design choice also has a number of drawbacks, which should be\n" "considered as well." msgstr "" -"Tuttavia, questa scelta progettuale presenta anche una serie di " -"inconvenienti, che dovrebbero essere\n" +"Tuttavia, questa scelta progettuale presenta anche una serie di inconvenienti, che dovrebbero essere\n" "considerato pure." #: src\patterns/ffi/export.md:239 #, fuzzy msgid "" "First, the API itself becomes less expressive.\n" -"With POSIX DBM, there is only one iterator per object, and every call " -"changes\n" -"its state. This is much more restrictive than iterators in almost any " -"language,\n" -"even though it is safe. Perhaps with other related objects, whose lifetimes " -"are\n" +"With POSIX DBM, there is only one iterator per object, and every call changes\n" +"its state. This is much more restrictive than iterators in almost any language,\n" +"even though it is safe. Perhaps with other related objects, whose lifetimes are\n" "less hierarchical, this limitation is more of a cost than the safety." msgstr "" "Innanzitutto, l'API stessa diventa meno espressiva.\n" "Con POSIX DBM, esiste un solo iteratore per oggetto e ogni chiamata cambia\n" -"il suo stato. Questo è molto più restrittivo degli iteratori in quasi tutte " -"le lingue,\n" +"il suo stato. Questo è molto più restrittivo degli iteratori in quasi tutte le lingue,\n" "anche se è sicuro. Forse con altri oggetti correlati, le cui vite sono\n" "meno gerarchica, questa limitazione è più un costo che la sicurezza." #: src\patterns/ffi/export.md:245 #, fuzzy msgid "" -"Second, depending on the relationships of the API's parts, significant " -"design effort\n" -"may be involved. Many of the easier design points have other patterns " -"associated\n" +"Second, depending on the relationships of the API's parts, significant design effort\n" +"may be involved. Many of the easier design points have other patterns associated\n" "with them:" msgstr "" -"In secondo luogo, a seconda delle relazioni tra le parti dell'API, uno " -"sforzo di progettazione significativo\n" -"può essere coinvolto. Molti dei punti di progettazione più semplici hanno " -"altri modelli associati\n" +"In secondo luogo, a seconda delle relazioni tra le parti dell'API, uno sforzo di progettazione significativo\n" +"può essere coinvolto. Molti dei punti di progettazione più semplici hanno altri modelli associati\n" "con loro:" #: src\patterns/ffi/export.md:249 #, fuzzy msgid "" -"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types " -"together\n" +"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types together\n" " into an opaque \"object\"\n" "\n" -"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling " -"with integer\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling with integer\n" " codes and sentinel return values (such as `NULL` pointers)\n" "\n" -"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows " -"accepting\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows accepting\n" " strings with minimal unsafe code, and is easier to get right than\n" " [Passing Strings to FFI](../../idioms/ffi/passing-strings.md)" msgstr "" -"- [Consolidamento del tipo di wrapper](./wrappers.md) raggruppa più tipi di " -"ruggine insieme\n" +"- [Consolidamento del tipo di wrapper](./wrappers.md) raggruppa più tipi di ruggine insieme\n" " in un \"oggetto\" opaco\n" "\n" -"- [FFI Error Passing](../../idioms/ffi/errors.md) spiega la gestione degli " -"errori con numeri interi\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) spiega la gestione degli errori con numeri interi\n" " codici e valori di ritorno sentinella (come i puntatori `NULL`)\n" "\n" -"- [Accettare stringhe esterne](../../idioms/ffi/accepting-strings.md) " -"consente di accettare\n" -" stringhe con codice non sicuro minimo ed è più facile da ottenere rispetto " -"a\n" +"- [Accettare stringhe esterne](../../idioms/ffi/accepting-strings.md) consente di accettare\n" +" stringhe con codice non sicuro minimo ed è più facile da ottenere rispetto a\n" " [Passaggio di stringhe a FFI](../../idioms/ffi/passing-strings.md)" #: src\patterns/ffi/export.md:259 @@ -7074,8 +5956,7 @@ msgid "" "It is up to the best judgement of the programmer as to who their audience is." msgstr "" "Tuttavia, non tutte le API possono essere eseguite in questo modo.\n" -"Spetta al miglior giudizio del programmatore stabilire chi sia il suo " -"pubblico." +"Spetta al miglior giudizio del programmatore stabilire chi sia il suo pubblico." #: src\patterns/ffi/wrappers.md:1 #, fuzzy @@ -7085,12 +5966,10 @@ msgstr "# Digitare Consolidation into Wrapper" #: src\patterns/ffi/wrappers.md:5 #, fuzzy msgid "" -"This pattern is designed to allow gracefully handling multiple related " -"types,\n" +"This pattern is designed to allow gracefully handling multiple related types,\n" "while minimizing the surface area for memory unsafety." msgstr "" -"Questo modello è progettato per consentire di gestire con garbo più tipi " -"correlati,\n" +"Questo modello è progettato per consentire di gestire con garbo più tipi correlati,\n" "riducendo al minimo la superficie per l'insicurezza della memoria." #: src\patterns/ffi/wrappers.md:8 @@ -7101,62 +5980,47 @@ msgid "" "data race safety included." msgstr "" "Uno dei capisaldi delle regole di aliasing di Rust sono le vite.\n" -"Ciò garantisce che molti modelli di accesso tra i tipi possano essere sicuri " -"per la memoria,\n" +"Ciò garantisce che molti modelli di accesso tra i tipi possano essere sicuri per la memoria,\n" "sicurezza della gara di dati inclusa." #: src\patterns/ffi/wrappers.md:12 #, fuzzy msgid "" -"However, when Rust types are exported to other languages, they are usually " -"transformed\n" -"into pointers. In Rust, a pointer means \"the user manages the lifetime of " -"the pointee.\"\n" +"However, when Rust types are exported to other languages, they are usually transformed\n" +"into pointers. In Rust, a pointer means \"the user manages the lifetime of the pointee.\"\n" "It is their responsibility to avoid memory unsafety." msgstr "" -"Tuttavia, quando i tipi di Rust vengono esportati in altri linguaggi, di " -"solito vengono trasformati\n" -"in puntatori. In Rust, un puntatore significa \"l'utente gestisce la vita " -"del puntatore\".\n" +"Tuttavia, quando i tipi di Rust vengono esportati in altri linguaggi, di solito vengono trasformati\n" +"in puntatori. In Rust, un puntatore significa \"l'utente gestisce la vita del puntatore\".\n" "È loro responsabilità evitare l'insicurezza della memoria." #: src\patterns/ffi/wrappers.md:16 #, fuzzy msgid "" -"Some level of trust in the user code is thus required, notably around " -"use-after-free\n" -"which Rust can do nothing about. However, some API designs place higher " -"burdens\n" +"Some level of trust in the user code is thus required, notably around use-after-free\n" +"which Rust can do nothing about. However, some API designs place higher burdens\n" "than others on the code written in the other language." msgstr "" -"È quindi richiesto un certo livello di fiducia nel codice utente, in " -"particolare per quanto riguarda l'uso dopo il libero\n" -"per cui Rust non può fare nulla. Tuttavia, alcuni progetti di API comportano " -"oneri maggiori\n" +"È quindi richiesto un certo livello di fiducia nel codice utente, in particolare per quanto riguarda l'uso dopo il libero\n" +"per cui Rust non può fare nulla. Tuttavia, alcuni progetti di API comportano oneri maggiori\n" "di altri sul codice scritto nell'altra lingua." #: src\patterns/ffi/wrappers.md:20 #, fuzzy msgid "" -"The lowest risk API is the \"consolidated wrapper\", where all possible " -"interactions\n" -"with an object are folded into a \"wrapper type\", while keeping the Rust " -"API clean." +"The lowest risk API is the \"consolidated wrapper\", where all possible interactions\n" +"with an object are folded into a \"wrapper type\", while keeping the Rust API clean." msgstr "" -"L'API a rischio più basso è il \"wrapper consolidato\", in cui tutte le " -"possibili interazioni\n" -"con un oggetto vengono piegati in un \"tipo wrapper\", mantenendo pulita " -"l'API di Rust." +"L'API a rischio più basso è il \"wrapper consolidato\", in cui tutte le possibili interazioni\n" +"con un oggetto vengono piegati in un \"tipo wrapper\", mantenendo pulita l'API di Rust." #: src\patterns/ffi/wrappers.md:25 #, fuzzy msgid "" -"To understand this, let us look at a classic example of an API to export: " -"iteration\n" +"To understand this, let us look at a classic example of an API to export: iteration\n" "through a collection." msgstr "" -"Per capirlo, esaminiamo un classico esempio di API da esportare: " -"l'iterazione\n" +"Per capirlo, esaminiamo un classico esempio di API da esportare: l'iterazione\n" "attraverso una raccolta" #: src\patterns/ffi/wrappers.md:28 @@ -7170,26 +6034,22 @@ msgid "" "1. The iterator is initialized with `first_key`.\n" "2. Each call to `next_key` will advance the iterator.\n" "3. Calls to `next_key` if the iterator is at the end will do nothing.\n" -"4. As noted above, the iterator is \"wrapped into\" the collection (unlike " -"the native\n" +"4. As noted above, the iterator is \"wrapped into\" the collection (unlike the native\n" " Rust API)." msgstr "" "1. L'iteratore viene inizializzato con `first_key`.\n" "2. Ogni chiamata a `next_key` farà avanzare l'iteratore.\n" "3. Le chiamate a `next_key` se l'iteratore è alla fine non faranno nulla.\n" -"4. Come notato sopra, l'iteratore è \"inserito\" nella raccolta (a " -"differenza del file native\n" +"4. Come notato sopra, l'iteratore è \"inserito\" nella raccolta (a differenza del file native\n" " API ruggine)." #: src\patterns/ffi/wrappers.md:36 #, fuzzy msgid "" -"If the iterator implements `nth()` efficiently, then it is possible to make " -"it\n" +"If the iterator implements `nth()` efficiently, then it is possible to make it\n" "ephemeral to each function call:" msgstr "" -"Se l'iteratore implementa `nth()` in modo efficiente, allora è possibile " -"farlo\n" +"Se l'iteratore implementa `nth()` in modo efficiente, allora è possibile farlo\n" "effimero per ogni chiamata di funzione:" #: src\patterns/ffi/wrappers.md:39 @@ -7220,51 +6080,39 @@ msgstr "" #: src\patterns/ffi/wrappers.md:61 #, fuzzy msgid "As a result, the wrapper is simple and contains no `unsafe` code." -msgstr "" -"Di conseguenza, il wrapper è semplice e non contiene codice \"non sicuro\"." +msgstr "Di conseguenza, il wrapper è semplice e non contiene codice \"non sicuro\"." #: src\patterns/ffi/wrappers.md:65 #, fuzzy msgid "" "This makes APIs safer to use, avoiding issues with lifetimes between types.\n" -"See [Object-Based APIs](./export.md) for more on the advantages and " -"pitfalls\n" +"See [Object-Based APIs](./export.md) for more on the advantages and pitfalls\n" "this avoids." msgstr "" -"Questo rende le API più sicure da usare, evitando problemi con la durata tra " -"i tipi.\n" -"Vedere [API basate su oggetti](./export.md) per ulteriori informazioni sui " -"vantaggi e le insidie\n" +"Questo rende le API più sicure da usare, evitando problemi con la durata tra i tipi.\n" +"Vedere [API basate su oggetti](./export.md) per ulteriori informazioni sui vantaggi e le insidie\n" "questo evita." #: src\patterns/ffi/wrappers.md:71 #, fuzzy msgid "" -"Often, wrapping types is quite difficult, and sometimes a Rust API " -"compromise\n" +"Often, wrapping types is quite difficult, and sometimes a Rust API compromise\n" "would make things easier." msgstr "" -"Spesso, il wrapping dei tipi è piuttosto difficile e talvolta un compromesso " -"con l'API Rust\n" +"Spesso, il wrapping dei tipi è piuttosto difficile e talvolta un compromesso con l'API Rust\n" "renderebbe le cose più facili." #: src\patterns/ffi/wrappers.md:74 #, fuzzy msgid "" -"As an example, consider an iterator which does not efficiently implement " -"`nth()`.\n" -"It would definitely be worth putting in special logic to make the object " -"handle\n" -"iteration internally, or to support a different access pattern efficiently " -"that\n" +"As an example, consider an iterator which does not efficiently implement `nth()`.\n" +"It would definitely be worth putting in special logic to make the object handle\n" +"iteration internally, or to support a different access pattern efficiently that\n" "only the Foreign Function API will use." msgstr "" -"Ad esempio, considera un iteratore che non implementa in modo efficiente " -"`nth()`.\n" -"Varrebbe sicuramente la pena inserire una logica speciale per far gestire " -"l'oggetto\n" -"iterazione interna o per supportare un diverso modello di accesso in modo " -"efficiente\n" +"Ad esempio, considera un iteratore che non implementa in modo efficiente `nth()`.\n" +"Varrebbe sicuramente la pena inserire una logica speciale per far gestire l'oggetto\n" +"iterazione interna o per supportare un diverso modello di accesso in modo efficiente\n" "utilizzerà solo l'API della funzione esterna." #: src\patterns/ffi/wrappers.md:79 @@ -7275,16 +6123,12 @@ msgstr "### Tentativo di avvolgere gli iteratori (e fallire)" #: src\patterns/ffi/wrappers.md:81 #, fuzzy msgid "" -"To wrap any type of iterator into the API correctly, the wrapper would need " -"to\n" -"do what a C version of the code would do: erase the lifetime of the " -"iterator,\n" +"To wrap any type of iterator into the API correctly, the wrapper would need to\n" +"do what a C version of the code would do: erase the lifetime of the iterator,\n" "and manage it manually." msgstr "" -"Per racchiudere correttamente qualsiasi tipo di iteratore nell'API, il " -"wrapper dovrebbe farlo\n" -"fai quello che farebbe una versione C del codice: cancella la durata " -"dell'iteratore,\n" +"Per racchiudere correttamente qualsiasi tipo di iteratore nell'API, il wrapper dovrebbe farlo\n" +"fai quello che farebbe una versione C del codice: cancella la durata dell'iteratore,\n" "e gestirlo manualmente." #: src\patterns/ffi/wrappers.md:85 @@ -7321,8 +6165,7 @@ msgid "" "it's ugly already. But it gets even worse: _any other operation can cause\n" "Rust `undefined behaviour`_." msgstr "" -"Con `transmute` utilizzato per estendere una durata e un puntatore per " -"nasconderlo,\n" +"Con `transmute` utilizzato per estendere una durata e un puntatore per nasconderlo,\n" "è già brutto. Ma c'è di peggio: _qualsiasi altra operazione può causare\n" "Rust `comportamento indefinito`_." @@ -7335,8 +6178,7 @@ msgid "" "libraries expect it." msgstr "" "Considera che \"MySet\" nel wrapper potrebbe essere manipolato da altri\n" -"funzioni durante l'iterazione, come la memorizzazione di un nuovo valore " -"nella chiave che era\n" +"funzioni durante l'iterazione, come la memorizzazione di un nuovo valore nella chiave che era\n" "iterando. L'API non scoraggia questo, e in effetti alcuni simili C\n" "le biblioteche se lo aspettano." @@ -7359,8 +6201,7 @@ msgid "" "\n" " // DO NOT USE THIS CODE. IT IS UNSAFE TO DEMONSTRATE A PROLBEM.\n" "\n" -" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in " -"here!\n" +" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in here!\n" " &mut (*myset).myset\n" " };\n" "\n" @@ -7378,104 +6219,71 @@ msgstr "" #: src\patterns/ffi/wrappers.md:137 #, fuzzy msgid "" -"If the iterator exists when this function is called, we have violated one of " -"Rust's\n" -"aliasing rules. According to Rust, the mutable reference in this block must " -"have\n" -"_exclusive_ access to the object. If the iterator simply exists, it's not " -"exclusive,\n" +"If the iterator exists when this function is called, we have violated one of Rust's\n" +"aliasing rules. According to Rust, the mutable reference in this block must have\n" +"_exclusive_ access to the object. If the iterator simply exists, it's not exclusive,\n" "so we have `undefined behaviour`! " msgstr "" -"Se l'iteratore esiste quando viene chiamata questa funzione, ne abbiamo " -"violato uno di Rust\n" -"regole di aliasing Secondo Rust, il riferimento mutabile in questo blocco " -"deve avere\n" -"accesso _esclusivo_ all'oggetto. Se l'iteratore esiste semplicemente, non è " -"esclusivo,\n" +"Se l'iteratore esiste quando viene chiamata questa funzione, ne abbiamo violato uno di Rust\n" +"regole di aliasing Secondo Rust, il riferimento mutabile in questo blocco deve avere\n" +"accesso _esclusivo_ all'oggetto. Se l'iteratore esiste semplicemente, non è esclusivo,\n" "quindi abbiamo un `comportamento indefinito`!" #: src\patterns/ffi/wrappers.md:142 #, fuzzy msgid "" -"To avoid this, we must have a way of ensuring that mutable reference really " -"is exclusive.\n" -"That basically means clearing out the iterator's shared reference while it " -"exists,\n" -"and then reconstructing it. In most cases, that will still be less efficient " -"than\n" +"To avoid this, we must have a way of ensuring that mutable reference really is exclusive.\n" +"That basically means clearing out the iterator's shared reference while it exists,\n" +"and then reconstructing it. In most cases, that will still be less efficient than\n" "the C version." msgstr "" -"Per evitare ciò, dobbiamo avere un modo per garantire che il riferimento " -"mutabile sia davvero esclusivo.\n" -"Ciò significa sostanzialmente eliminare il riferimento condiviso " -"dell'iteratore mentre esiste,\n" -"e poi ricostruirlo. Nella maggior parte dei casi, sarà comunque meno " -"efficiente di\n" +"Per evitare ciò, dobbiamo avere un modo per garantire che il riferimento mutabile sia davvero esclusivo.\n" +"Ciò significa sostanzialmente eliminare il riferimento condiviso dell'iteratore mentre esiste,\n" +"e poi ricostruirlo. Nella maggior parte dei casi, sarà comunque meno efficiente di\n" "la versione C." #: src\patterns/ffi/wrappers.md:147 #, fuzzy msgid "" "Some may ask: how can C do this more efficiently?\n" -"The answer is, it cheats. Rust's aliasing rules are the problem, and C " -"simply ignores\n" -"them for its pointers. In exchange, it is common to see code that is " -"declared\n" -"in the manual as \"not thread safe\" under some or all circumstances. In " -"fact,\n" -"the [GNU C " -"library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"The answer is, it cheats. Rust's aliasing rules are the problem, and C simply ignores\n" +"them for its pointers. In exchange, it is common to see code that is declared\n" +"in the manual as \"not thread safe\" under some or all circumstances. In fact,\n" +"the [GNU C library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" "has an entire lexicon dedicated to concurrent behavior!" msgstr "" "Alcuni potrebbero chiedere: come può C farlo in modo più efficiente?\n" -"La risposta è che imbroglia. Le regole di aliasing di Rust sono il problema " -"e C semplicemente le ignora\n" -"loro per i suoi puntatori. In cambio, è comune vedere il codice che viene " -"dichiarato\n" -"nel manuale come \"non thread-safe\" in alcune o tutte le circostanze. " -"Infatti,\n" -"la [libreria GNU " -"C](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"La risposta è che imbroglia. Le regole di aliasing di Rust sono il problema e C semplicemente le ignora\n" +"loro per i suoi puntatori. In cambio, è comune vedere il codice che viene dichiarato\n" +"nel manuale come \"non thread-safe\" in alcune o tutte le circostanze. Infatti,\n" +"la [libreria GNU C](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" "ha un intero lessico dedicato al comportamento concorrente!" #: src\patterns/ffi/wrappers.md:154 #, fuzzy msgid "" -"Rust would rather make everything memory safe all the time, for both safety " -"and\n" -"optimizations that C code cannot attain. Being denied access to certain " -"shortcuts\n" +"Rust would rather make everything memory safe all the time, for both safety and\n" +"optimizations that C code cannot attain. Being denied access to certain shortcuts\n" "is the price Rust programmers need to pay." msgstr "" -"Rust preferirebbe rendere ogni memoria sempre al sicuro, sia per sicurezza " -"che per\n" -"ottimizzazioni che il codice C non può raggiungere. Viene negato l'accesso a " -"determinate scorciatoie\n" +"Rust preferirebbe rendere ogni memoria sempre al sicuro, sia per sicurezza che per\n" +"ottimizzazioni che il codice C non può raggiungere. Viene negato l'accesso a determinate scorciatoie\n" "è il prezzo che i programmatori di Rust devono pagare." #: src\patterns/ffi/wrappers.md:158 #, fuzzy msgid "" "For the C programmers out there scratching their heads, the iterator need\n" -"not be read _during_ this code cause the UB. The exclusivity rule also " -"enables\n" -"compiler optimizations which may cause inconsistent observations by the " -"iterator's\n" -"shared reference (e.g. stack spills or reordering instructions for " -"efficiency).\n" -"These observations may happen _any time after_ the mutable reference is " -"created." +"not be read _during_ this code cause the UB. The exclusivity rule also enables\n" +"compiler optimizations which may cause inconsistent observations by the iterator's\n" +"shared reference (e.g. stack spills or reordering instructions for efficiency).\n" +"These observations may happen _any time after_ the mutable reference is created." msgstr "" -"Per i programmatori C là fuori che si grattano la testa, l'iteratore ha " -"bisogno\n" -"non essere letto _durante_ questo codice causa l'UB. La regola di " -"esclusività consente anche\n" -"ottimizzazioni del compilatore che possono causare osservazioni incoerenti " -"da parte dell'iteratore\n" -"riferimento condiviso (ad es. stack spill o riordino delle istruzioni per " -"l'efficienza).\n" -"Queste osservazioni possono verificarsi _qualsiasi momento dopo_ la " -"creazione del riferimento mutabile." +"Per i programmatori C là fuori che si grattano la testa, l'iteratore ha bisogno\n" +"non essere letto _durante_ questo codice causa l'UB. La regola di esclusività consente anche\n" +"ottimizzazioni del compilatore che possono causare osservazioni incoerenti da parte dell'iteratore\n" +"riferimento condiviso (ad es. stack spill o riordino delle istruzioni per l'efficienza).\n" +"Queste osservazioni possono verificarsi _qualsiasi momento dopo_ la creazione del riferimento mutabile." #: src\anti_patterns/index.md:1 #, fuzzy @@ -7485,26 +6293,18 @@ msgstr "# Anti-modelli" #: src\anti_patterns/index.md:3 #, fuzzy msgid "" -"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution " -"to\n" +"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution to\n" "a \"recurring problem that is usually ineffective and risks being highly\n" "counterproductive\". Just as valuable as knowing how to solve a problem, is\n" -"knowing how _not_ to solve it. Anti-patterns give us great counter-examples " -"to\n" -"consider relative to design patterns. Anti-patterns are not confined to " -"code.\n" +"knowing how _not_ to solve it. Anti-patterns give us great counter-examples to\n" +"consider relative to design patterns. Anti-patterns are not confined to code.\n" "For example, a process can be an anti-pattern, too." msgstr "" -"Un [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) è una " -"soluzione a\n" -"un \"problema ricorrente che di solito è inefficace e rischia di essere " -"altamente\n" -"controproducente\". Altrettanto prezioso quanto sapere come risolvere un " -"problema, lo è\n" -"sapere come _non_ risolverlo. Gli anti-pattern ci forniscono ottimi " -"contro-esempi\n" -"considerare rispetto ai modelli di progettazione. Gli anti-pattern non sono " -"limitati al codice.\n" +"Un [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) è una soluzione a\n" +"un \"problema ricorrente che di solito è inefficace e rischia di essere altamente\n" +"controproducente\". Altrettanto prezioso quanto sapere come risolvere un problema, lo è\n" +"sapere come _non_ risolverlo. Gli anti-pattern ci forniscono ottimi contro-esempi\n" +"considerare rispetto ai modelli di progettazione. Gli anti-pattern non sono limitati al codice.\n" "Ad esempio, anche un processo può essere un anti-pattern." #: src\anti_patterns/borrow_clone.md:1 @@ -7515,24 +6315,16 @@ msgstr "# Clona per soddisfare il controllore del prestito" #: src\anti_patterns/borrow_clone.md:5 #, fuzzy msgid "" -"The borrow checker prevents Rust users from developing otherwise unsafe code " -"by\n" -"ensuring that either: only one mutable reference exists, or potentially many " -"but\n" -"all immutable references exist. If the code written does not hold true to " -"these\n" -"conditions, this anti-pattern arises when the developer resolves the " -"compiler\n" +"The borrow checker prevents Rust users from developing otherwise unsafe code by\n" +"ensuring that either: only one mutable reference exists, or potentially many but\n" +"all immutable references exist. If the code written does not hold true to these\n" +"conditions, this anti-pattern arises when the developer resolves the compiler\n" "error by cloning the variable." msgstr "" -"Il controllo del prestito impedisce agli utenti di Rust di sviluppare codice " -"altrimenti non sicuro\n" -"assicurando che: esista un solo riferimento mutabile, o potenzialmente molti " -"ma\n" -"esistono tutti i riferimenti immutabili. Se il codice scritto non è vero per " -"questi\n" -"condizioni, questo anti-pattern si verifica quando lo sviluppatore risolve " -"il compilatore\n" +"Il controllo del prestito impedisce agli utenti di Rust di sviluppare codice altrimenti non sicuro\n" +"assicurando che: esista un solo riferimento mutabile, o potenzialmente molti ma\n" +"esistono tutti i riferimenti immutabili. Se il codice scritto non è vero per questi\n" +"condizioni, questo anti-pattern si verifica quando lo sviluppatore risolve il compilatore\n" "errore clonando la variabile." #: src\anti_patterns/borrow_clone.md:13 @@ -7544,8 +6336,7 @@ msgid "" "// Borrow `x` -- but clone it first\n" "let y = &mut (x.clone());\n" "\n" -"// without the x.clone() two lines prior, this line would fail on compile " -"as\n" +"// without the x.clone() two lines prior, this line would fail on compile as\n" "// x has been borrowed\n" "// thanks to x.clone(), x was never borrowed, and this line will run.\n" "println!(\"{}\", x);\n" @@ -7561,49 +6352,36 @@ msgstr "" msgid "" "It is tempting, particularly for beginners, to use this pattern to resolve\n" "confusing issues with the borrow checker. However, there are serious\n" -"consequences. Using `.clone()` causes a copy of the data to be made. Any " -"changes\n" -"between the two are not synchronized -- as if two completely separate " -"variables\n" +"consequences. Using `.clone()` causes a copy of the data to be made. Any changes\n" +"between the two are not synchronized -- as if two completely separate variables\n" "exist." msgstr "" -"È allettante, in particolare per i principianti, utilizzare questo schema " -"per risolvere\n" -"problemi di confusione con il controllo del prestito. Tuttavia, ci sono " -"gravi\n" -"conseguenze. L'uso di `.clone()` provoca la creazione di una copia dei dati. " -"Eventuali modifiche\n" -"tra i due non sono sincronizzati -- come se due variabili completamente " -"separate\n" +"È allettante, in particolare per i principianti, utilizzare questo schema per risolvere\n" +"problemi di confusione con il controllo del prestito. Tuttavia, ci sono gravi\n" +"conseguenze. L'uso di `.clone()` provoca la creazione di una copia dei dati. Eventuali modifiche\n" +"tra i due non sono sincronizzati -- come se due variabili completamente separate\n" "esistere." #: src\anti_patterns/borrow_clone.md:38 #, fuzzy msgid "" -"There are special cases -- `Rc` is designed to handle clones " -"intelligently.\n" -"It internally manages exactly one copy of the data, and cloning it will " -"only\n" +"There are special cases -- `Rc` is designed to handle clones intelligently.\n" +"It internally manages exactly one copy of the data, and cloning it will only\n" "clone the reference." msgstr "" -"Ci sono casi speciali -- `Rc` è progettato per gestire i cloni in modo " -"intelligente.\n" -"Gestisce internamente esattamente una copia dei dati e la clonazione lo farà " -"solo\n" +"Ci sono casi speciali -- `Rc` è progettato per gestire i cloni in modo intelligente.\n" +"Gestisce internamente esattamente una copia dei dati e la clonazione lo farà solo\n" "clonare il riferimento." #: src\anti_patterns/borrow_clone.md:42 #, fuzzy msgid "" "There is also `Arc` which provides shared ownership of a value of type T\n" -"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new " -"`Arc`\n" -"instance, which points to the same allocation on the heap as the source " -"`Arc`,\n" +"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new `Arc`\n" +"instance, which points to the same allocation on the heap as the source `Arc`,\n" "while increasing a reference count." msgstr "" -"C'è anche `Arc` che fornisce la proprietà condivisa di un valore di tipo " -"T\n" +"C'è anche `Arc` che fornisce la proprietà condivisa di un valore di tipo T\n" "allocato nell'heap. Invocare `.clone()` su `Arc` produce un nuovo `Arc`\n" "istanza, che punta alla stessa allocazione sull'heap della sorgente `Arc`,\n" "durante l'aumento di un conteggio di riferimento." @@ -7615,12 +6393,9 @@ msgid "" "consequences. If a clone is used to make a borrow checker error disappear,\n" "that's a good indication this anti-pattern may be in use." msgstr "" -"In generale, i cloni dovrebbero essere deliberati, con piena comprensione " -"del\n" -"conseguenze. Se viene utilizzato un clone per far scomparire un errore di " -"verifica del prestito,\n" -"questa è una buona indicazione che questo anti-pattern potrebbe essere in " -"uso." +"In generale, i cloni dovrebbero essere deliberati, con piena comprensione del\n" +"conseguenze. Se viene utilizzato un clone per far scomparire un errore di verifica del prestito,\n" +"questa è una buona indicazione che questo anti-pattern potrebbe essere in uso." #: src\anti_patterns/borrow_clone.md:51 #, fuzzy @@ -7643,63 +6418,46 @@ msgstr "" "- lo sviluppatore è ancora nuovo alla proprietà\n" "- il codice non ha grandi velocità o vincoli di memoria\n" " (come progetti di hackathon o prototipi)\n" -"- soddisfare il controllore del prestito è davvero complicato e preferisci " -"farlo\n" +"- soddisfare il controllore del prestito è davvero complicato e preferisci farlo\n" " ottimizzare la leggibilità rispetto alle prestazioni" #: src\anti_patterns/borrow_clone.md:60 #, fuzzy msgid "" -"If an unnecessary clone is suspected, The [Rust Book's chapter on " -"Ownership](https://doc.rust-lang.org/book/ownership.html)\n" -"should be understood fully before assessing whether the clone is required or " -"not." +"If an unnecessary clone is suspected, The [Rust Book's chapter on Ownership](https://doc.rust-lang.org/book/ownership.html)\n" +"should be understood fully before assessing whether the clone is required or not." msgstr "" -"Se si sospetta un clone non necessario, il [capitolo sulla proprietà di Rust " -"Book](https://doc.rust-lang.org/book/ownership.html)\n" -"dovrebbe essere compreso appieno prima di valutare se il clone è necessario " -"o meno." +"Se si sospetta un clone non necessario, il [capitolo sulla proprietà di Rust Book](https://doc.rust-lang.org/book/ownership.html)\n" +"dovrebbe essere compreso appieno prima di valutare se il clone è necessario o meno." #: src\anti_patterns/borrow_clone.md:63 #, fuzzy msgid "" -"Also be sure to always run `cargo clippy` in your project, which will detect " -"some\n" -"cases in which `.clone()` is not necessary, like " -"[1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"Also be sure to always run `cargo clippy` in your project, which will detect some\n" +"cases in which `.clone()` is not necessary, like [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" "[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" -"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or " -"[4](https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref)." +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or [4](https://rust-lang.github.io/rust-clippy/master/index." +"html#clone_double_ref)." msgstr "" -"Assicurati anche di eseguire sempre `cargo clippy` nel tuo progetto, che ne " -"rileverà alcuni\n" -"casi in cui `.clone()` non è necessario, come " -"[1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"Assicurati anche di eseguire sempre `cargo clippy` nel tuo progetto, che ne rileverà alcuni\n" +"casi in cui `.clone()` non è necessario, come [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" "[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" -"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) o " -"[4](https://rust-lang.github.io/rust-clippy/master " -"/index.html#clone_double_ref)." +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) o [4](https://rust-lang.github.io/rust-clippy/master /index." +"html#clone_double_ref)." #: src\anti_patterns/borrow_clone.md:70 #, fuzzy msgid "" -"- [`mem::{take(_), replace(_)}` to keep owned values in changed " -"enums](../idioms/mem-replace.md)\n" -"- [`Rc` documentation, which handles .clone() " -"intelligently](http://doc.rust-lang.org/std/rc/)\n" -"- [`Arc` documentation, a thread-safe reference-counting " -"pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" -"- [Tricks with ownership in " -"Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" -msgstr "" -"- [`mem::{take(_), replace(_)}` per mantenere i valori di proprietà nelle " -"enum modificate](../idioms/mem-replace.md)\n" -"- [documentazione `Rc`, che gestisce .clone() in modo " -"intelligente](http://doc.rust-lang.org/std/rc/)\n" -"- [documentazione `Arc`, un puntatore thread-safe per il conteggio dei " -"riferimenti](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" -"- [Trucchi con la proprietà in " -"Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +"- [`mem::{take(_), replace(_)}` to keep owned values in changed enums](../idioms/mem-replace.md)\n" +"- [`Rc` documentation, which handles .clone() intelligently](http://doc.rust-lang.org/std/rc/)\n" +"- [`Arc` documentation, a thread-safe reference-counting pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" +"- [Tricks with ownership in Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +msgstr "" +"- [`mem::{take(_), replace(_)}` per mantenere i valori di proprietà nelle enum modificate](../idioms/mem-replace.md)\n" +"- [documentazione `Rc`, che gestisce .clone() in modo intelligente](http://doc.rust-lang.org/std/rc/)\n" +"- [documentazione `Arc`, un puntatore thread-safe per il conteggio dei riferimenti](https://doc.rust-lang.org/std/sync/struct.Arc." +"html)\n" +"- [Trucchi con la proprietà in Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" #: src\anti_patterns/deny-warnings.md:1 #, fuzzy @@ -7712,8 +6470,7 @@ msgid "" "A well-intentioned crate author wants to ensure their code builds without\n" "warnings. So they annotate their crate root with the following:" msgstr "" -"Un autore di casse ben intenzionato vuole assicurarsi che il proprio codice " -"venga compilato senza\n" +"Un autore di casse ben intenzionato vuole assicurarsi che il proprio codice venga compilato senza\n" "avvertimenti. Quindi annotano la loro radice di cassa con quanto segue:" #: src\anti_patterns/deny-warnings.md:10 @@ -7738,41 +6495,28 @@ msgstr "## Svantaggi" #: src\anti_patterns/deny-warnings.md:22 #, fuzzy msgid "" -"By disallowing the compiler to build with warnings, a crate author opts out " -"of\n" -"Rust's famed stability. Sometimes new features or old misfeatures need a " -"change\n" -"in how things are done, thus lints are written that `warn` for a certain " -"grace\n" +"By disallowing the compiler to build with warnings, a crate author opts out of\n" +"Rust's famed stability. Sometimes new features or old misfeatures need a change\n" +"in how things are done, thus lints are written that `warn` for a certain grace\n" "period before being turned to `deny`." msgstr "" -"Impedendo al compilatore di compilare con avvertimenti, un autore di crate " -"rinuncia\n" -"La famosa stabilità di Rust. A volte nuove funzionalità o vecchie " -"funzionalità errate richiedono un cambiamento\n" -"nel modo in cui si fanno le cose, così si scrive lanugine che 'avvertono' " -"per una certa grazia\n" +"Impedendo al compilatore di compilare con avvertimenti, un autore di crate rinuncia\n" +"La famosa stabilità di Rust. A volte nuove funzionalità o vecchie funzionalità errate richiedono un cambiamento\n" +"nel modo in cui si fanno le cose, così si scrive lanugine che 'avvertono' per una certa grazia\n" "periodo prima di essere trasformato in \"deny\"." #: src\anti_patterns/deny-warnings.md:27 #, fuzzy msgid "" -"For example, it was discovered that a type could have two `impl`s with the " -"same\n" -"method. This was deemed a bad idea, but in order to make the transition " -"smooth,\n" -"the `overlapping-inherent-impls` lint was introduced to give a warning to " -"those\n" +"For example, it was discovered that a type could have two `impl`s with the same\n" +"method. This was deemed a bad idea, but in order to make the transition smooth,\n" +"the `overlapping-inherent-impls` lint was introduced to give a warning to those\n" "stumbling on this fact, before it becomes a hard error in a future release." msgstr "" -"Ad esempio, è stato scoperto che un tipo potrebbe avere due `impl` con lo " -"stesso\n" -"metodo. Questa è stata considerata una cattiva idea, ma per facilitare la " -"transizione,\n" -"il lint `overlapping-inherent-impls` è stato introdotto per dare un " -"avvertimento a quelli\n" -"inciampando su questo fatto, prima che diventi un grave errore in una " -"versione futura." +"Ad esempio, è stato scoperto che un tipo potrebbe avere due `impl` con lo stesso\n" +"metodo. Questa è stata considerata una cattiva idea, ma per facilitare la transizione,\n" +"il lint `overlapping-inherent-impls` è stato introdotto per dare un avvertimento a quelli\n" +"inciampando su questo fatto, prima che diventi un grave errore in una versione futura." #: src\anti_patterns/deny-warnings.md:32 #, fuzzy @@ -7780,38 +6524,28 @@ msgid "" "Also sometimes APIs get deprecated, so their use will emit a warning where\n" "before there was none." msgstr "" -"Inoltre, a volte le API vengono deprecate, quindi il loro utilizzo emetterà " -"un avviso dove\n" +"Inoltre, a volte le API vengono deprecate, quindi il loro utilizzo emetterà un avviso dove\n" "prima non ce n'era nessuno." #: src\anti_patterns/deny-warnings.md:35 #, fuzzy -msgid "" -"All this conspires to potentially break the build whenever something changes." -msgstr "" -"Tutto ciò cospira potenzialmente per interrompere la build ogni volta che " -"qualcosa cambia." +msgid "All this conspires to potentially break the build whenever something changes." +msgstr "Tutto ciò cospira potenzialmente per interrompere la build ogni volta che qualcosa cambia." #: src\anti_patterns/deny-warnings.md:37 #, fuzzy msgid "" -"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can " -"no\n" +"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can no\n" "longer be used unless the annotation is removed. This is mitigated with\n" -"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all " -"`deny`\n" +"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all `deny`\n" "lint errors into warnings." msgstr "" -"Inoltre, le casse che forniscono pelucchi aggiuntivi (ad es. " -"[ruggine-clippy]) non possono\n" -"essere più utilizzato a meno che l'annotazione non venga rimossa. Questo è " -"mitigato con\n" -"[--cap-pelucchi]. L'argomento della riga di comando `--cap-lints=warn` " -"trasforma tutto in `deny`\n" +"Inoltre, le casse che forniscono pelucchi aggiuntivi (ad es. [ruggine-clippy]) non possono\n" +"essere più utilizzato a meno che l'annotazione non venga rimossa. Questo è mitigato con\n" +"[--cap-pelucchi]. L'argomento della riga di comando `--cap-lints=warn` trasforma tutto in `deny`\n" "errori di lint in avvisi." -#: src\anti_patterns/deny-warnings.md:42 -#: src\functional/generics-type-classes.md:227 +#: src\anti_patterns/deny-warnings.md:42 src\functional/generics-type-classes.md:227 #, fuzzy msgid "## Alternatives" msgstr "## Alternative" @@ -7819,23 +6553,18 @@ msgstr "## Alternative" #: src\anti_patterns/deny-warnings.md:44 #, fuzzy msgid "" -"There are two ways of tackling this problem: First, we can decouple the " -"build\n" +"There are two ways of tackling this problem: First, we can decouple the build\n" "setting from the code, and second, we can name the lints we want to deny\n" "explicitly." msgstr "" -"Ci sono due modi per affrontare questo problema: in primo luogo, possiamo " -"disaccoppiare la build\n" -"impostazione dal codice e, in secondo luogo, possiamo nominare i lint che " -"vogliamo negare\n" +"Ci sono due modi per affrontare questo problema: in primo luogo, possiamo disaccoppiare la build\n" +"impostazione dal codice e, in secondo luogo, possiamo nominare i lint che vogliamo negare\n" "esplicitamente." #: src\anti_patterns/deny-warnings.md:48 #, fuzzy msgid "The following command line will build with all warnings set to `deny`:" -msgstr "" -"La seguente riga di comando verrà compilata con tutti gli avvisi impostati " -"su \"deny\":" +msgstr "La seguente riga di comando verrà compilata con tutti gli avvisi impostati su \"deny\":" #: src\anti_patterns/deny-warnings.md:50 #, fuzzy @@ -7849,23 +6578,18 @@ msgid "" "Travis, but remember that this may break the build when something changes)\n" "without requiring a change to the code." msgstr "" -"Questo può essere fatto da qualsiasi singolo sviluppatore (o essere " -"impostato in uno strumento CI come\n" -"Travis, ma ricorda che questo potrebbe interrompere la build quando qualcosa " -"cambia)\n" +"Questo può essere fatto da qualsiasi singolo sviluppatore (o essere impostato in uno strumento CI come\n" +"Travis, ma ricorda che questo potrebbe interrompere la build quando qualcosa cambia)\n" "senza richiedere una modifica al codice." #: src\anti_patterns/deny-warnings.md:56 #, fuzzy msgid "" "Alternatively, we can specify the lints that we want to `deny` in the code.\n" -"Here is a list of warning lints that is (hopefully) safe to deny (as of " -"Rustc 1.48.0):" +"Here is a list of warning lints that is (hopefully) safe to deny (as of Rustc 1.48.0):" msgstr "" -"In alternativa, possiamo specificare i lint che vogliamo \"negare\" nel " -"codice.\n" -"Ecco un elenco di avvertenze che è (si spera) sicuro negare (a partire da " -"Rustc 1.48.0):" +"In alternativa, possiamo specificare i lint che vogliamo \"negare\" nel codice.\n" +"Ecco un elenco di avvertenze che è (si spera) sicuro negare (a partire da Rustc 1.48.0):" #: src\anti_patterns/deny-warnings.md:59 msgid "" @@ -7892,9 +6616,7 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:78 #, fuzzy msgid "In addition, the following `allow`ed lints may be a good idea to `deny`:" -msgstr "" -"Inoltre, i seguenti lint \"consentiti\" possono essere una buona idea da " -"\"negare\":" +msgstr "Inoltre, i seguenti lint \"consentiti\" possono essere una buona idea da \"negare\":" #: src\anti_patterns/deny-warnings.md:80 msgid "" @@ -7913,9 +6635,7 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:91 #, fuzzy msgid "Some may also want to add `missing-copy-implementations` to their list." -msgstr "" -"Alcuni potrebbero anche voler aggiungere `missing-copy-implementations` alla " -"loro lista." +msgstr "Alcuni potrebbero anche voler aggiungere `missing-copy-implementations` alla loro lista." #: src\anti_patterns/deny-warnings.md:93 #, fuzzy @@ -7923,25 +6643,21 @@ msgid "" "Note that we explicitly did not add the `deprecated` lint, as it is fairly\n" "certain that there will be more deprecated APIs in the future." msgstr "" -"Si noti che non abbiamo esplicitamente aggiunto il lint `deprecato`, poiché " -"è corretto\n" +"Si noti che non abbiamo esplicitamente aggiunto il lint `deprecato`, poiché è corretto\n" "certi che in futuro ci saranno più API obsolete." #: src\anti_patterns/deny-warnings.md:98 #, fuzzy msgid "" -"- [A collection of all clippy " -"lints](https://rust-lang.github.io/rust-clippy/master)\n" +"- [A collection of all clippy lints](https://rust-lang.github.io/rust-clippy/master)\n" "- [deprecate attribute] documentation\n" "- Type `rustc -W help` for a list of lints on your system. Also type\n" " `rustc --help` for a general list of options\n" "- [rust-clippy] is a collection of lints for better Rust code" msgstr "" -"- [Una raccolta di tutti i pelucchi " -"clippy](https://rust-lang.github.io/rust-clippy/master)\n" +"- [Una raccolta di tutti i pelucchi clippy](https://rust-lang.github.io/rust-clippy/master)\n" "- [attributo obsoleto] documentazione\n" -"- Digita `rustc -W help` per un elenco di lint sul tuo sistema. Digita " -"anche\n" +"- Digita `rustc -W help` per un elenco di lint sul tuo sistema. Digita anche\n" " `rustc --help` per un elenco generale di opzioni\n" "- [rust-clippy] è una raccolta di lanugine per migliorare il codice Rust" @@ -7953,19 +6669,16 @@ msgstr "# Polimorfismo `Deref`" #: src\anti_patterns/deref.md:5 #, fuzzy msgid "" -"Misuse the `Deref` trait to emulate inheritance between structs, and thus " -"reuse\n" +"Misuse the `Deref` trait to emulate inheritance between structs, and thus reuse\n" "methods." msgstr "" -"Usa in modo improprio il tratto `Deref` per emulare l'ereditarietà tra " -"struct e quindi riutilizzarlo\n" +"Usa in modo improprio il tratto `Deref` per emulare l'ereditarietà tra struct e quindi riutilizzarlo\n" "metodi." #: src\anti_patterns/deref.md:10 #, fuzzy msgid "" -"Sometimes we want to emulate the following common pattern from OO languages " -"such\n" +"Sometimes we want to emulate the following common pattern from OO languages such\n" "as Java:" msgstr "" "A volte vogliamo emulare il seguente modello comune da linguaggi OO come\n" @@ -8026,48 +6739,33 @@ msgstr "" #: src\anti_patterns/deref.md:56 #, fuzzy msgid "" -"There is no struct inheritance in Rust. Instead we use composition and " -"include\n" -"an instance of `Foo` in `Bar` (since the field is a value, it is stored " -"inline,\n" -"so if there were fields, they would have the same layout in memory as the " -"Java\n" +"There is no struct inheritance in Rust. Instead we use composition and include\n" +"an instance of `Foo` in `Bar` (since the field is a value, it is stored inline,\n" +"so if there were fields, they would have the same layout in memory as the Java\n" "version (probably, you should use `#[repr(C)]` if you want to be sure))." msgstr "" -"Non c'è ereditarietà struct in Rust. Usiamo invece composizione e " -"inclusione\n" -"un'istanza di `Foo` in `Bar` (poiché il campo è un valore, viene memorizzato " -"in linea,\n" +"Non c'è ereditarietà struct in Rust. Usiamo invece composizione e inclusione\n" +"un'istanza di `Foo` in `Bar` (poiché il campo è un valore, viene memorizzato in linea,\n" "quindi se ci fossero campi, avrebbero lo stesso layout in memoria di Java\n" "versione (probabilmente, dovresti usare `#[repr(C)]` se vuoi essere sicuro))." #: src\anti_patterns/deref.md:61 #, fuzzy msgid "" -"In order to make the method call work we implement `Deref` for `Bar` with " -"`Foo`\n" +"In order to make the method call work we implement `Deref` for `Bar` with `Foo`\n" "as the target (returning the embedded `Foo` field). That means that when we\n" -"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That " -"is\n" -"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, " -"here we\n" +"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That is\n" +"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, here we\n" "have two unrelated types. However, since the dot operator does implicit\n" -"dereferencing, it means that the method call will search for methods on " -"`Foo` as\n" +"dereferencing, it means that the method call will search for methods on `Foo` as\n" "well as `Bar`." msgstr "" -"Per far funzionare la chiamata al metodo, implementiamo `Deref` per `Bar` " -"con `Foo`\n" -"come destinazione (restituendo il campo `Foo` incorporato). Ciò significa " -"che quando noi\n" -"dereferenziare un `Bar` (ad esempio, utilizzando `*`), otterremo un `Foo`. " -"Questo è\n" -"abbastanza strano. La dereferenziazione di solito dà una \"T\" da un " -"riferimento a \"T\", qui noi\n" -"hanno due tipi non correlati. Tuttavia, poiché l'operatore punto fa " -"implicit\n" -"dereferenziando, significa che la chiamata al metodo cercherà i metodi su " -"`Foo` as\n" +"Per far funzionare la chiamata al metodo, implementiamo `Deref` per `Bar` con `Foo`\n" +"come destinazione (restituendo il campo `Foo` incorporato). Ciò significa che quando noi\n" +"dereferenziare un `Bar` (ad esempio, utilizzando `*`), otterremo un `Foo`. Questo è\n" +"abbastanza strano. La dereferenziazione di solito dà una \"T\" da un riferimento a \"T\", qui noi\n" +"hanno due tipi non correlati. Tuttavia, poiché l'operatore punto fa implicit\n" +"dereferenziando, significa che la chiamata al metodo cercherà i metodi su `Foo` as\n" "così come \"Bar\"." #: src\anti_patterns/deref.md:71 @@ -8089,136 +6787,97 @@ msgstr "" #: src\anti_patterns/deref.md:83 #, fuzzy msgid "" -"Most importantly this is a surprising idiom - future programmers reading " -"this in\n" -"code will not expect this to happen. That's because we are misusing the " -"`Deref`\n" -"trait rather than using it as intended (and documented, etc.). It's also " -"because\n" +"Most importantly this is a surprising idiom - future programmers reading this in\n" +"code will not expect this to happen. That's because we are misusing the `Deref`\n" +"trait rather than using it as intended (and documented, etc.). It's also because\n" "the mechanism here is completely implicit." msgstr "" -"La cosa più importante è che questo è un linguaggio sorprendente: i futuri " -"programmatori lo leggono\n" -"il codice non si aspetterà che ciò accada. Questo perché stiamo abusando del " -"`Deref`\n" -"tratto piuttosto che usarlo come previsto (e documentato, ecc.). È anche " -"perché\n" +"La cosa più importante è che questo è un linguaggio sorprendente: i futuri programmatori lo leggono\n" +"il codice non si aspetterà che ciò accada. Questo perché stiamo abusando del `Deref`\n" +"tratto piuttosto che usarlo come previsto (e documentato, ecc.). È anche perché\n" "il meccanismo qui è del tutto implicito." #: src\anti_patterns/deref.md:88 #, fuzzy msgid "" "This pattern does not introduce subtyping between `Foo` and `Bar` like\n" -"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` " -"are\n" -"not automatically implemented for `Bar`, so this pattern interacts badly " -"with\n" +"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` are\n" +"not automatically implemented for `Bar`, so this pattern interacts badly with\n" "bounds checking and thus generic programming." msgstr "" "Questo modello non introduce il sottotipo tra `Foo` e `Bar` come\n" -"l'ereditarietà in Java o C++ lo fa. Inoltre, i tratti implementati da " -"\"Foo\" lo sono\n" -"non implementato automaticamente per `Bar`, quindi questo modello " -"interagisce male con\n" +"l'ereditarietà in Java o C++ lo fa. Inoltre, i tratti implementati da \"Foo\" lo sono\n" +"non implementato automaticamente per `Bar`, quindi questo modello interagisce male con\n" "controllo dei limiti e quindi programmazione generica." #: src\anti_patterns/deref.md:93 #, fuzzy msgid "" -"Using this pattern gives subtly different semantics from most OO languages " -"with\n" -"regards to `self`. Usually it remains a reference to the sub-class, with " -"this\n" +"Using this pattern gives subtly different semantics from most OO languages with\n" +"regards to `self`. Usually it remains a reference to the sub-class, with this\n" "pattern it will be the 'class' where the method is defined." msgstr "" -"L'uso di questo modello fornisce una semantica leggermente diversa dalla " -"maggior parte dei linguaggi OO con\n" -"riguardo a \"sé\". Di solito rimane un riferimento alla sottoclasse, con " -"questo\n" +"L'uso di questo modello fornisce una semantica leggermente diversa dalla maggior parte dei linguaggi OO con\n" +"riguardo a \"sé\". Di solito rimane un riferimento alla sottoclasse, con questo\n" "pattern sarà la 'classe' in cui è definito il metodo." #: src\anti_patterns/deref.md:97 #, fuzzy msgid "" -"Finally, this pattern only supports single inheritance, and has no notion " -"of\n" -"interfaces, class-based privacy, or other inheritance-related features. So, " -"it\n" -"gives an experience that will be subtly surprising to programmers used to " -"Java\n" +"Finally, this pattern only supports single inheritance, and has no notion of\n" +"interfaces, class-based privacy, or other inheritance-related features. So, it\n" +"gives an experience that will be subtly surprising to programmers used to Java\n" "inheritance, etc." msgstr "" -"Infine, questo modello supporta solo l'ereditarietà singola e non ha alcuna " -"nozione di\n" -"interfacce, privacy basata su classi o altre funzionalità relative " -"all'ereditarietà. Quindi, esso\n" -"offre un'esperienza che sarà sottilmente sorprendente per i programmatori " -"abituati a Java\n" +"Infine, questo modello supporta solo l'ereditarietà singola e non ha alcuna nozione di\n" +"interfacce, privacy basata su classi o altre funzionalità relative all'ereditarietà. Quindi, esso\n" +"offre un'esperienza che sarà sottilmente sorprendente per i programmatori abituati a Java\n" "eredità, ecc." #: src\anti_patterns/deref.md:104 #, fuzzy msgid "" -"There is no one good alternative. Depending on the exact circumstances it " -"might\n" -"be better to re-implement using traits or to write out the facade methods " -"to\n" +"There is no one good alternative. Depending on the exact circumstances it might\n" +"be better to re-implement using traits or to write out the facade methods to\n" "dispatch to `Foo` manually. We do intend to add a mechanism for inheritance\n" "similar to this to Rust, but it is likely to be some time before it reaches\n" -"stable Rust. See these " -"[blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"stable Rust. See these [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" "[posts](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" -"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more " -"details." -msgstr "" -"Non esiste una buona alternativa. A seconda delle circostanze esatte " -"potrebbe\n" -"sarebbe meglio reimplementare usando i tratti o scrivere i metodi di " -"facciata a\n" -"invia a `Foo` manualmente. Intendiamo aggiungere un meccanismo per " -"l'ereditarietà\n" -"simile a questo per Rust, ma è probabile che ci voglia del tempo prima che " -"raggiunga\n" -"Ruggine stabile. Vedi questi " -"[blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more details." +msgstr "" +"Non esiste una buona alternativa. A seconda delle circostanze esatte potrebbe\n" +"sarebbe meglio reimplementare usando i tratti o scrivere i metodi di facciata a\n" +"invia a `Foo` manualmente. Intendiamo aggiungere un meccanismo per l'ereditarietà\n" +"simile a questo per Rust, ma è probabile che ci voglia del tempo prima che raggiunga\n" +"Ruggine stabile. Vedi questi [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" "[post](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" -"e questo [problema RFC](https://github.com/rust-lang/rfcs/issues/349) per " -"maggiori dettagli." +"e questo [problema RFC](https://github.com/rust-lang/rfcs/issues/349) per maggiori dettagli." #: src\anti_patterns/deref.md:112 #, fuzzy msgid "" -"The `Deref` trait is designed for the implementation of custom pointer " -"types.\n" +"The `Deref` trait is designed for the implementation of custom pointer types.\n" "The intention is that it will take a pointer-to-`T` to a `T`, not convert\n" "between different types. It is a shame that this isn't (probably cannot be)\n" "enforced by the trait definition." msgstr "" -"Il tratto `Deref` è progettato per l'implementazione di tipi di puntatore " -"personalizzati.\n" +"Il tratto `Deref` è progettato per l'implementazione di tipi di puntatore personalizzati.\n" "L'intenzione è che prenderà un puntatore a `T` in una `T`, non convertirà\n" -"tra tipi diversi. È un peccato che questo non sia (probabilmente non può " -"essere)\n" +"tra tipi diversi. È un peccato che questo non sia (probabilmente non può essere)\n" "imposto dalla definizione di tratto." #: src\anti_patterns/deref.md:117 #, fuzzy msgid "" -"Rust tries to strike a careful balance between explicit and implicit " -"mechanisms,\n" -"favouring explicit conversions between types. Automatic dereferencing in the " -"dot\n" -"operator is a case where the ergonomics strongly favour an implicit " -"mechanism,\n" +"Rust tries to strike a careful balance between explicit and implicit mechanisms,\n" +"favouring explicit conversions between types. Automatic dereferencing in the dot\n" +"operator is a case where the ergonomics strongly favour an implicit mechanism,\n" "but the intention is that this is limited to degrees of indirection, not\n" "conversion between arbitrary types." msgstr "" -"Rust cerca di trovare un attento equilibrio tra meccanismi espliciti e " -"impliciti,\n" -"favorendo conversioni esplicite tra i tipi. Dereferenziazione automatica nel " -"punto\n" -"operatore è un caso in cui l'ergonomia favorisce fortemente un meccanismo " -"implicito,\n" +"Rust cerca di trovare un attento equilibrio tra meccanismi espliciti e impliciti,\n" +"favorendo conversioni esplicite tra i tipi. Dereferenziazione automatica nel punto\n" +"operatore è un caso in cui l'ergonomia favorisce fortemente un meccanismo implicito,\n" "ma l'intenzione è che questo sia limitato a gradi di indirezione, no\n" "conversione tra tipi arbitrari." @@ -8226,18 +6885,14 @@ msgstr "" #, fuzzy msgid "" "- [Collections are smart pointers idiom](../idioms/deref.md).\n" -"- Delegation crates for less boilerplate like " -"[delegate](https://crates.io/crates/delegate)\n" +"- Delegation crates for less boilerplate like [delegate](https://crates.io/crates/delegate)\n" " or [ambassador](https://crates.io/crates/ambassador)\n" -"- [Documentation for `Deref` " -"trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." msgstr "" "- [Le raccolte sono idiomi di puntatori intelligenti](../idioms/deref.md).\n" -"- Casse di delega per meno boilerplate come " -"[delegate](https://crates.io/crates/delegate)\n" +"- Casse di delega per meno boilerplate come [delegate](https://crates.io/crates/delegate)\n" " o [ambasciatore](https://crates.io/crates/ambassador)\n" -"- [Documentazione per il tratto " -"`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentazione per il tratto `Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." #: src\functional/index.md:1 #, fuzzy @@ -8248,31 +6903,24 @@ msgstr "# Utilizzo funzionale di Rust" #, fuzzy msgid "" "Rust is an imperative language, but it follows many\n" -"[functional " -"programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." +"[functional programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." msgstr "" "Rust è un linguaggio imperativo, ma ne segue molti\n" -"[programmazione " -"funzionale](https://en.wikipedia.org/wiki/Functional_programming) paradigmi." +"[programmazione funzionale](https://en.wikipedia.org/wiki/Functional_programming) paradigmi." #: src\functional/index.md:6 #, fuzzy msgid "" -"> In computer science, _functional programming_ is a programming paradigm " -"where\n" +"> In computer science, _functional programming_ is a programming paradigm where\n" "> programs are constructed by applying and composing functions.\n" -"> It is a declarative programming paradigm in which function definitions " -"are\n" +"> It is a declarative programming paradigm in which function definitions are\n" "> trees of expressions that each return a value, rather than a sequence of\n" "> imperative statements which change the state of the program." msgstr "" -"> In informatica, la _programmazione funzionale_ è un paradigma di " -"programmazione in cui\n" +"> In informatica, la _programmazione funzionale_ è un paradigma di programmazione in cui\n" "> i programmi sono costruiti applicando e componendo funzioni.\n" -"> È un paradigma di programmazione dichiarativo in cui le definizioni di " -"funzione sono\n" -"> alberi di espressioni che restituiscono ciascuno un valore, piuttosto che " -"una sequenza di\n" +"> È un paradigma di programmazione dichiarativo in cui le definizioni di funzione sono\n" +"> alberi di espressioni che restituiscono ciascuno un valore, piuttosto che una sequenza di\n" "> affermazioni imperative che cambiano lo stato del programma." #: src\functional/paradigms.md:1 @@ -8288,12 +6936,9 @@ msgid "" "describe **how** to do something, whereas declarative programs describe\n" "**what** to do. Let's sum the numbers from 1 to 10 to show this." msgstr "" -"Uno dei maggiori ostacoli alla comprensione dei programmi funzionali in " -"arrivo\n" -"da uno sfondo imperativo è il cambiamento nel pensiero. Programmi " -"imperativi\n" -"descrivono **come** fare qualcosa, mentre i programmi dichiarativi " -"descrivono\n" +"Uno dei maggiori ostacoli alla comprensione dei programmi funzionali in arrivo\n" +"da uno sfondo imperativo è il cambiamento nel pensiero. Programmi imperativi\n" +"descrivono **come** fare qualcosa, mentre i programmi dichiarativi descrivono\n" "**cosa fare. Sommiamo i numeri da 1 a 10 per mostrarlo." #: src\functional/paradigms.md:8 @@ -8315,19 +6960,16 @@ msgstr "" #: src\functional/paradigms.md:18 #, fuzzy msgid "" -"With imperative programs, we have to play compiler to see what is " -"happening.\n" +"With imperative programs, we have to play compiler to see what is happening.\n" "Here, we start with a `sum` of `0`.\n" "Next, we iterate through the range from 1 to 10.\n" "Each time through the loop, we add the corresponding value in the range.\n" "Then we print it out." msgstr "" -"Con i programmi imperativi, dobbiamo giocare al compilatore per vedere cosa " -"sta succedendo.\n" +"Con i programmi imperativi, dobbiamo giocare al compilatore per vedere cosa sta succedendo.\n" "Qui, iniziamo con una \"somma\" di \"0\".\n" "Successivamente, iteriamo attraverso l'intervallo da 1 a 10.\n" -"Ogni volta attraverso il ciclo, aggiungiamo il valore corrispondente " -"nell'intervallo.\n" +"Ogni volta attraverso il ciclo, aggiungiamo il valore corrispondente nell'intervallo.\n" "Quindi lo stampiamo." #: src\functional/paradigms.md:24 @@ -8362,12 +7004,10 @@ msgstr "" #: src\functional/paradigms.md:37 #, fuzzy msgid "" -"This is how most of us start out programming. We learn that a program is a " -"set\n" +"This is how most of us start out programming. We learn that a program is a set\n" "of steps." msgstr "" -"Questo è il modo in cui la maggior parte di noi inizia a programmare. " -"Impariamo che un programma è un insieme\n" +"Questo è il modo in cui la maggior parte di noi inizia a programmare. Impariamo che un programma è un insieme\n" "di passi." #: src\functional/paradigms.md:40 @@ -8387,14 +7027,12 @@ msgstr "" msgid "" "Whoa! This is really different! What's going on here?\n" "Remember that with declarative programs we are describing **what** to do,\n" -"rather than **how** to do it. `fold` is a function that " -"[composes](https://en.wikipedia.org/wiki/Function_composition)\n" +"rather than **how** to do it. `fold` is a function that [composes](https://en.wikipedia.org/wiki/Function_composition)\n" "functions. The name is a convention from Haskell." msgstr "" "Ehi! Questo è davvero diverso! Cosa sta succedendo qui?\n" "Ricorda che con i programmi dichiarativi stiamo descrivendo **cosa** fare,\n" -"piuttosto che **come** farlo. `fold` è una funzione che " -"[compone](https://en.wikipedia.org/wiki/Function_composition)\n" +"piuttosto che **come** farlo. `fold` è una funzione che [compone](https://en.wikipedia.org/wiki/Function_composition)\n" "funzioni. Il nome è una convenzione di Haskell." #: src\functional/paradigms.md:51 @@ -8402,24 +7040,16 @@ msgstr "" msgid "" "Here, we are composing functions of addition (this closure: `|a, b| a + b`)\n" "with a range from 1 to 10. The `0` is the starting point, so `a` is `0` at\n" -"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the " -"result.\n" -"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the " -"next\n" -"result. This process continues until we get to the last element in the " -"range,\n" +"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the result.\n" +"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the next\n" +"result. This process continues until we get to the last element in the range,\n" "`10`." msgstr "" -"Qui stiamo componendo funzioni di addizione (questa chiusura: `|a, b| a + " -"b`)\n" -"con un intervallo da 1 a 10. Lo \"0\" è il punto di partenza, quindi \"a\" è " -"\"0\" a\n" -"Primo. \"b\" è il primo elemento dell'intervallo, \"1\". `0 + 1 = 1` è il " -"risultato.\n" -"Quindi ora `pieghiamo` di nuovo, con `a = 1`, `b = 2` e quindi `1 + 2 = 3` è " -"il prossimo\n" -"risultato. Questo processo continua finché non arriviamo all'ultimo elemento " -"dell'intervallo,\n" +"Qui stiamo componendo funzioni di addizione (questa chiusura: `|a, b| a + b`)\n" +"con un intervallo da 1 a 10. Lo \"0\" è il punto di partenza, quindi \"a\" è \"0\" a\n" +"Primo. \"b\" è il primo elemento dell'intervallo, \"1\". `0 + 1 = 1` è il risultato.\n" +"Quindi ora `pieghiamo` di nuovo, con `a = 1`, `b = 2` e quindi `1 + 2 = 3` è il prossimo\n" +"risultato. Questo processo continua finché non arriviamo all'ultimo elemento dell'intervallo,\n" "`10`." #: src\functional/paradigms.md:58 @@ -8459,24 +7089,16 @@ msgstr "# Generics come classi di tipo" #: src\functional/generics-type-classes.md:5 #, fuzzy msgid "" -"Rust's type system is designed more like functional languages (like " -"Haskell)\n" -"rather than imperative languages (like Java and C++). As a result, Rust can " -"turn\n" -"many kinds of programming problems into \"static typing\" problems. This is " -"one\n" -"of the biggest wins of choosing a functional language, and is critical to " -"many\n" +"Rust's type system is designed more like functional languages (like Haskell)\n" +"rather than imperative languages (like Java and C++). As a result, Rust can turn\n" +"many kinds of programming problems into \"static typing\" problems. This is one\n" +"of the biggest wins of choosing a functional language, and is critical to many\n" "of Rust's compile time guarantees." msgstr "" -"Il sistema di tipi di Rust è progettato più come linguaggi funzionali (come " -"Haskell)\n" -"piuttosto che linguaggi imperativi (come Java e C++). Di conseguenza, Rust " -"può trasformarsi\n" -"molti tipi di problemi di programmazione in problemi di \"tipizzazione " -"statica\". Questo è uno\n" -"delle più grandi vittorie nella scelta di un linguaggio funzionale ed è " -"fondamentale per molti\n" +"Il sistema di tipi di Rust è progettato più come linguaggi funzionali (come Haskell)\n" +"piuttosto che linguaggi imperativi (come Java e C++). Di conseguenza, Rust può trasformarsi\n" +"molti tipi di problemi di programmazione in problemi di \"tipizzazione statica\". Questo è uno\n" +"delle più grandi vittorie nella scelta di un linguaggio funzionale ed è fondamentale per molti\n" "delle garanzie di tempo di compilazione di Rust." #: src\functional/generics-type-classes.md:11 @@ -8484,141 +7106,104 @@ msgstr "" msgid "" "A key part of this idea is the way generic types work. In C++ and Java, for\n" "example, generic types are a meta-programming construct for the compiler.\n" -"`vector` and `vector` in C++ are just two different copies of " -"the\n" +"`vector` and `vector` in C++ are just two different copies of the\n" "same boilerplate code for a `vector` type (known as a `template`) with two\n" "different types filled in." msgstr "" -"Una parte fondamentale di questa idea è il modo in cui funzionano i tipi " -"generici. In C++ e Java, per\n" -"esempio, i tipi generici sono un costrutto di metaprogrammazione per il " -"compilatore.\n" +"Una parte fondamentale di questa idea è il modo in cui funzionano i tipi generici. In C++ e Java, per\n" +"esempio, i tipi generici sono un costrutto di metaprogrammazione per il compilatore.\n" "`vector` e `vector` in C++ sono solo due copie diverse di\n" -"stesso codice boilerplate per un tipo `vettoriale` (noto come `template`) " -"con due\n" +"stesso codice boilerplate per un tipo `vettoriale` (noto come `template`) con due\n" "diversi tipi compilati." #: src\functional/generics-type-classes.md:17 #, fuzzy msgid "" -"In Rust, a generic type parameter creates what is known in functional " -"languages\n" -"as a \"type class constraint\", and each different parameter filled in by an " -"end\n" -"user _actually changes the type_. In other words, `Vec` and " -"`Vec`\n" -"_are two different types_, which are recognized as distinct by all parts of " -"the\n" +"In Rust, a generic type parameter creates what is known in functional languages\n" +"as a \"type class constraint\", and each different parameter filled in by an end\n" +"user _actually changes the type_. In other words, `Vec` and `Vec`\n" +"_are two different types_, which are recognized as distinct by all parts of the\n" "type system." msgstr "" -"In Rust, un parametro di tipo generico crea ciò che è noto nei linguaggi " -"funzionali\n" -"come \"vincolo di classe di tipo\" e ogni diverso parametro riempito da una " -"fine\n" -"l'utente _effettivamente cambia il tipo_. In altre parole, `Vec` e " -"`Vec`\n" -"_sono due tipi diversi_, che sono riconosciuti come distinti da tutte le " -"parti del\n" +"In Rust, un parametro di tipo generico crea ciò che è noto nei linguaggi funzionali\n" +"come \"vincolo di classe di tipo\" e ogni diverso parametro riempito da una fine\n" +"l'utente _effettivamente cambia il tipo_. In altre parole, `Vec` e `Vec`\n" +"_sono due tipi diversi_, che sono riconosciuti come distinti da tutte le parti del\n" "sistema tipo." #: src\functional/generics-type-classes.md:23 #, fuzzy msgid "" "This is called **monomorphization**, where different types are created from\n" -"**polymorphic** code. This special behavior requires `impl` blocks to " -"specify\n" -"generic parameters. Different values for the generic type cause different " -"types,\n" +"**polymorphic** code. This special behavior requires `impl` blocks to specify\n" +"generic parameters. Different values for the generic type cause different types,\n" "and different types can have different `impl` blocks." msgstr "" "Questo è chiamato **monomorfizzazione**, da cui vengono creati diversi tipi\n" -"codice **polimorfico**. Questo comportamento speciale richiede la " -"specificazione dei blocchi \"impl\".\n" -"parametri generici. Valori diversi per il tipo generico causano tipi " -"diversi,\n" +"codice **polimorfico**. Questo comportamento speciale richiede la specificazione dei blocchi \"impl\".\n" +"parametri generici. Valori diversi per il tipo generico causano tipi diversi,\n" "e diversi tipi possono avere diversi blocchi `impl`." #: src\functional/generics-type-classes.md:28 #, fuzzy msgid "" -"In object-oriented languages, classes can inherit behavior from their " -"parents.\n" +"In object-oriented languages, classes can inherit behavior from their parents.\n" "However, this allows the attachment of not only additional behavior to\n" "particular members of a type class, but extra behavior as well." msgstr "" -"Nei linguaggi orientati agli oggetti, le classi possono ereditare il " -"comportamento dai loro genitori.\n" -"Tuttavia, ciò consente l'attaccamento non solo di comportamenti aggiuntivi " -"a\n" +"Nei linguaggi orientati agli oggetti, le classi possono ereditare il comportamento dai loro genitori.\n" +"Tuttavia, ciò consente l'attaccamento non solo di comportamenti aggiuntivi a\n" "membri particolari di una classe di tipo, ma anche un comportamento extra." #: src\functional/generics-type-classes.md:32 #, fuzzy msgid "" -"The nearest equivalent is the runtime polymorphism in Javascript and " -"Python,\n" +"The nearest equivalent is the runtime polymorphism in Javascript and Python,\n" "where new members can be added to objects willy-nilly by any constructor.\n" -"However, unlike those languages, all of Rust's additional methods can be " -"type\n" -"checked when they are used, because their generics are statically defined. " -"That\n" +"However, unlike those languages, all of Rust's additional methods can be type\n" +"checked when they are used, because their generics are statically defined. That\n" "makes them more usable while remaining safe." msgstr "" -"L'equivalente più vicino è il polimorfismo di runtime in Javascript e " -"Python,\n" -"dove i nuovi membri possono essere aggiunti agli oggetti volenti o nolenti " -"da qualsiasi costruttore.\n" -"Tuttavia, a differenza di questi linguaggi, tutti i metodi aggiuntivi di " -"Rust possono essere digitati\n" -"controllati quando vengono utilizzati, perché i loro generici sono definiti " -"staticamente. Quello\n" +"L'equivalente più vicino è il polimorfismo di runtime in Javascript e Python,\n" +"dove i nuovi membri possono essere aggiunti agli oggetti volenti o nolenti da qualsiasi costruttore.\n" +"Tuttavia, a differenza di questi linguaggi, tutti i metodi aggiuntivi di Rust possono essere digitati\n" +"controllati quando vengono utilizzati, perché i loro generici sono definiti staticamente. Quello\n" "li rende più utilizzabili pur rimanendo al sicuro." #: src\functional/generics-type-classes.md:40 #, fuzzy msgid "" "Suppose you are designing a storage server for a series of lab machines.\n" -"Because of the software involved, there are two different protocols you " -"need\n" +"Because of the software involved, there are two different protocols you need\n" "to support: BOOTP (for PXE network boot), and NFS (for remote mount storage)." msgstr "" -"Si supponga di progettare un server di archiviazione per una serie di " -"computer da laboratorio.\n" +"Si supponga di progettare un server di archiviazione per una serie di computer da laboratorio.\n" "A causa del software coinvolto, sono necessari due diversi protocolli\n" -"per supportare: BOOTP (per l'avvio di rete PXE) e NFS (per l'archiviazione " -"di montaggio remoto)." +"per supportare: BOOTP (per l'avvio di rete PXE) e NFS (per l'archiviazione di montaggio remoto)." #: src\functional/generics-type-classes.md:44 #, fuzzy msgid "" "Your goal is to have one program, written in Rust, which can handle both of\n" -"them. It will have protocol handlers and listen for both kinds of requests. " -"The\n" -"main application logic will then allow a lab administrator to configure " -"storage\n" +"them. It will have protocol handlers and listen for both kinds of requests. The\n" +"main application logic will then allow a lab administrator to configure storage\n" "and security controls for the actual files." msgstr "" -"Il tuo obiettivo è avere un programma, scritto in Rust, in grado di gestirli " -"entrambi\n" -"loro. Avrà gestori di protocollo e ascolterà entrambi i tipi di richieste. " -"IL\n" -"la logica dell'applicazione principale consentirà quindi a un amministratore " -"di laboratorio di configurare l'archiviazione\n" +"Il tuo obiettivo è avere un programma, scritto in Rust, in grado di gestirli entrambi\n" +"loro. Avrà gestori di protocollo e ascolterà entrambi i tipi di richieste. IL\n" +"la logica dell'applicazione principale consentirà quindi a un amministratore di laboratorio di configurare l'archiviazione\n" "e controlli di sicurezza per i file effettivi." #: src\functional/generics-type-classes.md:49 #, fuzzy msgid "" "The requests from machines in the lab for files contain the same basic\n" -"information, no matter what protocol they came from: an authentication " -"method,\n" +"information, no matter what protocol they came from: an authentication method,\n" "and a file name to retrieve. A straightforward implementation would look\n" "something like this:" msgstr "" -"Le richieste di file dalle macchine nel laboratorio contengono la stessa " -"base\n" -"informazioni, indipendentemente dal protocollo da cui provengono: un metodo " -"di autenticazione,\n" +"Le richieste di file dalle macchine nel laboratorio contengono la stessa base\n" +"informazioni, indipendentemente dal protocollo da cui provengono: un metodo di autenticazione,\n" "e un nome file da recuperare. Sembrerebbe un'implementazione semplice\n" "qualcosa come questo:" @@ -8642,29 +7227,23 @@ msgstr "" msgid "" "This design might work well enough. But now suppose you needed to support\n" "adding metadata that was _protocol specific_. For example, with NFS, you\n" -"wanted to determine what their mount point was in order to enforce " -"additional\n" +"wanted to determine what their mount point was in order to enforce additional\n" "security rules." msgstr "" -"Questo design potrebbe funzionare abbastanza bene. Ma ora supponiamo di aver " -"bisogno di supporto\n" +"Questo design potrebbe funzionare abbastanza bene. Ma ora supponiamo di aver bisogno di supporto\n" "aggiunta di metadati che erano _protocol specific_. Ad esempio, con NFS, tu\n" -"voleva determinare quale fosse il loro punto di montaggio per applicare " -"ulteriori\n" +"voleva determinare quale fosse il loro punto di montaggio per applicare ulteriori\n" "regole di sicurezza." #: src\functional/generics-type-classes.md:71 #, fuzzy msgid "" "The way the current struct is designed leaves the protocol decision until\n" -"runtime. That means any method that applies to one protocol and not the " -"other\n" +"runtime. That means any method that applies to one protocol and not the other\n" "requires the programmer to do a runtime check." msgstr "" -"Il modo in cui è progettata la struttura corrente lascia la decisione del " -"protocollo fino a quando\n" -"tempo di esecuzione. Ciò significa qualsiasi metodo che si applica a un " -"protocollo e non all'altro\n" +"Il modo in cui è progettata la struttura corrente lascia la decisione del protocollo fino a quando\n" +"tempo di esecuzione. Ciò significa qualsiasi metodo che si applica a un protocollo e non all'altro\n" "richiede al programmatore di eseguire un controllo di runtime." #: src\functional/generics-type-classes.md:75 @@ -8696,16 +7275,12 @@ msgstr "" #: src\functional/generics-type-classes.md:95 #, fuzzy msgid "" -"Every caller of `mount_point()` must check for `None` and write code to " -"handle\n" -"it. This is true even if they know only NFS requests are ever used in a " -"given\n" +"Every caller of `mount_point()` must check for `None` and write code to handle\n" +"it. This is true even if they know only NFS requests are ever used in a given\n" "code path!" msgstr "" -"Ogni chiamante di `mount_point()` deve verificare la presenza di `None` e " -"scrivere il codice da gestire\n" -"Esso. Questo è vero anche se sanno che solo le richieste NFS vengono " -"utilizzate in un dato dato\n" +"Ogni chiamante di `mount_point()` deve verificare la presenza di `None` e scrivere il codice da gestire\n" +"Esso. Questo è vero anche se sanno che solo le richieste NFS vengono utilizzate in un dato dato\n" "percorso del codice!" #: src\functional/generics-type-classes.md:99 @@ -8713,26 +7288,21 @@ msgstr "" msgid "" "It would be far more optimal to cause a compile-time error if the different\n" "request types were confused. After all, the entire path of the user's code,\n" -"including what functions from the library they use, will know whether a " -"request\n" +"including what functions from the library they use, will know whether a request\n" "is an NFS request or a BOOTP request." msgstr "" -"Sarebbe molto più ottimale causare un errore in fase di compilazione se il " -"diverso\n" -"i tipi di richiesta erano confusi. Dopo tutto, l'intero percorso del codice " -"dell'utente,\n" +"Sarebbe molto più ottimale causare un errore in fase di compilazione se il diverso\n" +"i tipi di richiesta erano confusi. Dopo tutto, l'intero percorso del codice dell'utente,\n" "comprese le funzioni della libreria che usano, sapranno se una richiesta\n" "è una richiesta NFS o una richiesta BOOTP." #: src\functional/generics-type-classes.md:104 #, fuzzy msgid "" -"In Rust, this is actually possible! The solution is to _add a generic type_ " -"in\n" +"In Rust, this is actually possible! The solution is to _add a generic type_ in\n" "order to split the API." msgstr "" -"In Rust, questo è effettivamente possibile! La soluzione è _aggiungere un " -"tipo generico_ in\n" +"In Rust, questo è effettivamente possibile! La soluzione è _aggiungere un tipo generico_ in\n" "per dividere l'API." #: src\functional/generics-type-classes.md:107 @@ -8849,63 +7419,47 @@ msgstr "" #: src\functional/generics-type-classes.md:206 #, fuzzy msgid "" -"They would get a syntax error. The type `FileDownloadRequest` does " -"not\n" -"implement `mount_point()`, only the type `FileDownloadRequest` does. " -"And\n" +"They would get a syntax error. The type `FileDownloadRequest` does not\n" +"implement `mount_point()`, only the type `FileDownloadRequest` does. And\n" "that is created by the NFS module, not the BOOTP module of course!" msgstr "" "Otterrebbero un errore di sintassi. Il tipo `FileDownloadRequest` no\n" -"implementa `mount_point()`, solo il tipo `FileDownloadRequest` lo fa. " -"E\n" +"implementa `mount_point()`, solo il tipo `FileDownloadRequest` lo fa. E\n" "creato dal modulo NFS, non dal modulo BOOTP ovviamente!" #: src\functional/generics-type-classes.md:212 #, fuzzy msgid "" -"First, it allows fields that are common to multiple states to be " -"de-duplicated.\n" +"First, it allows fields that are common to multiple states to be de-duplicated.\n" "By making the non-shared fields generic, they are implemented once." msgstr "" "Innanzitutto, consente di deduplicare i campi comuni a più stati.\n" -"Rendendo generici i campi non condivisi, questi vengono implementati una " -"volta." +"Rendendo generici i campi non condivisi, questi vengono implementati una volta." #: src\functional/generics-type-classes.md:215 #, fuzzy msgid "" -"Second, it makes the `impl` blocks easier to read, because they are broken " -"down\n" -"by state. Methods common to all states are typed once in one block, and " -"methods\n" +"Second, it makes the `impl` blocks easier to read, because they are broken down\n" +"by state. Methods common to all states are typed once in one block, and methods\n" "unique to one state are in a separate block." msgstr "" -"In secondo luogo, rende i blocchi `impl` più facili da leggere, perché sono " -"scomposti\n" -"per stato. I metodi comuni a tutti gli stati vengono digitati una volta in " -"un blocco e i metodi\n" +"In secondo luogo, rende i blocchi `impl` più facili da leggere, perché sono scomposti\n" +"per stato. I metodi comuni a tutti gli stati vengono digitati una volta in un blocco e i metodi\n" "univoci per uno stato si trovano in un blocco separato." #: src\functional/generics-type-classes.md:219 #, fuzzy -msgid "" -"Both of these mean there are fewer lines of code, and they are better " -"organized." -msgstr "" -"Entrambi significano che ci sono meno righe di codice e sono meglio " -"organizzati." +msgid "Both of these mean there are fewer lines of code, and they are better organized." +msgstr "Entrambi significano che ci sono meno righe di codice e sono meglio organizzati." #: src\functional/generics-type-classes.md:223 #, fuzzy msgid "" -"This currently increases the size of the binary, due to the way " -"monomorphization\n" -"is implemented in the compiler. Hopefully the implementation will be able " -"to\n" +"This currently increases the size of the binary, due to the way monomorphization\n" +"is implemented in the compiler. Hopefully the implementation will be able to\n" "improve in the future." msgstr "" -"Questo attualmente aumenta la dimensione del binario, a causa del modo in " -"cui monomorfizzazione\n" +"Questo attualmente aumenta la dimensione del binario, a causa del modo in cui monomorfizzazione\n" "è implementato nel compilatore. Speriamo che l'attuazione sarà in grado di\n" "migliorare in futuro." @@ -8916,14 +7470,11 @@ msgid "" " initialization, consider the\n" " [Builder Pattern](../patterns/creational/builder.md) instead.\n" "\n" -"- If the API between types does not change -- only the behavior does -- " -"then\n" -" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better " -"used\n" +"- If the API between types does not change -- only the behavior does -- then\n" +" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better used\n" " instead." msgstr "" -"- Se un tipo sembra aver bisogno di una \"split API\" a causa della " -"costruzione o parziale\n" +"- Se un tipo sembra aver bisogno di una \"split API\" a causa della costruzione o parziale\n" " inizializzazione, considerare il\n" " [Builder Pattern](../patterns/creational/builder.md) invece.\n" "\n" @@ -8939,109 +7490,79 @@ msgstr "Questo modello è utilizzato in tutta la libreria standard:" #: src\functional/generics-type-classes.md:241 #, fuzzy msgid "" -"- `Vec` can be cast from a String, unlike every other type of " -"`Vec`.[^1]\n" +"- `Vec` can be cast from a String, unlike every other type of `Vec`.[^1]\n" "- They can also be cast into a binary heap, but only if they contain a type\n" " that implements the `Ord` trait.[^2]\n" "- The `to_string` method was specialized for `Cow` only of type `str`.[^3]" msgstr "" -"- `Vec` può essere lanciato da una stringa, a differenza di ogni altro " -"tipo di `Vec`.[^1]\n" -"- Possono anche essere inseriti in un heap binario, ma solo se contengono un " -"tipo\n" +"- `Vec` può essere lanciato da una stringa, a differenza di ogni altro tipo di `Vec`.[^1]\n" +"- Possono anche essere inseriti in un heap binario, ma solo se contengono un tipo\n" " che implementa il tratto `Ord`.[^2]\n" "- Il metodo `to_string` era specializzato per `Cow` solo di tipo `str`.[^3]" #: src\functional/generics-type-classes.md:246 #, fuzzy msgid "It is also used by several popular crates to allow API flexibility:" -msgstr "" -"Viene anche utilizzato da diverse casse popolari per consentire la " -"flessibilità dell'API:" +msgstr "Viene anche utilizzato da diverse casse popolari per consentire la flessibilità dell'API:" #: src\functional/generics-type-classes.md:248 #, fuzzy msgid "" -"- The `embedded-hal` ecosystem used for embedded devices makes extensive use " -"of\n" -" this pattern. For example, it allows statically verifying the " -"configuration of\n" -" device registers used to control embedded pins. When a pin is put into a " -"mode,\n" +"- The `embedded-hal` ecosystem used for embedded devices makes extensive use of\n" +" this pattern. For example, it allows statically verifying the configuration of\n" +" device registers used to control embedded pins. When a pin is put into a mode,\n" " it returns a `Pin` struct, whose generic determines the functions\n" " usable in that mode, which are not on the `Pin` itself. [^4]\n" "\n" -"- The `hyper` HTTP client library uses this to expose rich APIs for " -"different\n" -" pluggable requests. Clients with different connectors have different " -"methods\n" +"- The `hyper` HTTP client library uses this to expose rich APIs for different\n" +" pluggable requests. Clients with different connectors have different methods\n" " on them as well as different trait implementations, while a core set of\n" " methods apply to any connector. [^5]\n" "\n" -"- The \"type state\" pattern -- where an object gains and loses API based on " -"an\n" -" internal state or invariant -- is implemented in Rust using the same " -"basic\n" +"- The \"type state\" pattern -- where an object gains and loses API based on an\n" +" internal state or invariant -- is implemented in Rust using the same basic\n" " concept, and a slightly different technique. [^6]" msgstr "" -"- L'ecosistema `embedded-hal` utilizzato per i dispositivi embedded fa ampio " -"uso di\n" -" questo modello. Ad esempio, consente di verificare staticamente la " -"configurazione di\n" -" registri del dispositivo utilizzati per controllare i pin incorporati. " -"Quando un pin viene messo in una modalità,\n" -" restituisce una struttura `Pin`, il cui generico determina le " -"funzioni\n" +"- L'ecosistema `embedded-hal` utilizzato per i dispositivi embedded fa ampio uso di\n" +" questo modello. Ad esempio, consente di verificare staticamente la configurazione di\n" +" registri del dispositivo utilizzati per controllare i pin incorporati. Quando un pin viene messo in una modalità,\n" +" restituisce una struttura `Pin`, il cui generico determina le funzioni\n" " utilizzabili in quella modalità, che non sono sul `Pin` stesso. [^4]\n" "\n" -"- La libreria client `hyper` HTTP utilizza questo per esporre ricche API per " -"diversi\n" -" richieste collegabili. I client con connettori diversi hanno metodi " -"diversi\n" -" su di essi così come diverse implementazioni di tratti, mentre un set di " -"base di\n" +"- La libreria client `hyper` HTTP utilizza questo per esporre ricche API per diversi\n" +" richieste collegabili. I client con connettori diversi hanno metodi diversi\n" +" su di essi così come diverse implementazioni di tratti, mentre un set di base di\n" " metodi si applicano a qualsiasi connettore. [^5]\n" "\n" -"- Il modello \"tipo stato\" -- in cui un oggetto guadagna e perde l'API in " -"base a un\n" -" stato interno o invariante -- è implementato in Rust usando la stessa " -"base\n" +"- Il modello \"tipo stato\" -- in cui un oggetto guadagna e perde l'API in base a un\n" +" stato interno o invariante -- è implementato in Rust usando la stessa base\n" " concetto e una tecnica leggermente diversa. [^6]" #: src\functional/generics-type-classes.md:263 #, fuzzy -msgid "" -"See: [impl From\\ for " -"Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" -msgstr "" -"Vedere: [impl From\\ for " -"Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 " -")" +msgid "See: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" +msgstr "Vedere: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 )" #: src\functional/generics-type-classes.md:265 #, fuzzy msgid "" -"See: [impl\\ From\\\\> for " -"BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/binary_heap.rs.html#1345-1354)" +"See: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/" +"binary_heap.rs.html#1345-1354)" msgstr "" -"Vedere: [impl\\ From\\\\> for " -"BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections " -"/binary_heap.rs.html#1345-1354)" +"Vedere: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections /" +"binary_heap.rs.html#1345-1354)" #: src\functional/generics-type-classes.md:267 #, fuzzy -msgid "" -"See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, " -"str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" -msgstr "" -"Vedi: [impl\\<'\\_\\> ToString for Cow\\<'\\_, " -"str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" +msgid "See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" +msgstr "Vedi: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" #: src\functional/generics-type-classes.md:269 #, fuzzy msgid "" "Example:\n" -"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html)" +"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/" +"gpioa/struct.PA0.html)" msgstr "" "Esempio:\n" "[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/ " @@ -9060,20 +7581,18 @@ msgstr "" #, fuzzy msgid "" "See:\n" -"[The Case for the Type State " -"Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate-pattern-the-typestate-pattern-itself/)\n" +"[The Case for the Type State Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-" +"typestate-pattern-the-typestate-pattern-itself/)\n" "and\n" -"[Rusty Typestate Series (an extensive " -"thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-typestate-series/rust-typestate-index)" +"[Rusty Typestate Series (an extensive thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index)" msgstr "" "Vedere:\n" -"[The Case for the Type State " -"Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate- " -"pattern-the-typestate-pattern-itself/)\n" +"[The Case for the Type State Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-" +"typestate- pattern-the-typestate-pattern-itself/)\n" "E\n" -"[Rusty Typestate Series (una tesi " -"estesa)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-typestate-series/rust-typestate-index " -")" +"[Rusty Typestate Series (una tesi estesa)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index )" #: src\functional/lenses.md:1 #, fuzzy @@ -9085,15 +7604,12 @@ msgstr "# Lenti e prismi" msgid "" "This is a pure functional concept that is not frequently used in Rust.\n" "Nevertheless, exploring the concept may be helpful to understand other\n" -"patterns in Rust APIs, such as " -"[visitors](../patterns/behavioural/visitor.md).\n" +"patterns in Rust APIs, such as [visitors](../patterns/behavioural/visitor.md).\n" "They also have niche use cases." msgstr "" -"Questo è un puro concetto funzionale che non viene usato frequentemente in " -"Rust.\n" +"Questo è un puro concetto funzionale che non viene usato frequentemente in Rust.\n" "Tuttavia, esplorare il concetto può essere utile per capirne altri\n" -"pattern nelle API di Rust, come " -"[visitors](../patterns/behavioural/visitor.md).\n" +"pattern nelle API di Rust, come [visitors](../patterns/behavioural/visitor.md).\n" "Hanno anche casi d'uso di nicchia." #: src\functional/lenses.md:8 @@ -9106,15 +7622,12 @@ msgstr "## Lenti: accesso uniforme tra i tipi" msgid "" "A lens is a concept from functional programming languages that allows\n" "accessing parts of a data type in an abstract, unified way.[^1]\n" -"In basic concept, it is similar to the way Rust traits work with type " -"erasure,\n" +"In basic concept, it is similar to the way Rust traits work with type erasure,\n" "but it has a bit more power and flexibility." msgstr "" -"Una lente è un concetto dei linguaggi di programmazione funzionale che " -"consente\n" +"Una lente è un concetto dei linguaggi di programmazione funzionale che consente\n" "accedere a parti di un tipo di dati in modo astratto e unificato.[^1]\n" -"Nel concetto di base, è simile al modo in cui i tratti di Rust funzionano " -"con la cancellazione del tipo,\n" +"Nel concetto di base, è simile al modo in cui i tratti di Rust funzionano con la cancellazione del tipo,\n" "ma ha un po' più di potenza e flessibilità." #: src\functional/lenses.md:15 @@ -9125,8 +7638,7 @@ msgid "" "This is because they come from different databases or legacy systems.\n" "One database contains the data needed to perform credit checks:" msgstr "" -"Ad esempio, supponiamo che una banca contenga diversi formati JSON per il " -"cliente\n" +"Ad esempio, supponiamo che una banca contenga diversi formati JSON per il cliente\n" "dati.\n" "Questo perché provengono da diversi database o sistemi legacy.\n" "Un database contiene i dati necessari per eseguire i controlli del credito:" @@ -9170,23 +7682,19 @@ msgstr "" #: src\functional/lenses.md:47 #, fuzzy msgid "" -"Notice that both types have a customer ID number which corresponds to a " -"person.\n" +"Notice that both types have a customer ID number which corresponds to a person.\n" "How would a single function handle both records of different types?" msgstr "" -"Si noti che entrambi i tipi hanno un numero ID cliente che corrisponde a una " -"persona.\n" +"Si noti che entrambi i tipi hanno un numero ID cliente che corrisponde a una persona.\n" "In che modo una singola funzione gestirà entrambi i record di tipi diversi?" #: src\functional/lenses.md:50 #, fuzzy msgid "" -"In Rust, a `struct` could represent each of these types, and a trait would " -"have\n" +"In Rust, a `struct` could represent each of these types, and a trait would have\n" "a `get_customer_id` function they would implement:" msgstr "" -"In Rust, una `struct` potrebbe rappresentare ciascuno di questi tipi e un " -"tratto lo farebbe\n" +"In Rust, una `struct` potrebbe rappresentare ciascuno di questi tipi e un tratto lo farebbe\n" "una funzione `get_customer_id` che implementerebbero:" #: src\functional/lenses.md:53 @@ -9233,8 +7741,7 @@ msgid "" " records.iter().map(|r| r.get_customer_id()).collect()\n" "}\n" "\n" -"// dynamic dispatch: iterates over any type with a customer ID, collecting " -"all\n" +"// dynamic dispatch: iterates over any type with a customer ID, collecting all\n" "// values together\n" "fn unique_ids_iter(iterator: I) -> HashSet\n" " where I: Iterator>\n" @@ -9252,26 +7759,20 @@ msgid "" "Rather than implementing a trait on each type, all matching structures can\n" "simply be accessed the same way." msgstr "" -"Le lenti, tuttavia, consentono di spostare il codice che supporta l'ID " -"cliente dal file\n" +"Le lenti, tuttavia, consentono di spostare il codice che supporta l'ID cliente dal file\n" "_type_ alla _funzione di accesso_.\n" -"Invece di implementare un tratto su ciascun tipo, tutte le strutture " -"corrispondenti possono farlo\n" +"Invece di implementare un tratto su ciascun tipo, tutte le strutture corrispondenti possono farlo\n" "essere semplicemente accessibile allo stesso modo." #: src\functional/lenses.md:109 #, fuzzy msgid "" "While the Rust language itself does not support this (type erasure is the\n" -"preferred solution to this problem), the [lens-rs " -"crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows " -"code\n" +"preferred solution to this problem), the [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows code\n" "that feels like this to be written with macros:" msgstr "" -"Anche se il linguaggio Rust stesso non lo supporta (la cancellazione del " -"tipo è il file\n" -"soluzione preferita a questo problema), il [lens-rs " -"crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) consente il " +"Anche se il linguaggio Rust stesso non lo supporta (la cancellazione del tipo è il file\n" +"soluzione preferita a questo problema), il [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) consente il " "codice\n" "che sembra così da scrivere con le macro:" @@ -9317,43 +7818,32 @@ msgstr "" #: src\functional/lenses.md:149 #, fuzzy msgid "" -"The version of `unique_ids_lens` shown here allows any type to be in the " -"iterator,\n" -"so long as it has an attribute called `customer_id` which can be accessed " -"by\n" +"The version of `unique_ids_lens` shown here allows any type to be in the iterator,\n" +"so long as it has an attribute called `customer_id` which can be accessed by\n" "the function.\n" "This is how most functional programming languages operate on lenses." msgstr "" -"La versione di `unique_ids_lens` mostrata qui consente a qualsiasi tipo di " -"essere nell'iteratore,\n" -"fintanto che ha un attributo chiamato `customer_id` a cui è possibile " -"accedere\n" +"La versione di `unique_ids_lens` mostrata qui consente a qualsiasi tipo di essere nell'iteratore,\n" +"fintanto che ha un attributo chiamato `customer_id` a cui è possibile accedere\n" "la funzione.\n" -"Questo è il modo in cui la maggior parte dei linguaggi di programmazione " -"funzionali opera sugli obiettivi." +"Questo è il modo in cui la maggior parte dei linguaggi di programmazione funzionali opera sugli obiettivi." #: src\functional/lenses.md:154 #, fuzzy msgid "" -"Rather than macros, they achieve this with a technique known as " -"\"currying\".\n" +"Rather than macros, they achieve this with a technique known as \"currying\".\n" "That is, they \"partially construct\" the function, leaving the type of the\n" -"final parameter (the value being operated on) unfilled until the function " -"is\n" +"final parameter (the value being operated on) unfilled until the function is\n" "called.\n" -"Thus it can be called with different types dynamically even from one place " -"in\n" +"Thus it can be called with different types dynamically even from one place in\n" "the code.\n" "That is what the `optics!` and `view_ref` in the example above simulates." msgstr "" -"Piuttosto che macro, ottengono questo risultato con una tecnica nota come " -"\"currying\".\n" +"Piuttosto che macro, ottengono questo risultato con una tecnica nota come \"currying\".\n" "Cioè, \"costruiscono parzialmente\" la funzione, lasciando il tipo di\n" -"parametro finale (il valore su cui si sta operando) vuoto finché la funzione " -"non lo è\n" +"parametro finale (il valore su cui si sta operando) vuoto finché la funzione non lo è\n" "chiamato.\n" -"Quindi può essere chiamato dinamicamente con tipi diversi anche da un posto " -"all'interno\n" +"Quindi può essere chiamato dinamicamente con tipi diversi anche da un posto all'interno\n" "il codice.\n" "Questo è ciò che simulano `optics!` e `view_ref` nell'esempio precedente." @@ -9363,16 +7853,14 @@ msgid "" "The functional approach need not be restricted to accessing members.\n" "More powerful lenses can be created which both _set_ and _get_ data in a\n" "structure.\n" -"But the concept really becomes interesting when used as a building block " -"for\n" +"But the concept really becomes interesting when used as a building block for\n" "composition.\n" "That is where the concept appears more clearly in Rust." msgstr "" "L'approccio funzionale non deve essere limitato all'accesso ai membri.\n" "È possibile creare lenti più potenti che sia _set_ che _get_ dati in a\n" "struttura.\n" -"Ma il concetto diventa davvero interessante se usato come elemento " -"costitutivo per\n" +"Ma il concetto diventa davvero interessante se usato come elemento costitutivo per\n" "composizione.\n" "È qui che il concetto appare più chiaramente in Rust." @@ -9384,20 +7872,16 @@ msgstr "## Prismi: una forma di \"ottica\" di ordine superiore" #: src\functional/lenses.md:171 #, fuzzy msgid "" -"A simple function such as `unique_ids_lens` above operates on a single " -"lens.\n" +"A simple function such as `unique_ids_lens` above operates on a single lens.\n" "A _prism_ is a function that operates on a _family_ of lenses.\n" "It is one conceptual level higher, using lenses as a building block, and\n" "continuing the metaphor, is part of a family of \"optics\".\n" -"It is the main one that is useful in understanding Rust APIs, so will be " -"the\n" +"It is the main one that is useful in understanding Rust APIs, so will be the\n" "focus here." msgstr "" -"Una semplice funzione come `unique_ids_lens` sopra opera su un singolo " -"obiettivo.\n" +"Una semplice funzione come `unique_ids_lens` sopra opera su un singolo obiettivo.\n" "Un _prisma_ è una funzione che opera su una _famiglia_ di lenti.\n" -"È un livello concettuale più alto, usando le lenti come elemento " -"costitutivo, e\n" +"È un livello concettuale più alto, usando le lenti come elemento costitutivo, e\n" "continuando la metafora, fa parte di una famiglia di \"ottiche\".\n" "È il principale utile per comprendere le API di Rust, così come lo sarà il\n" "concentrati qui." @@ -9405,17 +7889,13 @@ msgstr "" #: src\functional/lenses.md:178 #, fuzzy msgid "" -"The same way that traits allow \"lens-like\" design with static polymorphism " -"and\n" -"dynamic dispatch, prism-like designs appear in Rust APIs which split " -"problems\n" +"The same way that traits allow \"lens-like\" design with static polymorphism and\n" +"dynamic dispatch, prism-like designs appear in Rust APIs which split problems\n" "into multiple associated types to be composed.\n" "A good example of this is the traits in the parsing crate _Serde_." msgstr "" -"Allo stesso modo in cui i tratti consentono un design \"simile a una lente\" " -"con polimorfismo statico e\n" -"invio dinamico, i design simili a prismi appaiono nelle API di Rust che " -"suddividono i problemi\n" +"Allo stesso modo in cui i tratti consentono un design \"simile a una lente\" con polimorfismo statico e\n" +"invio dinamico, i design simili a prismi appaiono nelle API di Rust che suddividono i problemi\n" "in più tipi associati da comporre.\n" "Un buon esempio di ciò sono i tratti nella cassa di analisi _Serde_." @@ -9429,8 +7909,7 @@ msgid "" msgstr "" "Cercare di capire il modo in cui funziona _Serde_ leggendo solo l'API è un\n" "sfida, soprattutto la prima volta.\n" -"Considera il tratto `Deserializer`, implementato da qualche tipo in " -"qualsiasi libreria\n" +"Considera il tratto `Deserializer`, implementato da qualche tipo in qualsiasi libreria\n" "che analizza un nuovo formato:" #: src\functional/lenses.md:188 @@ -9439,13 +7918,11 @@ msgid "" "pub trait Deserializer<'de>: Sized {\n" " type Error: Error;\n" "\n" -" fn deserialize_any(self, visitor: V) -> Result\n" +" fn deserialize_any(self, visitor: V) -> Result\n" " where\n" " V: Visitor<'de>;\n" "\n" -" fn deserialize_bool(self, visitor: V) -> Result\n" +" fn deserialize_bool(self, visitor: V) -> Result\n" " where\n" " V: Visitor<'de>;\n" "\n" @@ -9460,8 +7937,7 @@ msgid "" "For a trait that is just supposed to parse data from a format and return a\n" "value, this looks odd." msgstr "" -"Per un tratto che dovrebbe solo analizzare i dati da un formato e restituire " -"a\n" +"Per un tratto che dovrebbe solo analizzare i dati da un formato e restituire a\n" "valore, questo sembra strano." #: src\functional/lenses.md:207 @@ -9504,12 +7980,10 @@ msgstr "" #: src\functional/lenses.md:232 #, fuzzy msgid "" -"The job of the `Visitor` type is to construct values in the _Serde_ data " -"model,\n" +"The job of the `Visitor` type is to construct values in the _Serde_ data model,\n" "which are represented by its associated `Value` type." msgstr "" -"Il compito del tipo `Visitor` è costruire valori nel modello di dati " -"_Serde_,\n" +"Il compito del tipo `Visitor` è costruire valori nel modello di dati _Serde_,\n" "che sono rappresentati dal tipo \"Valore\" associato." #: src\functional/lenses.md:235 @@ -9519,41 +7993,31 @@ msgid "" "If this fails, it returns an `Error` type - an error type determined by the\n" "`Deserializer` when its methods were called." msgstr "" -"Questi valori rappresentano parti del valore Rust che vengono " -"deserializzate.\n" -"Se fallisce, restituisce un tipo `Error` - un tipo di errore determinato dal " -"file\n" +"Questi valori rappresentano parti del valore Rust che vengono deserializzate.\n" +"Se fallisce, restituisce un tipo `Error` - un tipo di errore determinato dal file\n" "`Deserializer` quando sono stati chiamati i suoi metodi." #: src\functional/lenses.md:239 #, fuzzy msgid "" -"This highlights that `Deserializer` is similar to `CustomerId` from " -"earlier,\n" -"allowing any format parser which implements it to create `Value`s based on " -"what\n" +"This highlights that `Deserializer` is similar to `CustomerId` from earlier,\n" +"allowing any format parser which implements it to create `Value`s based on what\n" "it parsed.\n" "The `Value` trait is acting like a lens in functional programming languages." msgstr "" "Ciò evidenzia che \"Deserializer\" è simile a \"CustomerId\" di prima,\n" -"consentendo a qualsiasi parser di formato che lo implementa di creare " -"`Valori` in base a cosa\n" +"consentendo a qualsiasi parser di formato che lo implementa di creare `Valori` in base a cosa\n" "ha analizzato.\n" -"Il tratto \"Valore\" agisce come una lente nei linguaggi di programmazione " -"funzionale." +"Il tratto \"Valore\" agisce come una lente nei linguaggi di programmazione funzionale." #: src\functional/lenses.md:244 #, fuzzy msgid "" -"But unlike the `CustomerId` trait, the return types of `Visitor` methods " -"are\n" -"_generic_, and the concrete `Value` type is _determined by the Visitor " -"itself_." +"But unlike the `CustomerId` trait, the return types of `Visitor` methods are\n" +"_generic_, and the concrete `Value` type is _determined by the Visitor itself_." msgstr "" -"Ma a differenza del tratto `CustomerId`, i tipi restituiti dei metodi " -"`Visitor` lo sono\n" -"_generico_, e il tipo `Valore` concreto è _determinato dal Visitatore " -"stesso_." +"Ma a differenza del tratto `CustomerId`, i tipi restituiti dei metodi `Visitor` lo sono\n" +"_generico_, e il tipo `Valore` concreto è _determinato dal Visitatore stesso_." #: src\functional/lenses.md:247 #, fuzzy @@ -9567,13 +8031,11 @@ msgstr "" #: src\functional/lenses.md:250 #, fuzzy msgid "" -"The `Deserializer` API is based on having a generic set of \"lenses\" work " -"across\n" +"The `Deserializer` API is based on having a generic set of \"lenses\" work across\n" "a set of other generic types for \"observation\".\n" "It is a _prism_." msgstr "" -"L'API `Deserializer` si basa sull'utilizzo di un insieme generico di " -"\"lenti\".\n" +"L'API `Deserializer` si basa sull'utilizzo di un insieme generico di \"lenti\".\n" "un insieme di altri tipi generici per \"osservazione\".\n" "È un _prisma_." @@ -9593,45 +8055,34 @@ msgstr "" #: src\functional/lenses.md:262 #, fuzzy -msgid "" -"How would the _Serde_ library deserialize this JSON into `struct " -"CreditRecord`?" -msgstr "" -"In che modo la libreria _Serde_ deserializzerebbe questo JSON in \"struct " -"CreditRecord\"?" +msgid "How would the _Serde_ library deserialize this JSON into `struct CreditRecord`?" +msgstr "In che modo la libreria _Serde_ deserializzerebbe questo JSON in \"struct CreditRecord\"?" #: src\functional/lenses.md:264 #, fuzzy msgid "" -"1. The user would call a library function to deserialize the data. This " -"would\n" +"1. The user would call a library function to deserialize the data. This would\n" " create a `Deserializer` based on the JSON format.\n" "1. Based on the fields in the struct, a `Visitor` would be created (more on\n" " that in a moment) which knows how to create each type in a generic data\n" " model that was needed to represent it: `u64` and `String`.\n" "1. The deserializer would make calls to the `Visitor` as it parsed items.\n" -"1. The `Visitor` would indicate if the items found were expected, and if " -"not,\n" +"1. The `Visitor` would indicate if the items found were expected, and if not,\n" " raise an error to indicate deserialization has failed." msgstr "" -"1. L'utente chiamerebbe una funzione di libreria per deserializzare i dati. " -"Questo sarebbe\n" +"1. L'utente chiamerebbe una funzione di libreria per deserializzare i dati. Questo sarebbe\n" " creare un \"Deserializer\" basato sul formato JSON.\n" -"1. Sulla base dei campi nella struttura, verrebbe creato un \"Visitatore\" " -"(maggiori informazioni su\n" +"1. Sulla base dei campi nella struttura, verrebbe creato un \"Visitatore\" (maggiori informazioni su\n" " che in un attimo) che sa creare ogni tipo in un dato generico\n" " modello necessario per rappresentarlo: `u64` e `String`.\n" -"1. Il deserializzatore effettuerebbe chiamate al \"Visitatore\" durante " -"l'analisi degli elementi.\n" -"1. Il \"Visitatore\" indicherebbe se gli elementi trovati erano attesi e, in " -"caso contrario,\n" +"1. Il deserializzatore effettuerebbe chiamate al \"Visitatore\" durante l'analisi degli elementi.\n" +"1. Il \"Visitatore\" indicherebbe se gli elementi trovati erano attesi e, in caso contrario,\n" " genera un errore per indicare che la deserializzazione non è riuscita." #: src\functional/lenses.md:273 #, fuzzy msgid "For our very simple structure above, the expected pattern would be:" -msgstr "" -"Per la nostra struttura molto semplice sopra, il modello previsto sarebbe:" +msgstr "Per la nostra struttura molto semplice sopra, il modello previsto sarebbe:" #: src\functional/lenses.md:275 #, fuzzy @@ -9643,8 +8094,7 @@ msgid "" "1. Visit a string value, which will go into the `customer_id` field.\n" "1. Visit the end of the map." msgstr "" -"1. Visita una mappa (l'equivalente di _Serde_ a `HashMap` o il dizionario di " -"JSON).\n" +"1. Visita una mappa (l'equivalente di _Serde_ a `HashMap` o il dizionario di JSON).\n" "1. Visita una chiave di stringa chiamata \"nome\".\n" "1. Visita un valore stringa, che andrà nel campo `name`.\n" "1. Visita una chiave stringa chiamata \"customer_id\".\n" @@ -9664,8 +8114,7 @@ msgid "" "Rust does not support that, so every single type would need to have its own\n" "code written based on its fields and their properties." msgstr "" -"Un linguaggio di programmazione funzionale sarebbe in grado di utilizzare il " -"currying per creare\n" +"Un linguaggio di programmazione funzionale sarebbe in grado di utilizzare il currying per creare\n" "riflesso di ogni tipo in base al tipo stesso.\n" "Rust non lo supporta, quindi ogni singolo tipo dovrebbe averne uno proprio\n" "codice scritto in base ai suoi campi e alle loro proprietà." @@ -9694,8 +8143,7 @@ msgid "" "That macro simply generates an impl block causing the struct to implement a\n" "trait called `Deserialize`." msgstr "" -"Quella macro genera semplicemente un blocco impl che fa sì che la struct " -"implementi a\n" +"Quella macro genera semplicemente un blocco impl che fa sì che la struct implementi a\n" "tratto chiamato \"Deserialize\"." #: src\functional/lenses.md:304 @@ -9719,23 +8167,20 @@ msgstr "" msgid "" "This is the function that determines how to create the struct itself.\n" "Code is generated based on the struct's fields.\n" -"When the parsing library is called - in our example, a JSON parsing library " -"-\n" +"When the parsing library is called - in our example, a JSON parsing library -\n" "it creates a `Deserializer` and calls `Type::deserialize` with it as a\n" "parameter." msgstr "" "Questa è la funzione che determina come creare la struttura stessa.\n" "Il codice viene generato in base ai campi della struttura.\n" -"Quando viene chiamata la libreria di analisi, nel nostro esempio una " -"libreria di analisi JSON,\n" +"Quando viene chiamata la libreria di analisi, nel nostro esempio una libreria di analisi JSON,\n" "crea un \"Deserializer\" e chiama \"Type::deserialize\" con esso come a\n" "parametro." #: src\functional/lenses.md:320 #, fuzzy msgid "" -"The `deserialize` code will then create a `Visitor` which will have its " -"calls\n" +"The `deserialize` code will then create a `Visitor` which will have its calls\n" "\"refracted\" by the `Deserializer`.\n" "If everything goes well, eventually that `Visitor` will construct a value\n" "corresponding to the type being parsed and return it." @@ -9747,12 +8192,8 @@ msgstr "" #: src\functional/lenses.md:325 #, fuzzy -msgid "" -"For a complete example, see the [_Serde_ " -"documentation](https://serde.rs/deserialize-struct.html)." -msgstr "" -"Per un esempio completo, consulta la " -"[documentazione_Serde_](https://serde.rs/deserialize-struct.html)." +msgid "For a complete example, see the [_Serde_ documentation](https://serde.rs/deserialize-struct.html)." +msgstr "Per un esempio completo, consulta la [documentazione_Serde_](https://serde.rs/deserialize-struct.html)." #: src\functional/lenses.md:327 #, fuzzy @@ -9762,74 +8203,56 @@ msgstr "Per concludere, questo è il potere di _Serde_:" #: src\functional/lenses.md:329 #, fuzzy msgid "" -"1. The structure being parsed is represented by an `impl` block for " -"`Deserialize`\n" -"1. The input data format (e.g. JSON) is represented by a `Deserializer` " -"called\n" +"1. The structure being parsed is represented by an `impl` block for `Deserialize`\n" +"1. The input data format (e.g. JSON) is represented by a `Deserializer` called\n" " by `Deserialize`\n" -"1. The `Deserializer` acts like a prism which \"refracts\" lens-like " -"`Visitor`\n" +"1. The `Deserializer` acts like a prism which \"refracts\" lens-like `Visitor`\n" " calls which actually build the data value" msgstr "" -"1. La struttura analizzata è rappresentata da un blocco `impl` per " -"`Deserialize`\n" -"1. Il formato dei dati di input (ad es. JSON) è rappresentato da un " -"`Deserializzatore` chiamato\n" +"1. La struttura analizzata è rappresentata da un blocco `impl` per `Deserialize`\n" +"1. Il formato dei dati di input (ad es. JSON) è rappresentato da un `Deserializzatore` chiamato\n" " da \"Deserializzare\".\n" -"1. Il \"Deserializzatore\" agisce come un prisma che \"rifrange\" il " -"\"Visitatore\" simile a una lente\n" +"1. Il \"Deserializzatore\" agisce come un prisma che \"rifrange\" il \"Visitatore\" simile a una lente\n" " chiamate che effettivamente costruiscono il valore dei dati" #: src\functional/lenses.md:335 #, fuzzy msgid "" -"The result is that types to be deserialized only implement the \"top layer\" " -"of\n" +"The result is that types to be deserialized only implement the \"top layer\" of\n" "the API, and file formats only need to implement the \"bottom layer\".\n" -"Each piece can then \"just work\" with the rest of the ecosystem, since " -"generic\n" +"Each piece can then \"just work\" with the rest of the ecosystem, since generic\n" "types will bridge them." msgstr "" -"Il risultato è che i tipi da deserializzare implementano solo il \"livello " -"superiore\" di\n" -"l'API e i formati di file devono solo implementare il \"livello " -"inferiore\".\n" -"Ogni pezzo può quindi \"funzionare semplicemente\" con il resto " -"dell'ecosistema, poiché generico\n" +"Il risultato è che i tipi da deserializzare implementano solo il \"livello superiore\" di\n" +"l'API e i formati di file devono solo implementare il \"livello inferiore\".\n" +"Ogni pezzo può quindi \"funzionare semplicemente\" con il resto dell'ecosistema, poiché generico\n" "i tipi li collegheranno." #: src\functional/lenses.md:340 #, fuzzy msgid "" -"To emphasize, the only reason this model works on any format and any type " -"is\n" +"To emphasize, the only reason this model works on any format and any type is\n" "because the `Deserializer` trait's output type **is specified by the\n" -"implementor of `Visitor` it is passed**, rather than being tied to one " -"specific\n" +"implementor of `Visitor` it is passed**, rather than being tied to one specific\n" "type.\n" "This was not true in the account example earlier." msgstr "" -"Per sottolineare, l'unico motivo per cui questo modello funziona su " -"qualsiasi formato e qualsiasi tipo è\n" +"Per sottolineare, l'unico motivo per cui questo modello funziona su qualsiasi formato e qualsiasi tipo è\n" "perché il tipo di output del tratto `Deserializer` **è specificato da\n" -"implementatore di `Visitor` viene passato**, piuttosto che essere legato a " -"uno specifico\n" +"implementatore di `Visitor` viene passato**, piuttosto che essere legato a uno specifico\n" "tipo.\n" "Questo non era vero nell'esempio dell'account precedente." #: src\functional/lenses.md:346 #, fuzzy msgid "" -"Rust's generic-inspired type system can bring it close to these concepts " -"and\n" +"Rust's generic-inspired type system can bring it close to these concepts and\n" "use their power, as shown in this API design.\n" "But it may also need procedural macros to create bridges for its generics." msgstr "" -"Il sistema di tipi di ispirazione generica di Rust può avvicinarlo a questi " -"concetti e\n" +"Il sistema di tipi di ispirazione generica di Rust può avvicinarlo a questi concetti e\n" "usa il loro potere, come mostrato in questo progetto API.\n" -"Ma potrebbe anche aver bisogno di macro procedurali per creare ponti per i " -"suoi generici." +"Ma potrebbe anche aver bisogno di macro procedurali per creare ponti per i suoi generici." #: src\functional/lenses.md:350 #, fuzzy @@ -9841,53 +8264,40 @@ msgstr "## Guarda anche" msgid "" "- [lens-rs crate](https://crates.io/crates/lens-rs) for a pre-built lenses\n" " implementation, with a cleaner interface than these examples\n" -"- [serde](https://serde.rs) itself, which makes these concepts intuitive " -"for\n" +"- [serde](https://serde.rs) itself, which makes these concepts intuitive for\n" " end users (i.e. defining the structs) without needing to undestand the\n" " details\n" -"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for " -"drawing\n" -" computer graphics that uses lens API design, including proceducal macros " -"to\n" -" create full prisms for buffers of different pixel types that remain " -"generic\n" -"- [An Article about Lenses in " -"Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-lens-and-other-optics-in-scala-e5f7e2fdafe)\n" +"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for drawing\n" +" computer graphics that uses lens API design, including proceducal macros to\n" +" create full prisms for buffers of different pixel types that remain generic\n" +"- [An Article about Lenses in Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-" +"references-lens-and-other-optics-in-scala-e5f7e2fdafe)\n" " that is very readable even without Scala expertise.\n" "- [Paper: Profunctor Optics: Modular Data\n" -" " -"Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +" Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" msgstr "" -"- [lens-rs crate](https://crates.io/crates/lens-rs) per obiettivi " -"predefiniti\n" +"- [lens-rs crate](https://crates.io/crates/lens-rs) per obiettivi predefiniti\n" " implementazione, con un'interfaccia più pulita rispetto a questi esempi\n" "- [serde](https://serde.rs) stesso, che rende questi concetti intuitivi per\n" -" utenti finali (ovvero definendo le strutture) senza la necessità di " -"comprendere il\n" +" utenti finali (ovvero definendo le strutture) senza la necessità di comprendere il\n" " dettagli\n" -"- [luminance](https://github.com/phaazon/luminance-rs) è una cassa per " -"disegnare\n" -" computer grafica che utilizza la progettazione dell'API dell'obiettivo, " -"comprese le macro procedurali per\n" -" creare prismi completi per buffer di diversi tipi di pixel che rimangono " -"generici\n" -"- [Un articolo sulle lenti in " -"Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-lens-and-other-optics-in- " -"scala-e5f7e2fdafe)\n" +"- [luminance](https://github.com/phaazon/luminance-rs) è una cassa per disegnare\n" +" computer grafica che utilizza la progettazione dell'API dell'obiettivo, comprese le macro procedurali per\n" +" creare prismi completi per buffer di diversi tipi di pixel che rimangono generici\n" +"- [Un articolo sulle lenti in Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-" +"references-lens-and-other-optics-in- scala-e5f7e2fdafe)\n" " che è molto leggibile anche senza l'esperienza di Scala.\n" "- [Documento: Profunctor Optics: Modular Data\n" -" " -"Accessor](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +" Accessor](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" #: src\functional/lenses.md:365 #, fuzzy msgid "" -"[School of Haskell: A Little Lens Starter " -"Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" +"[School of Haskell: A Little Lens Starter Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/" +"to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" msgstr "" -"[Scuola di Haskell: un piccolo tutorial per iniziare con " -"l'obiettivo](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of- " -"la-settimana/un-piccolo-tutorial-di-avviamento)" +"[Scuola di Haskell: un piccolo tutorial per iniziare con l'obiettivo](https://web.archive.org/web/20221128190041/https://www." +"schoolofhaskell.com/school/to-infinity-and-beyond/pick-of- la-settimana/un-piccolo-tutorial-di-avviamento)" #: src\additional_resources/index.md:1 #, fuzzy @@ -9909,21 +8319,16 @@ msgstr "## Colloqui" msgid "" "- [Design Patterns in Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) by\n" " Nicholas Cameron at the PDRust (2016)\n" -"- [Writing Idiomatic Libraries in " -"Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +"- [Writing Idiomatic Libraries in Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" " by Pascal Hertleif at RustFest (2017)\n" -"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) " -"by\n" +"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) by\n" " Nicholas Cameron at LinuxConfAu (2018)" msgstr "" -"- [Modelli di design in " -"ruggine](https://www.youtube.com/watch?v=Pm_oO0N5B9k) di\n" +"- [Modelli di design in ruggine](https://www.youtube.com/watch?v=Pm_oO0N5B9k) di\n" " Nicholas Cameron al PDRust (2016)\n" -"- [Scrivere librerie idiomatiche in " -"Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +"- [Scrivere librerie idiomatiche in Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" " di Pascal Hertleif al RustFest (2017)\n" -"- [Tecniche di programmazione " -"Rust](https://www.youtube.com/watch?v=vqavdUGKeb4) di\n" +"- [Tecniche di programmazione Rust](https://www.youtube.com/watch?v=vqavdUGKeb4) di\n" " Nicholas Cameron alla LinuxConfAu (2018)" #: src\additional_resources/index.md:14 @@ -9934,9 +8339,7 @@ msgstr "## Libri (online)" #: src\additional_resources/index.md:16 #, fuzzy msgid "- [The Rust API Guidelines](https://rust-lang.github.io/api-guidelines)" -msgstr "" -"- [Le linee guida dell'API di " -"Rust](https://rust-lang.github.io/api-guidelines)" +msgstr "- [Le linee guida dell'API di Rust](https://rust-lang.github.io/api-guidelines)" #: src\additional_resources/design-principles.md:1 #, fuzzy @@ -9956,61 +8359,42 @@ msgstr "## [SOLIDO](https://en.wikipedia.org/wiki/SOLIDO)" #: src\additional_resources/design-principles.md:9 #, fuzzy msgid "" -"- [Single Responsibility Principle " -"(SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" -" A class should only have a single responsibility, that is, only changes " -"to\n" +"- [Single Responsibility Principle (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" A class should only have a single responsibility, that is, only changes to\n" " one part of the software's specification should be able to affect the\n" " specification of the class.\n" -"- [Open/Closed Principle " -"(OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +"- [Open/Closed Principle (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" " \"Software entities ... should be open for extension, but closed for\n" " modification.\"\n" -"- [Liskov Substitution Principle " -"(LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" -" \"Objects in a program should be replaceable with instances of their " -"subtypes\n" +"- [Liskov Substitution Principle (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Objects in a program should be replaceable with instances of their subtypes\n" " without altering the correctness of that program.\"\n" -"- [Interface Segregation Principle " -"(ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +"- [Interface Segregation Principle (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" " \"Many client-specific interfaces are better than one general-purpose\n" " interface.\"\n" -"- [Dependency Inversion Principle " -"(DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +"- [Dependency Inversion Principle (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" " One should \"depend upon abstractions, [not] concretions.\"" msgstr "" -"- [Principio di responsabilità singola " -"(SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +"- [Principio di responsabilità singola (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" " Una classe dovrebbe avere una sola responsabilità, cioè solo modifiche a\n" -" una parte delle specifiche del software dovrebbe essere in grado di " -"influenzare il file\n" +" una parte delle specifiche del software dovrebbe essere in grado di influenzare il file\n" " specifica della classe.\n" -"- [Principio aperto/chiuso " -"(OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" -" \"Le entità software ... dovrebbero essere aperte per l'estensione, ma " -"chiuse per\n" +"- [Principio aperto/chiuso (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +" \"Le entità software ... dovrebbero essere aperte per l'estensione, ma chiuse per\n" " modifica.\"\n" -"- [Principio di sostituzione di Liskov " -"(LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" -" \"Gli oggetti in un programma dovrebbero essere sostituibili con istanze " -"dei loro sottotipi\n" +"- [Principio di sostituzione di Liskov (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Gli oggetti in un programma dovrebbero essere sostituibili con istanze dei loro sottotipi\n" " senza alterare la correttezza di quel programma.\"\n" -"- [Principio di segregazione dell'interfaccia " -"(ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +"- [Principio di segregazione dell'interfaccia (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" " \"Molte interfacce specifiche del client sono migliori di una generica\n" " interfaccia.\"\n" -"- [Principio di inversione delle dipendenze " -"(DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +"- [Principio di inversione delle dipendenze (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" " Si dovrebbe \"dipendere dalle astrazioni, [non] dalle concrezioni\"." #: src\additional_resources/design-principles.md:25 #, fuzzy -msgid "" -"## [DRY (Don’t Repeat " -"Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" -msgstr "" -"## [DRY (Non " -"ripeterti)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgid "## [DRY (Don’t Repeat Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgstr "## [DRY (Non ripeterti)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" #: src\additional_resources/design-principles.md:27 #, fuzzy @@ -10028,8 +8412,7 @@ msgstr "## [Principio KISS](https://en.wikipedia.org/wiki/KISS_principle)" #: src\additional_resources/design-principles.md:32 msgid "" -"most systems work best if they are kept simple rather than made " -"complicated;\n" +"most systems work best if they are kept simple rather than made complicated;\n" "therefore, simplicity should be a key goal in design, and unnecessary\n" "complexity should be avoided" msgstr "" @@ -10037,81 +8420,57 @@ msgstr "" #: src\additional_resources/design-principles.md:36 #, fuzzy msgid "## [Law of Demeter (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter)" -msgstr "" -"## [Legge di Demetra (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter)" +msgstr "## [Legge di Demetra (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter)" #: src\additional_resources/design-principles.md:38 #, fuzzy msgid "" "a given object should assume as little as possible about the structure or\n" -"properties of anything else (including its subcomponents), in accordance " -"with\n" +"properties of anything else (including its subcomponents), in accordance with\n" "the principle of \"information hiding\"" msgstr "" "un dato oggetto dovrebbe presumere il meno possibile sulla struttura o\n" -"proprietà di qualsiasi altra cosa (compresi i suoi sottocomponenti), in " -"conformità con\n" +"proprietà di qualsiasi altra cosa (compresi i suoi sottocomponenti), in conformità con\n" "il principio di \"occultamento delle informazioni\"" #: src\additional_resources/design-principles.md:42 #, fuzzy -msgid "" -"## [Design by contract " -"(DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" -msgstr "" -"## [Design by contract " -"(DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgid "## [Design by contract (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgstr "## [Design by contract (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" #: src\additional_resources/design-principles.md:44 #, fuzzy msgid "" "software designers should define formal, precise and verifiable interface\n" -"specifications for software components, which extend the ordinary definition " -"of\n" +"specifications for software components, which extend the ordinary definition of\n" "abstract data types with preconditions, postconditions and invariants" msgstr "" -"i progettisti di software dovrebbero definire un'interfaccia formale, " -"precisa e verificabile\n" -"specifiche per i componenti software, che estendono la definizione ordinaria " -"di\n" +"i progettisti di software dovrebbero definire un'interfaccia formale, precisa e verificabile\n" +"specifiche per i componenti software, che estendono la definizione ordinaria di\n" "tipi di dati astratti con precondizioni, postcondizioni e invarianti" #: src\additional_resources/design-principles.md:48 #, fuzzy -msgid "" -"## " -"[Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" -msgstr "" -"## " -"[Incapsulamento](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgid "## [Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgstr "## [Incapsulamento](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" #: src\additional_resources/design-principles.md:50 #, fuzzy msgid "" -"bundling of data with the methods that operate on that data, or the " -"restricting\n" -"of direct access to some of an object's components. Encapsulation is used " -"to\n" -"hide the values or state of a structured data object inside a class, " -"preventing\n" +"bundling of data with the methods that operate on that data, or the restricting\n" +"of direct access to some of an object's components. Encapsulation is used to\n" +"hide the values or state of a structured data object inside a class, preventing\n" "unauthorized parties' direct access to them." msgstr "" -"raggruppamento di dati con i metodi che operano su tali dati o la " -"restrizione\n" -"di accesso diretto ad alcuni dei componenti di un oggetto. L'incapsulamento " -"è utilizzato per\n" -"nascondere i valori o lo stato di un oggetto di dati strutturati all'interno " -"di una classe, impedendo\n" +"raggruppamento di dati con i metodi che operano su tali dati o la restrizione\n" +"di accesso diretto ad alcuni dei componenti di un oggetto. L'incapsulamento è utilizzato per\n" +"nascondere i valori o lo stato di un oggetto di dati strutturati all'interno di una classe, impedendo\n" "l'accesso diretto di soggetti non autorizzati." #: src\additional_resources/design-principles.md:55 #, fuzzy -msgid "" -"## " -"[Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" -msgstr "" -"## " -"[Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgid "## [Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgstr "## [Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" #: src\additional_resources/design-principles.md:57 #, fuzzy @@ -10120,29 +8479,22 @@ msgid "" "(procedures) will be permitted to produce side effects.” - Bertrand Meyer:\n" "Object-Oriented Software Construction" msgstr "" -"“Le funzioni non dovrebbero produrre effetti collaterali astratti... solo " -"comandi\n" +"“Le funzioni non dovrebbero produrre effetti collaterali astratti... solo comandi\n" "(procedure) potranno produrre effetti collaterali”. -Bertrand Mayer:\n" "Costruzione software orientata agli oggetti" #: src\additional_resources/design-principles.md:61 #, fuzzy -msgid "" -"## [Principle of least astonishment " -"(POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" -msgstr "" -"## [Principio del minimo stupore " -"(POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgid "## [Principle of least astonishment (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgstr "## [Principio del minimo stupore (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" #: src\additional_resources/design-principles.md:63 #, fuzzy msgid "" -"a component of a system should behave in a way that most users will expect " -"it\n" +"a component of a system should behave in a way that most users will expect it\n" "to behave. The behavior should not astonish or surprise users" msgstr "" -"un componente di un sistema dovrebbe comportarsi in un modo che la maggior " -"parte degli utenti se lo aspetta\n" +"un componente di un sistema dovrebbe comportarsi in un modo che la maggior parte degli utenti se lo aspetta\n" "comportarsi. Il comportamento non deve stupire o sorprendere gli utenti" #: src\additional_resources/design-principles.md:66 @@ -10153,12 +8505,10 @@ msgstr "## Unità linguistiche-modulari" #: src\additional_resources/design-principles.md:68 #, fuzzy msgid "" -"“Modules must correspond to syntactic units in the language used.” - " -"Bertrand\n" +"“Modules must correspond to syntactic units in the language used.” - Bertrand\n" "Meyer: Object-Oriented Software Construction" msgstr "" -"\"I moduli devono corrispondere alle unità sintattiche nella lingua " -"utilizzata.\" - Bertrand\n" +"\"I moduli devono corrispondere alle unità sintattiche nella lingua utilizzata.\" - Bertrand\n" "Meyer: costruzione di software orientato agli oggetti" #: src\additional_resources/design-principles.md:71 @@ -10170,14 +8520,11 @@ msgstr "## Autodocumentazione" #, fuzzy msgid "" "“The designer of a module should strive to make all information about the\n" -"module part of the module itself.” - Bertrand Meyer: Object-Oriented " -"Software\n" +"module part of the module itself.” - Bertrand Meyer: Object-Oriented Software\n" "Construction" msgstr "" -"“Il progettista di un modulo dovrebbe sforzarsi di rendere tutte le " -"informazioni sul\n" -"modulo parte del modulo stesso.” - Bertrand Meyer: Software orientato agli " -"oggetti\n" +"“Il progettista di un modulo dovrebbe sforzarsi di rendere tutte le informazioni sul\n" +"modulo parte del modulo stesso.” - Bertrand Meyer: Software orientato agli oggetti\n" "Costruzione" #: src\additional_resources/design-principles.md:77 @@ -10189,15 +8536,12 @@ msgstr "## Accesso uniforme" #, fuzzy msgid "" "“All services offered by a module should be available through a uniform\n" -"notation, which does not betray whether they are implemented through storage " -"or\n" +"notation, which does not betray whether they are implemented through storage or\n" "through computation.” - Bertrand Meyer: Object-Oriented Software Construction" msgstr "" -"“Tutti i servizi offerti da un modulo dovrebbero essere disponibili " -"attraverso un'uniforme\n" +"“Tutti i servizi offerti da un modulo dovrebbero essere disponibili attraverso un'uniforme\n" "notazione, che non tradisce se sono implementati tramite archiviazione o\n" -"attraverso il calcolo.” - Bertrand Meyer: Costruzione di software orientato " -"agli oggetti" +"attraverso il calcolo.” - Bertrand Meyer: Costruzione di software orientato agli oggetti" #: src\additional_resources/design-principles.md:83 #, fuzzy @@ -10207,16 +8551,12 @@ msgstr "## Scelta singola" #: src\additional_resources/design-principles.md:85 #, fuzzy msgid "" -"“Whenever a software system must support a set of alternatives, one and " -"only\n" -"one module in the system should know their exhaustive list.” - Bertrand " -"Meyer:\n" +"“Whenever a software system must support a set of alternatives, one and only\n" +"one module in the system should know their exhaustive list.” - Bertrand Meyer:\n" "Object-Oriented Software Construction" msgstr "" -"“Ogni volta che un sistema software deve supportare un insieme di " -"alternative, una e sola\n" -"un modulo nel sistema dovrebbe conoscere il loro elenco esaustivo. -Bertrand " -"Mayer:\n" +"“Ogni volta che un sistema software deve supportare un insieme di alternative, una e sola\n" +"un modulo nel sistema dovrebbe conoscere il loro elenco esaustivo. -Bertrand Mayer:\n" "Costruzione software orientata agli oggetti" #: src\additional_resources/design-principles.md:89 @@ -10229,52 +8569,12 @@ msgstr "## Persistenza-Chiusura" msgid "" "“Whenever a storage mechanism stores an object, it must store with it the\n" "dependents of that object. Whenever a retrieval mechanism retrieves a\n" -"previously stored object, it must also retrieve any dependent of that " -"object\n" -"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented " -"Software\n" +"previously stored object, it must also retrieve any dependent of that object\n" +"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented Software\n" "Construction" msgstr "" -"“Ogni volta che un meccanismo di archiviazione immagazzina un oggetto, deve " -"immagazzinare con esso il\n" -"dipendenti di quell'oggetto. Ogni volta che un meccanismo di recupero " -"recupera a\n" -"oggetto precedentemente memorizzato, deve anche recuperare qualsiasi " -"dipendente di quell'oggetto\n" -"che non è stato ancora recuperato. - Bertrand Meyer: Software orientato agli " -"oggetti\n" +"“Ogni volta che un meccanismo di archiviazione immagazzina un oggetto, deve immagazzinare con esso il\n" +"dipendenti di quell'oggetto. Ogni volta che un meccanismo di recupero recupera a\n" +"oggetto precedentemente memorizzato, deve anche recuperare qualsiasi dipendente di quell'oggetto\n" +"che non è stato ancora recuperato. - Bertrand Meyer: Software orientato agli oggetti\n" "Costruzione" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - diff --git a/po/pt-BR.po b/po/pt-BR.po index dea82f3..8fc8eb0 100644 --- a/po/pt-BR.po +++ b/po/pt-BR.po @@ -1,16 +1,16 @@ - msgid "" msgstr "" "Project-Id-Version: Rust Design Patterns\n" "POT-Creation-Date: \n" -"PO-Revision-Date: 2023-04-08 21:56+0200\n" -"Last-Translator: \n" +"PO-Revision-Date: 2023-04-09 03:23+0200\n" +"Last-Translator: EMAIL@ADDRESS\n" "Language-Team: Language pt-BR\n" +"Language: pt_BR\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" -"Language: pt-BR\n" "Plural-Forms: nplurals=1; plural=0;\n" +"X-Generator: Poedit 3.2.2\n" #: src\SUMMARY.md:3 #, fuzzy @@ -266,12 +266,10 @@ msgstr "## Participação" #, fuzzy msgid "" "If you are interested in contributing to this book, check out the\n" -"[contribution " -"guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +"[contribution guidelines](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." msgstr "" "Se você estiver interessado em contribuir para este livro, confira o\n" -"[diretrizes de " -"contribuição](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." +"[diretrizes de contribuição](https://github.com/rust-unofficial/patterns/blob/master/CONTRIBUTING.md)." #: src\intro.md:8 #, fuzzy @@ -287,11 +285,9 @@ msgid "" "abstract from these particularities to find the common practices that\n" "are generically applicable." msgstr "" -"No desenvolvimento de software, muitas vezes nos deparamos com problemas que " -"compartilham\n" +"No desenvolvimento de software, muitas vezes nos deparamos com problemas que compartilham\n" "semelhanças independentemente do ambiente em que aparecem.\n" -"detalhes de implementação são cruciais para resolver a tarefa em mãos, " -"podemos\n" +"detalhes de implementação são cruciais para resolver a tarefa em mãos, podemos\n" "abstrair dessas particularidades para encontrar as práticas comuns que\n" "são genericamente aplicáveis." @@ -304,10 +300,8 @@ msgid "" "language for developers, making them an excellent tool for effective\n" "communication when problem-solving in teams." msgstr "" -"Padrões de projeto são uma coleção de soluções reutilizáveis e testadas " -"para\n" -"problemas recorrentes na engenharia. Eles tornam nosso software mais " -"modular,\n" +"Padrões de projeto são uma coleção de soluções reutilizáveis e testadas para\n" +"problemas recorrentes na engenharia. Eles tornam nosso software mais modular,\n" "sustentável e extensível. Além disso, esses padrões fornecem uma\n" "linguagem para desenvolvedores, tornando-os uma excelente ferramenta para\n" "comunicação na solução de problemas em equipes." @@ -320,8 +314,7 @@ msgstr "## Padrões de design em Rust" #: src\intro.md:24 #, fuzzy msgid "" -"Rust is not object-oriented, and the combination of all its " -"characteristics,\n" +"Rust is not object-oriented, and the combination of all its characteristics,\n" "such as functional elements, a strong type system, and the borrow checker,\n" "makes it unique.\n" "Because of this, Rust design patterns vary with respect to other\n" @@ -329,15 +322,12 @@ msgid "" "That's why we decided to write this book. We hope you enjoy reading it!\n" "The book is divided in three main chapters:" msgstr "" -"Rust não é orientado a objetos, e a combinação de todas as suas " -"características,\n" -"como elementos funcionais, um sistema de tipo forte e o verificador de " -"empréstimo,\n" +"Rust não é orientado a objetos, e a combinação de todas as suas características,\n" +"como elementos funcionais, um sistema de tipo forte e o verificador de empréstimo,\n" "torna único.\n" "Por causa disso, os padrões de projeto do Rust variam em relação a outros\n" "linguagens de programação tradicionais orientadas a objetos.\n" -"É por isso que decidimos escrever este livro. Esperamos que você goste de " -"lê-lo!\n" +"É por isso que decidimos escrever este livro. Esperamos que você goste de lê-lo!\n" "O livro está dividido em três capítulos principais:" #: src\intro.md:32 @@ -348,8 +338,7 @@ msgid "" " You should break them only if you have a good reason for it.\n" "- [Design patterns](./patterns/index.md): methods to solve common problems\n" " when coding.\n" -"- [Anti-patterns](./anti_patterns/index.md): methods to solve common " -"problems\n" +"- [Anti-patterns](./anti_patterns/index.md): methods to solve common problems\n" " when coding.\n" " However, while design patterns give us benefits,\n" " anti-patterns create more problems." @@ -357,11 +346,9 @@ msgstr "" "- [Idioms](./idioms/index.md): orientações a seguir ao codificar.\n" " Eles são as normas sociais da comunidade.\n" " Você deve quebrá-los apenas se tiver um bom motivo para isso.\n" -"- [Padrões de design](./patterns/index.md): métodos para resolver problemas " -"comuns\n" +"- [Padrões de design](./patterns/index.md): métodos para resolver problemas comuns\n" " ao codificar.\n" -"- [Anti-padrões](./anti_patterns/index.md): métodos para resolver problemas " -"comuns\n" +"- [Anti-padrões](./anti_patterns/index.md): métodos para resolver problemas comuns\n" " ao codificar.\n" " No entanto, embora os padrões de projeto nos tragam benefícios,\n" " antipadrões criam mais problemas." @@ -374,15 +361,13 @@ msgstr "# Traduções" #: src\translations.md:3 #, fuzzy msgid "" -"We are utilizing " -"[mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" -"Please read up on how to _add_ and _update_ translations in [their " -"repository](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations)" +"We are utilizing [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Please read up on how to _add_ and _update_ translations in [their repository](https://github.com/google/mdbook-i18n-helpers#creating-" +"and-updating-translations)" msgstr "" -"Estamos utilizando " -"[mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" -"Leia sobre como _adicionar_ e _atualizar_ traduções em [seu " -"repositório](https://github.com/google/mdbook-i18n-helpers#creating-and-updating-translations)" +"Estamos utilizando [mdbook-i18n-helper](https://github.com/google/mdbook-i18n-helpers).\n" +"Leia sobre como _adicionar_ e _atualizar_ traduções em [seu repositório](https://github.com/google/mdbook-i18n-helpers#creating-and-" +"updating-translations)" #: src\translations.md:6 #, fuzzy @@ -416,11 +401,9 @@ msgid "" "Writing idiomatic code allows other developers to understand better what is\n" "happening." msgstr "" -"[idiomas](https://en.wikipedia.org/wiki/Programming_idiom) são comumente " -"usados\n" +"[idiomas](https://en.wikipedia.org/wiki/Programming_idiom) são comumente usados\n" "estilos, diretrizes e padrões amplamente aceitos por uma comunidade.\n" -"Escrever código idiomático permite que outros desenvolvedores entendam " -"melhor o que é\n" +"Escrever código idiomático permite que outros desenvolvedores entendam melhor o que é\n" "acontecendo." #: src\idioms/index.md:8 @@ -433,19 +416,14 @@ msgid "" msgstr "" "Afinal, o computador só se preocupa com o código de máquina que é gerado\n" "pelo compilador.\n" -"Em vez disso, o código-fonte é benéfico principalmente para o " -"desenvolvedor.\n" -"Então, já que temos essa camada de abstração, por que não torná-la mais " -"legível?" +"Em vez disso, o código-fonte é benéfico principalmente para o desenvolvedor.\n" +"Então, já que temos essa camada de abstração, por que não torná-la mais legível?" #: src\idioms/index.md:13 msgid "" -"Remember the [KISS " -"principle](https://en.wikipedia.org/wiki/KISS_principle):\n" -"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they " -"are\n" -"kept simple rather than made complicated; therefore, simplicity should be a " -"key\n" +"Remember the [KISS principle](https://en.wikipedia.org/wiki/KISS_principle):\n" +"\"Keep It Simple, Stupid\". It claims that \"most systems work best if they are\n" +"kept simple rather than made complicated; therefore, simplicity should be a key\n" "goal in design, and unnecessary complexity should be avoided\"." msgstr "" @@ -459,25 +437,16 @@ msgstr "> O código existe para ser entendido por humanos, não por computadores msgid "# Use borrowed types for arguments" msgstr "# Use tipos emprestados para argumentos" -#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 -#: src\idioms/default.md:3 src\idioms/deref.md:3 src\idioms/dtor-finally.md:3 -#: src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 -#: src\idioms/ffi/errors.md:3 src\idioms/ffi/accepting-strings.md:3 -#: src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 -#: src\idioms/pass-var-to-closure.md:3 src\idioms/priv-extend.md:3 -#: src\idioms/temporary-mutability.md:3 -#: src\idioms/return-consumed-arg-on-error.md:3 -#: src\patterns/behavioural/command.md:3 -#: src\patterns/behavioural/interpreter.md:3 -#: src\patterns/behavioural/newtype.md:13 src\patterns/behavioural/RAII.md:3 -#: src\patterns/behavioural/strategy.md:3 src\patterns/behavioural/visitor.md:3 -#: src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 -#: src\patterns/structural/compose-structs.md:5 -#: src\patterns/structural/small-crates.md:3 -#: src\patterns/structural/unsafe-mods.md:3 src\patterns/ffi/export.md:3 -#: src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 -#: src\anti_patterns/deny-warnings.md:3 src\anti_patterns/deref.md:3 -#: src\functional/generics-type-classes.md:3 +#: src\idioms/coercion-arguments.md:3 src\idioms/concat-format.md:3 src\idioms/default.md:3 src\idioms/deref.md:3 +#: src\idioms/dtor-finally.md:3 src\idioms/mem-replace.md:3 src\idioms/on-stack-dyn-dispatch.md:3 src\idioms/ffi/errors.md:3 +#: src\idioms/ffi/accepting-strings.md:3 src\idioms/ffi/passing-strings.md:3 src\idioms/option-iter.md:3 +#: src\idioms/pass-var-to-closure.md:3 src\idioms/priv-extend.md:3 src\idioms/temporary-mutability.md:3 +#: src\idioms/return-consumed-arg-on-error.md:3 src\patterns/behavioural/command.md:3 src\patterns/behavioural/interpreter.md:3 +#: src\patterns/behavioural/newtype.md:13 src\patterns/behavioural/RAII.md:3 src\patterns/behavioural/strategy.md:3 +#: src\patterns/behavioural/visitor.md:3 src\patterns/creational/builder.md:3 src\patterns/creational/fold.md:3 +#: src\patterns/structural/compose-structs.md:5 src\patterns/structural/small-crates.md:3 src\patterns/structural/unsafe-mods.md:3 +#: src\patterns/ffi/export.md:3 src\patterns/ffi/wrappers.md:3 src\anti_patterns/borrow_clone.md:3 src\anti_patterns/deny-warnings.md:3 +#: src\anti_patterns/deref.md:3 src\functional/generics-type-classes.md:3 #, fuzzy msgid "## Description" msgstr "## Descrição" @@ -485,15 +454,12 @@ msgstr "## Descrição" #: src\idioms/coercion-arguments.md:5 #, fuzzy msgid "" -"Using a target of a deref coercion can increase the flexibility of your " -"code\n" +"Using a target of a deref coercion can increase the flexibility of your code\n" "when you are deciding which argument type to use for a function argument.\n" "In this way, the function will accept more input types." msgstr "" -"Usar um alvo de uma coerção deref pode aumentar a flexibilidade do seu " -"código\n" -"quando você está decidindo qual tipo de argumento usar para um argumento de " -"função.\n" +"Usar um alvo de uma coerção deref pode aumentar a flexibilidade do seu código\n" +"quando você está decidindo qual tipo de argumento usar para um argumento de função.\n" "Dessa forma, a função aceitará mais tipos de entrada." #: src\idioms/coercion-arguments.md:9 @@ -512,38 +478,25 @@ msgstr "" #: src\idioms/coercion-arguments.md:14 #, fuzzy msgid "" -"Using borrowed types you can avoid layers of indirection for those " -"instances\n" -"where the owned type already provides a layer of indirection. For instance, " -"a\n" +"Using borrowed types you can avoid layers of indirection for those instances\n" +"where the owned type already provides a layer of indirection. For instance, a\n" "`String` has a layer of indirection, so a `&String` will have two layers of\n" -"indirection. We can avoid this by using `&str` instead, and letting " -"`&String`\n" +"indirection. We can avoid this by using `&str` instead, and letting `&String`\n" "coerce to a `&str` whenever the function is invoked." msgstr "" -"Usando tipos emprestados, você pode evitar camadas de indireção para essas " -"instâncias\n" -"onde o tipo de propriedade já fornece uma camada de indireção. Por exemplo, " -"um\n" -"`String` tem uma camada de indireção, então um `&String` terá duas camadas " -"de\n" +"Usando tipos emprestados, você pode evitar camadas de indireção para essas instâncias\n" +"onde o tipo de propriedade já fornece uma camada de indireção. Por exemplo, um\n" +"`String` tem uma camada de indireção, então um `&String` terá duas camadas de\n" "indireção. Podemos evitar isso usando `&str` e deixando `&String`\n" "coagir a um `&str` sempre que a função for invocada." -#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 -#: src\idioms/default.md:20 src\idioms/deref.md:9 src\idioms/dtor-finally.md:9 -#: src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 -#: src\idioms/pass-var-to-closure.md:12 src\idioms/priv-extend.md:18 -#: src\idioms/temporary-mutability.md:12 -#: src\idioms/return-consumed-arg-on-error.md:8 -#: src\patterns/behavioural/command.md:18 -#: src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 -#: src\patterns/behavioural/strategy.md:28 -#: src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 -#: src\patterns/creational/fold.md:12 -#: src\patterns/structural/compose-structs.md:17 -#: src\anti_patterns/borrow_clone.md:11 src\anti_patterns/deny-warnings.md:8 -#: src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 +#: src\idioms/coercion-arguments.md:20 src\idioms/concat-format.md:10 src\idioms/default.md:20 src\idioms/deref.md:9 +#: src\idioms/dtor-finally.md:9 src\idioms/mem-replace.md:11 src\idioms/on-stack-dyn-dispatch.md:10 src\idioms/pass-var-to-closure.md:12 +#: src\idioms/priv-extend.md:18 src\idioms/temporary-mutability.md:12 src\idioms/return-consumed-arg-on-error.md:8 +#: src\patterns/behavioural/command.md:18 src\patterns/behavioural/newtype.md:18 src\patterns/behavioural/RAII.md:11 +#: src\patterns/behavioural/strategy.md:28 src\patterns/behavioural/visitor.md:13 src\patterns/creational/builder.md:7 +#: src\patterns/creational/fold.md:12 src\patterns/structural/compose-structs.md:17 src\anti_patterns/borrow_clone.md:11 +#: src\anti_patterns/deny-warnings.md:8 src\anti_patterns/deref.md:8 src\functional/generics-type-classes.md:38 #, fuzzy msgid "## Example" msgstr "## Exemplo" @@ -551,29 +504,23 @@ msgstr "## Exemplo" #: src\idioms/coercion-arguments.md:22 #, fuzzy msgid "" -"For this example, we will illustrate some differences for using `&String` as " -"a\n" -"function argument versus using a `&str`, but the ideas apply as well to " -"using\n" +"For this example, we will illustrate some differences for using `&String` as a\n" +"function argument versus using a `&str`, but the ideas apply as well to using\n" "`&Vec` versus using a `&[T]` or using a `&Box` versus a `&T`." msgstr "" -"Para este exemplo, vamos ilustrar algumas diferenças para usar `&String` " -"como um\n" -"argumento de função versus usar um `&str`, mas as ideias também se aplicam " -"ao uso\n" +"Para este exemplo, vamos ilustrar algumas diferenças para usar `&String` como um\n" +"argumento de função versus usar um `&str`, mas as ideias também se aplicam ao uso\n" "`&Vec` versus usar um `&[T]` ou usar um `&Box` versus um `&T`." #: src\idioms/coercion-arguments.md:26 #, fuzzy msgid "" "Consider an example where we wish to determine if a word contains three\n" -"consecutive vowels. We don't need to own the string to determine this, so " -"we\n" +"consecutive vowels. We don't need to own the string to determine this, so we\n" "will take a reference." msgstr "" "Considere um exemplo em que desejamos determinar se uma palavra contém três\n" -"vogais consecutivas. Não precisamos ser os donos da string para determinar " -"isso, então\n" +"vogais consecutivas. Não precisamos ser os donos da string para determinar isso, então\n" "vai pegar uma referência." #: src\idioms/coercion-arguments.md:30 @@ -618,17 +565,13 @@ msgstr "" #, fuzzy msgid "" "This works fine because we are passing a `&String` type as a parameter.\n" -"If we remove the comments on the last two lines, the example will fail. " -"This\n" -"is because a `&str` type will not coerce to a `&String` type. We can fix " -"this\n" +"If we remove the comments on the last two lines, the example will fail. This\n" +"is because a `&str` type will not coerce to a `&String` type. We can fix this\n" "by simply modifying the type for our argument." msgstr "" "Isso funciona bem porque estamos passando um tipo `&String` como parâmetro.\n" -"Se removermos os comentários nas duas últimas linhas, o exemplo falhará. " -"Esse\n" -"é porque um tipo `&str` não será forçado a um tipo `&String`. Nós podemos " -"consertar isso\n" +"Se removermos os comentários nas duas últimas linhas, o exemplo falhará. Esse\n" +"é porque um tipo `&str` não será forçado a um tipo `&String`. Nós podemos consertar isso\n" "simplesmente modificando o tipo do nosso argumento." #: src\idioms/coercion-arguments.md:67 @@ -660,30 +603,23 @@ msgstr "" #, fuzzy msgid "" "But wait, that's not all! There is more to this story.\n" -"It's likely that you may say to yourself: that doesn't matter, I will never " -"be\n" -"using a `&'static str` as an input anyways (as we did when we used " -"`\"Ferris\"`).\n" -"Even ignoring this special example, you may still find that using `&str` " -"will\n" +"It's likely that you may say to yourself: that doesn't matter, I will never be\n" +"using a `&'static str` as an input anyways (as we did when we used `\"Ferris\"`).\n" +"Even ignoring this special example, you may still find that using `&str` will\n" "give you more flexibility than using a `&String`." msgstr "" "Mas espere, isso não é tudo! Há mais nesta história.\n" "É provável que você diga a si mesmo: isso não importa, eu nunca serei\n" -"usando um `&'static str` como uma entrada de qualquer maneira (como fizemos " -"quando usamos `\"Ferris\"`).\n" -"Mesmo ignorando este exemplo especial, você ainda pode achar que usar " -"`&str`\n" +"usando um `&'static str` como uma entrada de qualquer maneira (como fizemos quando usamos `\"Ferris\"`).\n" +"Mesmo ignorando este exemplo especial, você ainda pode achar que usar `&str`\n" "dar-lhe mais flexibilidade do que usar um `&String`." #: src\idioms/coercion-arguments.md:86 #, fuzzy msgid "" "Let's now take an example where someone gives us a sentence, and we want to\n" -"determine if any of the words in the sentence contain three consecutive " -"vowels.\n" -"We probably should make use of the function we have already defined and " -"simply\n" +"determine if any of the words in the sentence contain three consecutive vowels.\n" +"We probably should make use of the function we have already defined and simply\n" "feed in each word from the sentence." msgstr "" "Vamos agora dar um exemplo onde alguém nos dá uma frase, e queremos\n" @@ -717,8 +653,7 @@ msgid "" "\n" "fn main() {\n" " let sentence_string =\n" -" \"Once upon a time, there was a friendly curious crab named " -"Ferris\".to_string();\n" +" \"Once upon a time, there was a friendly curious crab named Ferris\".to_string();\n" " for word in sentence_string.split(' ') {\n" " if three_vowels(word) {\n" " println!(\"{} has three consecutive vowels!\", word);\n" @@ -731,12 +666,10 @@ msgstr "" #: src\idioms/coercion-arguments.md:121 #, fuzzy msgid "" -"Running this example using our function declared with an argument type " -"`&str`\n" +"Running this example using our function declared with an argument type `&str`\n" "will yield" msgstr "" -"Executando este exemplo usando nossa função declarada com um tipo de " -"argumento `&str`\n" +"Executando este exemplo usando nossa função declarada com um tipo de argumento `&str`\n" "vai render" #: src\idioms/coercion-arguments.md:124 @@ -750,34 +683,21 @@ msgstr "" #, fuzzy msgid "" "However, this example will not run when our function is declared with an\n" -"argument type `&String`. This is because string slices are a `&str` and not " -"a\n" -"`&String` which would require an allocation to be converted to `&String` " -"which\n" -"is not implicit, whereas converting from `String` to `&str` is cheap and " -"implicit." -msgstr "" -"No entanto, este exemplo não será executado quando nossa função for " -"declarada com um\n" -"tipo de argumento `&String`. Isso ocorre porque as fatias de string são um " -"`&str` e não um\n" +"argument type `&String`. This is because string slices are a `&str` and not a\n" +"`&String` which would require an allocation to be converted to `&String` which\n" +"is not implicit, whereas converting from `String` to `&str` is cheap and implicit." +msgstr "" +"No entanto, este exemplo não será executado quando nossa função for declarada com um\n" +"tipo de argumento `&String`. Isso ocorre porque as fatias de string são um `&str` e não um\n" "`&String` que exigiria uma alocação para ser convertida em `&String` que\n" -"não é implícito, enquanto a conversão de `String` para `&str` é barata e " -"implícita." - -#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 -#: src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 -#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 -#: src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 -#: src\patterns/behavioural/command.md:218 -#: src\patterns/behavioural/interpreter.md:142 -#: src\patterns/behavioural/newtype.md:104 src\patterns/behavioural/RAII.md:111 -#: src\patterns/behavioural/strategy.md:174 -#: src\patterns/behavioural/visitor.md:106 -#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 -#: src\patterns/structural/small-crates.md:45 -#: src\patterns/structural/unsafe-mods.md:32 -#: src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 +"não é implícito, enquanto a conversão de `String` para `&str` é barata e implícita." + +#: src\idioms/coercion-arguments.md:133 src\idioms/default.md:58 src\idioms/deref.md:76 src\idioms/dtor-finally.md:88 +#: src\idioms/mem-replace.md:108 src\idioms/on-stack-dyn-dispatch.md:83 src\idioms/option-iter.md:46 src\idioms/priv-extend.md:120 +#: src\patterns/behavioural/command.md:218 src\patterns/behavioural/interpreter.md:142 src\patterns/behavioural/newtype.md:104 +#: src\patterns/behavioural/RAII.md:111 src\patterns/behavioural/strategy.md:174 src\patterns/behavioural/visitor.md:106 +#: src\patterns/creational/builder.md:108 src\patterns/creational/fold.md:109 src\patterns/structural/small-crates.md:45 +#: src\patterns/structural/unsafe-mods.md:32 src\anti_patterns/borrow_clone.md:68 src\anti_patterns/deny-warnings.md:96 #: src\anti_patterns/deref.md:123 src\functional/generics-type-classes.md:237 #, fuzzy msgid "## See also" @@ -786,19 +706,16 @@ msgstr "## Veja também" #: src\idioms/coercion-arguments.md:135 #, fuzzy msgid "" -"- [Rust Language Reference on Type " -"Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- [Rust Language Reference on Type Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" "- For more discussion on how to handle `String` and `&str` see\n" -" [this blog series " -"(2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html)\n" +" [this blog series (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-" +"functions.html)\n" " by Herman J. Radtke III" msgstr "" -"- [Rust Language Reference on Type " -"Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" +"- [Rust Language Reference on Type Coercions](https://doc.rust-lang.org/reference/type-coercions.html)\n" "- Para mais discussões sobre como lidar com `String` e `&str` veja\n" -" [esta série de blogs " -"(2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html " -")\n" +" [esta série de blogs (2015)](https://web.archive.org/web/20201112023149/https://hermanradtke.com/2015/05/03/string-vs-str-in-rust-" +"functions.html )\n" " por Herman J. Radtke III" #: src\idioms/concat-format.md:1 @@ -809,15 +726,13 @@ msgstr "# Concatenando strings com `format!`" #: src\idioms/concat-format.md:5 #, fuzzy msgid "" -"It is possible to build up strings using the `push` and `push_str` methods " -"on a\n" +"It is possible to build up strings using the `push` and `push_str` methods on a\n" "mutable `String`, or using its `+` operator. However, it is often more\n" "convenient to use `format!`, especially where there is a mix of literal and\n" "non-literal strings." msgstr "" "É possível construir strings usando os métodos `push` e `push_str` em um\n" -"`String` mutável, ou usando seu operador `+`. No entanto, muitas vezes é " -"mais\n" +"`String` mutável, ou usando seu operador `+`. No entanto, muitas vezes é mais\n" "conveniente usar `format!`, especialmente onde há uma mistura de literal e\n" "strings não literais." @@ -837,47 +752,29 @@ msgid "" "```" msgstr "" -#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 -#: src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 -#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 -#: src\idioms/ffi/accepting-strings.md:68 src\idioms/ffi/passing-strings.md:68 -#: src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 -#: src\idioms/return-consumed-arg-on-error.md:55 -#: src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 -#: src\patterns/behavioural/strategy.md:96 -#: src\patterns/creational/builder.md:68 -#: src\patterns/structural/compose-structs.md:75 -#: src\patterns/structural/small-crates.md:12 -#: src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 -#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 -#: src\anti_patterns/deref.md:69 src\functional/generics-type-classes.md:210 +#: src\idioms/concat-format.md:25 src\idioms/deref.md:43 src\idioms/dtor-finally.md:42 src\idioms/mem-replace.md:83 +#: src\idioms/on-stack-dyn-dispatch.md:48 src\idioms/ffi/errors.md:131 src\idioms/ffi/accepting-strings.md:68 +#: src\idioms/ffi/passing-strings.md:68 src\idioms/pass-var-to-closure.md:48 src\idioms/temporary-mutability.md:38 +#: src\idioms/return-consumed-arg-on-error.md:55 src\patterns/behavioural/newtype.md:66 src\patterns/behavioural/RAII.md:78 +#: src\patterns/behavioural/strategy.md:96 src\patterns/creational/builder.md:68 src\patterns/structural/compose-structs.md:75 +#: src\patterns/structural/small-crates.md:12 src\patterns/structural/unsafe-mods.md:11 src\patterns/ffi/export.md:111 +#: src\patterns/ffi/wrappers.md:63 src\anti_patterns/deny-warnings.md:16 src\anti_patterns/deref.md:69 +#: src\functional/generics-type-classes.md:210 #, fuzzy msgid "## Advantages" msgstr "## Vantagens" #: src\idioms/concat-format.md:27 #, fuzzy -msgid "" -"Using `format!` is usually the most succinct and readable way to combine " -"strings." -msgstr "" -"Usar `format!` geralmente é a maneira mais sucinta e legível de combinar " -"strings." - -#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 -#: src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 -#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 -#: src\idioms/ffi/accepting-strings.md:141 -#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 -#: src\idioms/temporary-mutability.md:42 -#: src\idioms/return-consumed-arg-on-error.md:59 -#: src\patterns/behavioural/newtype.md:77 -#: src\patterns/behavioural/strategy.md:104 -#: src\patterns/creational/builder.md:76 -#: src\patterns/structural/compose-structs.md:81 -#: src\patterns/structural/small-crates.md:22 -#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 -#: src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 +msgid "Using `format!` is usually the most succinct and readable way to combine strings." +msgstr "Usar `format!` geralmente é a maneira mais sucinta e legível de combinar strings." + +#: src\idioms/concat-format.md:29 src\idioms/deref.md:50 src\idioms/dtor-finally.md:47 src\idioms/mem-replace.md:87 +#: src\idioms/on-stack-dyn-dispatch.md:54 src\idioms/ffi/errors.md:136 src\idioms/ffi/accepting-strings.md:141 +#: src\idioms/ffi/passing-strings.md:103 src\idioms/pass-var-to-closure.md:57 src\idioms/temporary-mutability.md:42 +#: src\idioms/return-consumed-arg-on-error.md:59 src\patterns/behavioural/newtype.md:77 src\patterns/behavioural/strategy.md:104 +#: src\patterns/creational/builder.md:76 src\patterns/structural/compose-structs.md:81 src\patterns/structural/small-crates.md:22 +#: src\patterns/structural/unsafe-mods.md:17 src\patterns/ffi/export.md:234 src\patterns/ffi/wrappers.md:69 src\anti_patterns/deref.md:81 #: src\functional/generics-type-classes.md:221 #, fuzzy msgid "## Disadvantages" @@ -886,16 +783,12 @@ msgstr "## Desvantagens" #: src\idioms/concat-format.md:31 #, fuzzy msgid "" -"It is usually not the most efficient way to combine strings - a series of " -"`push`\n" -"operations on a mutable string is usually the most efficient (especially if " -"the\n" +"It is usually not the most efficient way to combine strings - a series of `push`\n" +"operations on a mutable string is usually the most efficient (especially if the\n" "string has been pre-allocated to the expected size)." msgstr "" -"Geralmente não é a maneira mais eficiente de combinar strings - uma série de " -"`push`\n" -"operações em uma string mutável é geralmente a mais eficiente (especialmente " -"se o\n" +"Geralmente não é a maneira mais eficiente de combinar strings - uma série de `push`\n" +"operações em uma string mutável é geralmente a mais eficiente (especialmente se o\n" "string foi pré-alocada para o tamanho esperado)." #: src\idioms/ctor.md:1 @@ -912,13 +805,10 @@ msgstr "## Descrição\r" #, fuzzy msgid "" "Rust does not have constructors as a language construct. Instead, the\r\n" -"convention is to use an [associated function][associated function] `new` to " -"create an object:" +"convention is to use an [associated function][associated function] `new` to create an object:" msgstr "" -"Rust não possui construtores como uma construção de linguagem. Em vez disso, " -"o\r\n" -"A convenção é usar uma [função associada][função associada] `new` para criar " -"um objeto:" +"Rust não possui construtores como uma construção de linguagem. Em vez disso, o\r\n" +"A convenção é usar uma [função associada][função associada] `new` para criar um objeto:" #: src\idioms/ctor.md:8 msgid "" @@ -957,10 +847,8 @@ msgstr "## Construtores Padrão\r" #: src\idioms/ctor.md:37 #, fuzzy -msgid "" -"Rust supports default constructors with the [`Default`][std-default] trait:" -msgstr "" -"Rust suporta construtores padrão com o atributo [`Default`][std-default]:" +msgid "Rust supports default constructors with the [`Default`][std-default] trait:" +msgstr "Rust suporta construtores padrão com o atributo [`Default`][std-default]:" #: src\idioms/ctor.md:39 msgid "" @@ -995,12 +883,10 @@ msgstr "" #: src\idioms/ctor.md:66 #, fuzzy msgid "" -"`Default` can also be derived if all types of all fields implement " -"`Default`,\r\n" +"`Default` can also be derived if all types of all fields implement `Default`,\r\n" "like they do with `Second`:" msgstr "" -"`Padrão` também pode ser derivado se todos os tipos de todos os campos " -"implementarem `Padrão`,\r\n" +"`Padrão` também pode ser derivado se todos os tipos de todos os campos implementarem `Padrão`,\r\n" "como eles fazem com `Second`:" #: src\idioms/ctor.md:69 @@ -1046,17 +932,13 @@ msgstr "" #: src\idioms/ctor.md:97 #, fuzzy msgid "" -"**Hint:** The advantage of implementing or deriving `Default` is that your " -"type\r\n" -"can now be used where a `Default` implementation is required, most " -"prominently,\r\n" +"**Hint:** The advantage of implementing or deriving `Default` is that your type\r\n" +"can now be used where a `Default` implementation is required, most prominently,\r\n" "any of the [`*or_default` functions in the standard library][std-or-default]." msgstr "" "**Dica:** A vantagem de implementar ou derivar `Default` é que seu tipo\r\n" -"agora pode ser usado onde uma implementação `Padrão` é necessária, " -"principalmente,\r\n" -"qualquer uma das funções [`*or_default` na biblioteca " -"padrão][std-or-default]." +"agora pode ser usado onde uma implementação `Padrão` é necessária, principalmente,\r\n" +"qualquer uma das funções [`*or_default` na biblioteca padrão][std-or-default]." #: src\idioms/ctor.md:101 #, fuzzy @@ -1069,8 +951,7 @@ msgid "" "- The [default idiom](default.md) for a more in-depth description of the\r\n" " `Default` trait.\r\n" "\r\n" -"- The [builder pattern](../patterns/creational/builder.md) for " -"constructing\r\n" +"- The [builder pattern](../patterns/creational/builder.md) for constructing\r\n" " objects where there are multiple configurations.\r\n" "\r\n" "- [API Guidelines/C-COMMON-TRAITS][API Guidelines/C-COMMON-TRAITS] for\r\n" @@ -1080,12 +961,10 @@ msgstr "" "- O [idioma padrão](default.md) para uma descrição mais detalhada do\r\n" " Traço `Padrão`.\r\n" "\r\n" -"- O [padrão de construtor](../patterns/creational/builder.md) para " -"construir\r\n" +"- O [padrão de construtor](../patterns/creational/builder.md) para construir\r\n" " objetos onde existem múltiplas configurações.\r\n" "\r\n" -"- [Diretrizes de API/C-COMMON-TRAITS][Diretrizes de API/C-COMMON-TRAITS] " -"para\r\n" +"- [Diretrizes de API/C-COMMON-TRAITS][Diretrizes de API/C-COMMON-TRAITS] para\r\n" " implementando ambos, `Default` e `new`.\r\n" "\r" @@ -1097,11 +976,9 @@ msgstr "# A Característica `Padrão`" #: src\idioms/default.md:5 msgid "" "Many types in Rust have a [constructor]. However, this is _specific_ to the\n" -"type; Rust cannot abstract over \"everything that has a `new()` method\". " -"To\n" +"type; Rust cannot abstract over \"everything that has a `new()` method\". To\n" "allow this, the [`Default`] trait was conceived, which can be used with\n" -"containers and other generic types (e.g. see " -"[`Option::unwrap_or_default()`]).\n" +"containers and other generic types (e.g. see [`Option::unwrap_or_default()`]).\n" "Notably, some containers already implement it where applicable." msgstr "" @@ -1113,11 +990,9 @@ msgid "" "`#[derive(Default)]` for structs whose fields all implement it, so the more\n" "types implement `Default`, the more useful it becomes." msgstr "" -"Não apenas contêineres de um elemento como `Cow`, `Box` ou `Arc` " -"implementam\n" +"Não apenas contêineres de um elemento como `Cow`, `Box` ou `Arc` implementam\n" "`Default` para tipos `Default` contidos, pode-se automaticamente\n" -"`#[derive(Default)]` para structs cujos campos todos o implementam, então " -"quanto mais\n" +"`#[derive(Default)]` para structs cujos campos todos o implementam, então quanto mais\n" "tipos implementam `Padrão`, mais útil ele se torna." #: src\idioms/default.md:16 @@ -1127,8 +1002,7 @@ msgid "" "`default()` method does not. There can even be multiple constructors with\n" "different names, but there can only be one `Default` implementation per type." msgstr "" -"Por outro lado, os construtores podem receber vários argumentos, enquanto " -"os\n" +"Por outro lado, os construtores podem receber vários argumentos, enquanto os\n" "O método `default()` não. Pode até haver vários construtores com\n" "nomes diferentes, mas só pode haver uma implementação `Padrão` por tipo." @@ -1161,8 +1035,7 @@ msgid "" " conf.check = true;\n" " println!(\"conf = {:#?}\", conf);\n" " \n" -" // partial initialization with default values, creates the same " -"instance\n" +" // partial initialization with default values, creates the same instance\n" " let conf1 = MyConfiguration {\n" " check: true,\n" " ..Default::default()\n" @@ -1175,18 +1048,15 @@ msgstr "" #: src\idioms/default.md:60 #, fuzzy msgid "" -"- The [constructor] idiom is another way to generate instances that may or " -"may\n" +"- The [constructor] idiom is another way to generate instances that may or may\n" " not be \"default\"\n" "- The [`Default`] documentation (scroll down for the list of implementors)\n" "- [`Option::unwrap_or_default()`]\n" "- [`derive(new)`]" msgstr "" -"- O idioma [constructor] é outra maneira de gerar instâncias que podem ou " -"podem\n" +"- O idioma [constructor] é outra maneira de gerar instâncias que podem ou podem\n" " não ser \"padrão\"\n" -"- A documentação [`Padrão`] (role para baixo para ver a lista de " -"implementadores)\n" +"- A documentação [`Padrão`] (role para baixo para ver a lista de implementadores)\n" "- [`Option::unwrap_or_default()`]\n" "- [`derivar(novo)`]" @@ -1203,8 +1073,7 @@ msgid "" "and borrowed views of data." msgstr "" "Use o [`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)\n" -"característica para tratar coleções como ponteiros inteligentes, oferecendo " -"propriedade\n" +"característica para tratar coleções como ponteiros inteligentes, oferecendo propriedade\n" "e visualizações de dados emprestadas." #: src\idioms/deref.md:11 @@ -1230,23 +1099,16 @@ msgstr "" #: src\idioms/deref.md:28 #, fuzzy msgid "" -"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a " -"borrowed\n" -"collection of `T`s. Implementing `Deref` for `Vec` allows implicit " -"dereferencing\n" +"A `Vec` is an owning collection of `T`s, while a slice (`&[T]`) is a borrowed\n" +"collection of `T`s. Implementing `Deref` for `Vec` allows implicit dereferencing\n" "from `&Vec` to `&[T]` and includes the relationship in auto-derefencing\n" -"searches. Most methods you might expect to be implemented for `Vec`s are " -"instead\n" +"searches. Most methods you might expect to be implemented for `Vec`s are instead\n" "implemented for slices." msgstr "" -"Um `Vec` é uma coleção proprietária de `T`s, enquanto uma fatia (`&[T]`) " -"é um empréstimo\n" -"coleção de `T`s. A implementação de `Deref` para `Vec` permite a " -"desreferência implícita\n" -"de `&Vec` para `&[T]` e inclui o relacionamento na desativação " -"automática\n" -"pesquisas. A maioria dos métodos que você pode esperar que sejam " -"implementados para `Vec`s são\n" +"Um `Vec` é uma coleção proprietária de `T`s, enquanto uma fatia (`&[T]`) é um empréstimo\n" +"coleção de `T`s. A implementação de `Deref` para `Vec` permite a desreferência implícita\n" +"de `&Vec` para `&[T]` e inclui o relacionamento na desativação automática\n" +"pesquisas. A maioria dos métodos que você pode esperar que sejam implementados para `Vec`s são\n" "implementado para fatias." #: src\idioms/deref.md:34 @@ -1254,18 +1116,12 @@ msgstr "" msgid "Also `String` and `&str` have a similar relation." msgstr "Além disso, `String` e `&str` têm uma relação semelhante." -#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 -#: src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 -#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 -#: src\idioms/return-consumed-arg-on-error.md:43 -#: src\patterns/behavioural/command.md:8 -#: src\patterns/behavioural/interpreter.md:16 -#: src\patterns/behavioural/newtype.md:56 src\patterns/behavioural/RAII.md:72 -#: src\patterns/behavioural/strategy.md:19 -#: src\patterns/behavioural/visitor.md:72 src\patterns/creational/builder.md:63 -#: src\patterns/creational/fold.md:73 -#: src\patterns/structural/compose-structs.md:71 src\patterns/ffi/export.md:15 -#: src\anti_patterns/borrow_clone.md:30 +#: src\idioms/deref.md:36 src\idioms/dtor-finally.md:32 src\idioms/mem-replace.md:57 src\idioms/on-stack-dyn-dispatch.md:37 +#: src\idioms/ffi/accepting-strings.md:12 src\idioms/ffi/passing-strings.md:14 src\idioms/return-consumed-arg-on-error.md:43 +#: src\patterns/behavioural/command.md:8 src\patterns/behavioural/interpreter.md:16 src\patterns/behavioural/newtype.md:56 +#: src\patterns/behavioural/RAII.md:72 src\patterns/behavioural/strategy.md:19 src\patterns/behavioural/visitor.md:72 +#: src\patterns/creational/builder.md:63 src\patterns/creational/fold.md:73 src\patterns/structural/compose-structs.md:71 +#: src\patterns/ffi/export.md:15 src\anti_patterns/borrow_clone.md:30 #, fuzzy msgid "## Motivation" msgstr "## Motivação" @@ -1273,19 +1129,14 @@ msgstr "## Motivação" #: src\idioms/deref.md:38 #, fuzzy msgid "" -"Ownership and borrowing are key aspects of the Rust language. Data " -"structures\n" +"Ownership and borrowing are key aspects of the Rust language. Data structures\n" "must account for these semantics properly to give a good user\n" -"experience. When implementing a data structure that owns its data, offering " -"a\n" +"experience. When implementing a data structure that owns its data, offering a\n" "borrowed view of that data allows for more flexible APIs." msgstr "" -"Propriedade e empréstimo são aspectos-chave da linguagem Rust. Estruturas de " -"dados\n" -"deve levar em conta essas semânticas adequadamente para dar a um bom " -"usuário\n" -"experiência. Ao implementar uma estrutura de dados proprietária de seus " -"dados, oferecendo uma\n" +"Propriedade e empréstimo são aspectos-chave da linguagem Rust. Estruturas de dados\n" +"deve levar em conta essas semânticas adequadamente para dar a um bom usuário\n" +"experiência. Ao implementar uma estrutura de dados proprietária de seus dados, oferecendo uma\n" "A visão emprestada desses dados permite APIs mais flexíveis." #: src\idioms/deref.md:45 @@ -1294,40 +1145,29 @@ msgid "" "Most methods can be implemented only for the borrowed view, they are then\n" "implicitly available for the owning view." msgstr "" -"A maioria dos métodos pode ser implementada apenas para a visão emprestada, " -"eles são então\n" +"A maioria dos métodos pode ser implementada apenas para a visão emprestada, eles são então\n" "implicitamente disponível para a exibição proprietária." #: src\idioms/deref.md:48 #, fuzzy msgid "Gives clients a choice between borrowing or taking ownership of data." -msgstr "" -"Dá aos clientes a escolha entre tomar emprestado ou se apropriar dos dados." +msgstr "Dá aos clientes a escolha entre tomar emprestado ou se apropriar dos dados." #: src\idioms/deref.md:52 #, fuzzy msgid "" -"Methods and traits only available via dereferencing are not taken into " -"account\n" -"when bounds checking, so generic programming with data structures using " -"this\n" +"Methods and traits only available via dereferencing are not taken into account\n" +"when bounds checking, so generic programming with data structures using this\n" "pattern can get complex (see the `Borrow` and `AsRef` traits, etc.)." msgstr "" -"Métodos e características disponíveis apenas por desreferenciação não são " -"levados em consideração\n" -"ao verificar limites, então programação genérica com estruturas de dados " -"usando este\n" -"padrão pode se tornar complexo (veja as características `Borrow` e `AsRef`, " -"etc.)." - -#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 -#: src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 -#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 -#: src\patterns/behavioural/interpreter.md:103 -#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 -#: src\patterns/behavioural/strategy.md:110 -#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 -#: src\patterns/creational/fold.md:85 +"Métodos e características disponíveis apenas por desreferenciação não são levados em consideração\n" +"ao verificar limites, então programação genérica com estruturas de dados usando este\n" +"padrão pode se tornar complexo (veja as características `Borrow` e `AsRef`, etc.)." + +#: src\idioms/deref.md:56 src\idioms/dtor-finally.md:61 src\idioms/mem-replace.md:97 src\idioms/on-stack-dyn-dispatch.md:68 +#: src\idioms/priv-extend.md:85 src\patterns/behavioural/command.md:203 src\patterns/behavioural/interpreter.md:103 +#: src\patterns/behavioural/newtype.md:85 src\patterns/behavioural/RAII.md:83 src\patterns/behavioural/strategy.md:110 +#: src\patterns/behavioural/visitor.md:79 src\patterns/creational/builder.md:81 src\patterns/creational/fold.md:85 #: src\patterns/structural/compose-structs.md:89 src\anti_patterns/deref.md:102 #, fuzzy msgid "## Discussion" @@ -1336,77 +1176,56 @@ msgstr "## Discussão" #: src\idioms/deref.md:58 #, fuzzy msgid "" -"Smart pointers and collections are analogous: a smart pointer points to a " -"single\n" -"object, whereas a collection points to many objects. From the point of view " -"of\n" -"the type system, there is little difference between the two. A collection " -"owns\n" +"Smart pointers and collections are analogous: a smart pointer points to a single\n" +"object, whereas a collection points to many objects. From the point of view of\n" +"the type system, there is little difference between the two. A collection owns\n" "its data if the only way to access each datum is via the collection and the\n" "collection is responsible for deleting the data (even in cases of shared\n" -"ownership, some kind of borrowed view may be appropriate). If a collection " -"owns\n" -"its data, it is usually useful to provide a view of the data as borrowed so " -"that\n" +"ownership, some kind of borrowed view may be appropriate). If a collection owns\n" +"its data, it is usually useful to provide a view of the data as borrowed so that\n" "it can be referenced multiple times." msgstr "" -"Ponteiros inteligentes e coleções são análogos: um ponteiro inteligente " -"aponta para um único\n" -"objeto, enquanto uma coleção aponta para muitos objetos. Do ponto de vista " -"de\n" +"Ponteiros inteligentes e coleções são análogos: um ponteiro inteligente aponta para um único\n" +"objeto, enquanto uma coleção aponta para muitos objetos. Do ponto de vista de\n" "o sistema de tipo, há pouca diferença entre os dois. Uma coleção possui\n" -"seus dados se a única forma de acesso a cada dado for através da coleta e " -"do\n" -"coleta é responsável por excluir os dados (mesmo em casos de " -"compartilhamento\n" -"propriedade, algum tipo de visão emprestada pode ser apropriada). Se uma " -"coleção possui\n" -"seus dados, geralmente é útil fornecer uma visão dos dados como emprestados " -"para que\n" +"seus dados se a única forma de acesso a cada dado for através da coleta e do\n" +"coleta é responsável por excluir os dados (mesmo em casos de compartilhamento\n" +"propriedade, algum tipo de visão emprestada pode ser apropriada). Se uma coleção possui\n" +"seus dados, geralmente é útil fornecer uma visão dos dados como emprestados para que\n" "pode ser referenciado várias vezes." #: src\idioms/deref.md:67 #, fuzzy msgid "" "Most smart pointers (e.g., `Foo`) implement `Deref`. However,\n" -"collections will usually dereference to a custom type. `[T]` and `str` have " -"some\n" -"language support, but in the general case, this is not necessary. `Foo` " -"can\n" -"implement `Deref>` where `Bar` is a dynamically sized type " -"and\n" +"collections will usually dereference to a custom type. `[T]` and `str` have some\n" +"language support, but in the general case, this is not necessary. `Foo` can\n" +"implement `Deref>` where `Bar` is a dynamically sized type and\n" "`&Bar` is a borrowed view of the data in `Foo`." msgstr "" -"A maioria dos ponteiros inteligentes (por exemplo, `Foo`) implementam " -"`Deref`. No entanto,\n" -"as coleções geralmente desreferenciarão a um tipo personalizado. `[T]` e " -"`str` têm alguns\n" +"A maioria dos ponteiros inteligentes (por exemplo, `Foo`) implementam `Deref`. No entanto,\n" +"as coleções geralmente desreferenciarão a um tipo personalizado. `[T]` e `str` têm alguns\n" "suporte a idiomas, mas no caso geral, isso não é necessário. `Foo` pode\n" -"implemente `Deref>` onde `Bar` é um tipo de tamanho dinâmico " -"e\n" +"implemente `Deref>` onde `Bar` é um tipo de tamanho dinâmico e\n" "`&Bar` é uma visão emprestada dos dados em `Foo`." #: src\idioms/deref.md:73 #, fuzzy msgid "" -"Commonly, ordered collections will implement `Index` for `Range`s to " -"provide\n" +"Commonly, ordered collections will implement `Index` for `Range`s to provide\n" "slicing syntax. The target will be the borrowed view." msgstr "" -"Normalmente, coleções ordenadas irão implementar `Index` para `Range`s para " -"fornecer\n" +"Normalmente, coleções ordenadas irão implementar `Index` para `Range`s para fornecer\n" "sintaxe de corte. O alvo será a visão emprestada." #: src\idioms/deref.md:78 #, fuzzy msgid "" "- [Deref polymorphism anti-pattern](../anti_patterns/deref.md).\n" -"- [Documentation for `Deref` " -"trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." msgstr "" "- [Deref polimorfismo anti-padrão](../anti_patterns/deref.md).\n" -"- [Documentação para o trait " -"`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentação para o trait `Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." #: src\idioms/dtor-finally.md:1 #, fuzzy @@ -1416,15 +1235,12 @@ msgstr "# Finalização em destrutores" #: src\idioms/dtor-finally.md:5 #, fuzzy msgid "" -"Rust does not provide the equivalent to `finally` blocks - code that will " -"be\n" -"executed no matter how a function is exited. Instead, an object's destructor " -"can\n" +"Rust does not provide the equivalent to `finally` blocks - code that will be\n" +"executed no matter how a function is exited. Instead, an object's destructor can\n" "be used to run code that must be run before exit." msgstr "" "Rust não fornece o equivalente aos blocos `finally` - código que será\n" -"executado, não importa como uma função é encerrada. Em vez disso, o " -"destruidor de um objeto pode\n" +"executado, não importa como uma função é encerrada. Em vez disso, o destruidor de um objeto pode\n" "ser usado para executar o código que deve ser executado antes da saída." #: src\idioms/dtor-finally.md:11 @@ -1454,28 +1270,19 @@ msgstr "" #: src\idioms/dtor-finally.md:34 #, fuzzy msgid "" -"If a function has multiple return points, then executing code on exit " -"becomes\n" -"difficult and repetitive (and thus bug-prone). This is especially the case " -"where\n" +"If a function has multiple return points, then executing code on exit becomes\n" +"difficult and repetitive (and thus bug-prone). This is especially the case where\n" "return is implicit due to a macro. A common case is the `?` operator which\n" -"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used " -"as\n" -"an exception handling mechanism, but unlike Java (which has `finally`), " -"there is\n" +"returns if the result is an `Err`, but continues if it is `Ok`. `?` is used as\n" +"an exception handling mechanism, but unlike Java (which has `finally`), there is\n" "no way to schedule code to run in both the normal and exceptional cases.\n" "Panicking will also exit a function early." msgstr "" -"Se uma função tiver vários pontos de retorno, a execução do código na saída " -"torna-se\n" -"difícil e repetitivo (e, portanto, propenso a erros). Este é especialmente o " -"caso onde\n" -"o retorno é implícito devido a uma macro. Um caso comum é o operador `?` " -"que\n" -"retorna se o resultado for um `Err`, mas continua se for `Ok`. `?` é usado " -"como\n" -"um mecanismo de manipulação de exceção, mas ao contrário de Java (que tem " -"`finally`), há\n" +"Se uma função tiver vários pontos de retorno, a execução do código na saída torna-se\n" +"difícil e repetitivo (e, portanto, propenso a erros). Este é especialmente o caso onde\n" +"o retorno é implícito devido a uma macro. Um caso comum é o operador `?` que\n" +"retorna se o resultado for um `Err`, mas continua se for `Ok`. `?` é usado como\n" +"um mecanismo de manipulação de exceção, mas ao contrário de Java (que tem `finally`), há\n" "não há como agendar o código para execução em casos normais e excepcionais.\n" "Entrar em pânico também sairá de uma função mais cedo." @@ -1494,84 +1301,60 @@ msgid "" "It is not guaranteed that destructors will run. For example, if there is an\n" "infinite loop in a function or if running a function crashes before exit.\n" "Destructors are also not run in the case of a panic in an already panicking\n" -"thread. Therefore, destructors cannot be relied on as finalizers where it " -"is\n" +"thread. Therefore, destructors cannot be relied on as finalizers where it is\n" "absolutely essential that finalisation happens." msgstr "" -"Não é garantido que os destruidores serão executados. Por exemplo, se houver " -"um\n" -"loop infinito em uma função ou se a execução de uma função falhar antes de " -"sair.\n" -"Os destruidores também não são executados no caso de um pânico em um já em " -"pânico\n" -"fio. Portanto, os destruidores não podem ser usados como finalizadores onde " -"é\n" +"Não é garantido que os destruidores serão executados. Por exemplo, se houver um\n" +"loop infinito em uma função ou se a execução de uma função falhar antes de sair.\n" +"Os destruidores também não são executados no caso de um pânico em um já em pânico\n" +"fio. Portanto, os destruidores não podem ser usados como finalizadores onde é\n" "absolutamente essencial que a finalização aconteça." #: src\idioms/dtor-finally.md:55 #, fuzzy msgid "" -"This pattern introduces some hard to notice, implicit code. Reading a " -"function\n" +"This pattern introduces some hard to notice, implicit code. Reading a function\n" "gives no clear indication of destructors to be run on exit. This can make\n" "debugging tricky." msgstr "" -"Esse padrão introduz algum código implícito difícil de perceber. Lendo uma " -"função\n" -"não dá nenhuma indicação clara de destruidores a serem executados na saída. " -"isso pode fazer\n" +"Esse padrão introduz algum código implícito difícil de perceber. Lendo uma função\n" +"não dá nenhuma indicação clara de destruidores a serem executados na saída. isso pode fazer\n" "depuração complicada." #: src\idioms/dtor-finally.md:59 #, fuzzy -msgid "" -"Requiring an object and `Drop` impl just for finalisation is heavy on " -"boilerplate." -msgstr "" -"Exigir um objeto e impl `Drop` apenas para finalização é pesado em clichê." +msgid "Requiring an object and `Drop` impl just for finalisation is heavy on boilerplate." +msgstr "Exigir um objeto e impl `Drop` apenas para finalização é pesado em clichê." #: src\idioms/dtor-finally.md:63 #, fuzzy msgid "" "There is some subtlety about how exactly to store the object used as a\n" -"finalizer. It must be kept alive until the end of the function and must then " -"be\n" -"destroyed. The object must always be a value or uniquely owned pointer " -"(e.g.,\n" -"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer " -"can\n" +"finalizer. It must be kept alive until the end of the function and must then be\n" +"destroyed. The object must always be a value or uniquely owned pointer (e.g.,\n" +"`Box`). If a shared pointer (such as `Rc`) is used, then the finalizer can\n" "be kept alive beyond the lifetime of the function. For similar reasons, the\n" "finalizer should not be moved or returned." msgstr "" -"Existe alguma sutileza sobre como exatamente armazenar o objeto usado como " -"um\n" +"Existe alguma sutileza sobre como exatamente armazenar o objeto usado como um\n" "finalizador. Deve ser mantido vivo até o final da função e deve então ser\n" -"destruído. O objeto deve ser sempre um valor ou um ponteiro de propriedade " -"exclusiva (por exemplo,\n" -"`Box`). Se um ponteiro compartilhado (como `Rc`) for usado, o " -"finalizador pode\n" +"destruído. O objeto deve ser sempre um valor ou um ponteiro de propriedade exclusiva (por exemplo,\n" +"`Box`). Se um ponteiro compartilhado (como `Rc`) for usado, o finalizador pode\n" "ser mantido vivo além do tempo de vida da função. Por razões semelhantes, o\n" "finalizer não deve ser movido ou retornado." #: src\idioms/dtor-finally.md:70 #, fuzzy msgid "" -"The finalizer must be assigned into a variable, otherwise it will be " -"destroyed\n" -"immediately, rather than when it goes out of scope. The variable name must " -"start\n" -"with `_` if the variable is only used as a finalizer, otherwise the " -"compiler\n" -"will warn that the finalizer is never used. However, do not call the " -"variable\n" +"The finalizer must be assigned into a variable, otherwise it will be destroyed\n" +"immediately, rather than when it goes out of scope. The variable name must start\n" +"with `_` if the variable is only used as a finalizer, otherwise the compiler\n" +"will warn that the finalizer is never used. However, do not call the variable\n" "`_` with no suffix - in that case it will be destroyed immediately." msgstr "" -"O finalizador deve ser atribuído a uma variável, caso contrário, será " -"destruído\n" -"imediatamente, em vez de quando sai do escopo. O nome da variável deve " -"começar\n" -"com `_` se a variável for usada apenas como finalizador, caso contrário, o " -"compilador\n" +"O finalizador deve ser atribuído a uma variável, caso contrário, será destruído\n" +"imediatamente, em vez de quando sai do escopo. O nome da variável deve começar\n" +"com `_` se a variável for usada apenas como finalizador, caso contrário, o compilador\n" "avisará que o finalizador nunca é usado. No entanto, não chame a variável\n" "`_` sem sufixo - nesse caso será destruído imediatamente." @@ -1581,39 +1364,28 @@ msgid "" "In Rust, destructors are run when an object goes out of scope. This happens\n" "whether we reach the end of block, there is an early return, or the program\n" "panics. When panicking, Rust unwinds the stack running destructors for each\n" -"object in each stack frame. So, destructors get called even if the panic " -"happens\n" +"object in each stack frame. So, destructors get called even if the panic happens\n" "in a function being called." msgstr "" -"No Rust, os destruidores são executados quando um objeto sai do escopo. Isto " -"acontece\n" +"No Rust, os destruidores são executados quando um objeto sai do escopo. Isto acontece\n" "se chegamos ao final do bloco, há um retorno antecipado ou o programa\n" -"pânico. Ao entrar em pânico, Rust desenrola a pilha executando destruidores " -"para cada\n" -"objeto em cada quadro de pilha. Assim, os destruidores são chamados mesmo " -"que o pânico aconteça\n" +"pânico. Ao entrar em pânico, Rust desenrola a pilha executando destruidores para cada\n" +"objeto em cada quadro de pilha. Assim, os destruidores são chamados mesmo que o pânico aconteça\n" "em uma função que está sendo chamada." #: src\idioms/dtor-finally.md:82 #, fuzzy msgid "" -"If a destructor panics while unwinding, there is no good action to take, so " -"Rust\n" -"aborts the thread immediately, without running further destructors. This " -"means\n" -"that destructors are not absolutely guaranteed to run. It also means that " -"you\n" +"If a destructor panics while unwinding, there is no good action to take, so Rust\n" +"aborts the thread immediately, without running further destructors. This means\n" +"that destructors are not absolutely guaranteed to run. It also means that you\n" "must take extra care in your destructors not to panic, since it could leave\n" "resources in an unexpected state." msgstr "" -"Se um destruidor entrar em pânico enquanto desenrola, não há nenhuma boa " -"ação a ser tomada, então Rust\n" -"aborta o thread imediatamente, sem executar mais destruidores. Isso " -"significa\n" -"que os destruidores não são absolutamente garantidos para serem executados. " -"Também significa que você\n" -"deve tomar cuidado extra em seus destruidores para não entrar em pânico, " -"pois pode deixar\n" +"Se um destruidor entrar em pânico enquanto desenrola, não há nenhuma boa ação a ser tomada, então Rust\n" +"aborta o thread imediatamente, sem executar mais destruidores. Isso significa\n" +"que os destruidores não são absolutamente garantidos para serem executados. Também significa que você\n" +"deve tomar cuidado extra em seus destruidores para não entrar em pânico, pois pode deixar\n" "recursos em um estado inesperado." #: src\idioms/dtor-finally.md:90 @@ -1624,9 +1396,7 @@ msgstr "[guardas RAII](../patterns/behavioural/RAII.md)." #: src\idioms/mem-replace.md:1 #, fuzzy msgid "# `mem::{take(_), replace(_)}` to keep owned values in changed enums" -msgstr "" -"# `mem::{take(_), replace(_)}` para manter os valores de propriedade em " -"enums alterados" +msgstr "# `mem::{take(_), replace(_)}` para manter os valores de propriedade em enums alterados" #: src\idioms/mem-replace.md:5 #, fuzzy @@ -1686,8 +1456,7 @@ msgid "" "fn swizzle(e: &mut MultiVariateEnum) {\n" " use MultiVariateEnum::*;\n" " *e = match e {\n" -" // Ownership rules do not allow taking `name` by value, but we " -"cannot\n" +" // Ownership rules do not allow taking `name` by value, but we cannot\n" " // take the value out of a mutable reference, unless we replace it:\n" " A { name } => B { name: mem::take(name) },\n" " B { name } => A { name: mem::take(name) },\n" @@ -1701,61 +1470,45 @@ msgstr "" #: src\idioms/mem-replace.md:59 #, fuzzy msgid "" -"When working with enums, we may want to change an enum value in place, " -"perhaps\n" +"When working with enums, we may want to change an enum value in place, perhaps\n" "to another variant. This is usually done in two phases to keep the borrow\n" -"checker happy. In the first phase, we observe the existing value and look " -"at\n" -"its parts to decide what to do next. In the second phase we may " -"conditionally\n" +"checker happy. In the first phase, we observe the existing value and look at\n" +"its parts to decide what to do next. In the second phase we may conditionally\n" "change the value (as in the example above)." msgstr "" -"Ao trabalhar com enums, podemos querer alterar um valor de enum no lugar, " -"talvez\n" -"para outra variante. Isso geralmente é feito em duas fases para manter o " -"empréstimo\n" -"verificador feliz. Na primeira fase, observamos o valor existente e " -"procuramos\n" -"suas partes para decidir o que fazer a seguir. Na segunda fase, podemos " -"condicionalmente\n" +"Ao trabalhar com enums, podemos querer alterar um valor de enum no lugar, talvez\n" +"para outra variante. Isso geralmente é feito em duas fases para manter o empréstimo\n" +"verificador feliz. Na primeira fase, observamos o valor existente e procuramos\n" +"suas partes para decidir o que fazer a seguir. Na segunda fase, podemos condicionalmente\n" "altere o valor (como no exemplo acima)." #: src\idioms/mem-replace.md:65 #, fuzzy msgid "" "The borrow checker won't allow us to take out `name` of the enum (because\n" -"_something_ must be there.) We could of course `.clone()` name and put the " -"clone\n" -"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy " -"the borrow checker](../anti_patterns/borrow_clone.md) anti-pattern. Anyway, " -"we\n" +"_something_ must be there.) We could of course `.clone()` name and put the clone\n" +"into our `MyEnum::B`, but that would be an instance of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md) " +"anti-pattern. Anyway, we\n" "can avoid the extra allocation by changing `e` with only a mutable borrow." msgstr "" -"O verificador de empréstimo não nos permitirá remover `name` do enum " -"(porque\n" -"_algo_ deve estar lá.) É claro que poderíamos nomear `.clone()` e colocar o " -"clone\n" -"em nosso `MyEnum::B`, mas isso seria uma instância do anti-padrão [Clone " -"para satisfazer o verificador de " -"empréstimo](../anti_patterns/borrow_clone.md). De qualquer forma, nós\n" +"O verificador de empréstimo não nos permitirá remover `name` do enum (porque\n" +"_algo_ deve estar lá.) É claro que poderíamos nomear `.clone()` e colocar o clone\n" +"em nosso `MyEnum::B`, mas isso seria uma instância do anti-padrão [Clone para satisfazer o verificador de empréstimo](../anti_patterns/" +"borrow_clone.md). De qualquer forma, nós\n" "pode evitar a alocação extra alterando `e` apenas com um empréstimo mutável." #: src\idioms/mem-replace.md:70 #, fuzzy msgid "" -"`mem::take` lets us swap out the value, replacing it with it's default " -"value,\n" -"and returning the previous value. For `String`, the default value is an " -"empty\n" +"`mem::take` lets us swap out the value, replacing it with it's default value,\n" +"and returning the previous value. For `String`, the default value is an empty\n" "`String`, which does not need to allocate. As a result, we get the original\n" "`name` _as an owned value_. We can then wrap this in another enum." msgstr "" -"`mem::take` nos permite trocar o valor, substituindo-o por seu valor " -"padrão,\n" +"`mem::take` nos permite trocar o valor, substituindo-o por seu valor padrão,\n" "e retornando o valor anterior. Para `String`, o valor padrão é um vazio\n" "`String`, que não precisa alocar. Como resultado, obtemos o original\n" -"`name` _como um valor de propriedade_. Podemos então envolver isso em outro " -"enum." +"`name` _como um valor de propriedade_. Podemos então envolver isso em outro enum." #: src\idioms/mem-replace.md:75 #, fuzzy @@ -1764,8 +1517,7 @@ msgid "" "replace the value with. An equivalent to our `mem::take` line would be\n" "`mem::replace(name, String::new())`." msgstr "" -"**NOTA:** `mem::replace` é muito semelhante, mas nos permite especificar o " -"que\n" +"**NOTA:** `mem::replace` é muito semelhante, mas nos permite especificar o que\n" "substitua o valor por. Um equivalente à nossa linha `mem::take` seria\n" "`mem::replace(nome, String::new())`." @@ -1776,19 +1528,14 @@ msgid "" "value with a `None`, `Option`’s `take()` method provides a shorter and\n" "more idiomatic alternative." msgstr "" -"Observe, no entanto, que se estivermos usando uma `Option` e quisermos " -"substituir sua\n" -"valor com um `None`, o método `take()` de `Option` fornece um valor mais " -"curto e\n" +"Observe, no entanto, que se estivermos usando uma `Option` e quisermos substituir sua\n" +"valor com um `None`, o método `take()` de `Option` fornece um valor mais curto e\n" "alternativa mais idiomática." #: src\idioms/mem-replace.md:85 #, fuzzy -msgid "" -"Look ma, no allocation! Also you may feel like Indiana Jones while doing it." -msgstr "" -"Olha ma, sem alocação! Além disso, você pode se sentir como Indiana Jones ao " -"fazê-lo." +msgid "Look ma, no allocation! Also you may feel like Indiana Jones while doing it." +msgstr "Olha ma, sem alocação! Além disso, você pode se sentir como Indiana Jones ao fazê-lo." #: src\idioms/mem-replace.md:89 #, fuzzy @@ -1799,64 +1546,52 @@ msgid "" "languages." msgstr "" "Isso fica um pouco prolixo. Errar repetidamente fará com que você odeie o\n" -"verificador de empréstimo. O compilador pode falhar ao otimizar o " -"armazenamento duplo,\n" -"resultando em desempenho reduzido em oposição ao que você faria em ambientes " -"inseguros\n" +"verificador de empréstimo. O compilador pode falhar ao otimizar o armazenamento duplo,\n" +"resultando em desempenho reduzido em oposição ao que você faria em ambientes inseguros\n" "línguas." #: src\idioms/mem-replace.md:94 #, fuzzy msgid "" -"Furthermore, the type you are taking needs to implement the [`Default` " -"trait](./default.md). However, if the type you're working with doesn't\n" +"Furthermore, the type you are taking needs to implement the [`Default` trait](./default.md). However, if the type you're working with " +"doesn't\n" "implement this, you can instead use `mem::replace`." msgstr "" -"Além disso, o tipo que você está tomando precisa implementar o [traço " -"`Default`](./default.md). No entanto, se o tipo com o qual você está " -"trabalhando não\n" +"Além disso, o tipo que você está tomando precisa implementar o [traço `Default`](./default.md). No entanto, se o tipo com o qual você " +"está trabalhando não\n" "implementar isso, você pode usar `mem::replace`." #: src\idioms/mem-replace.md:99 #, fuzzy msgid "" "This pattern is only of interest in Rust. In GC'd languages, you'd take the\n" -"reference to the value by default (and the GC would keep track of refs), and " -"in\n" -"other low-level languages like C you'd simply alias the pointer and fix " -"things\n" +"reference to the value by default (and the GC would keep track of refs), and in\n" +"other low-level languages like C you'd simply alias the pointer and fix things\n" "later." msgstr "" "Esse padrão é interessante apenas no Rust. Em idiomas GC'd, você pegaria o\n" "referência ao valor por padrão (e o GC manteria o controle de refs), e em\n" -"outras linguagens de baixo nível, como C, você simplesmente criaria um alias " -"para o ponteiro e consertaria as coisas\n" +"outras linguagens de baixo nível, como C, você simplesmente criaria um alias para o ponteiro e consertaria as coisas\n" "mais tarde." #: src\idioms/mem-replace.md:104 #, fuzzy msgid "" -"However, in Rust, we have to do a little more work to do this. An owned " -"value\n" -"may only have one owner, so to take it out, we need to put something back in " -"–\n" +"However, in Rust, we have to do a little more work to do this. An owned value\n" +"may only have one owner, so to take it out, we need to put something back in –\n" "like Indiana Jones, replacing the artifact with a bag of sand." msgstr "" -"No entanto, no Rust, temos que trabalhar um pouco mais para fazer isso. Um " -"valor de propriedade\n" -"pode ter apenas um dono, então, para retirá-lo, precisamos colocar algo de " -"volta –\n" +"No entanto, no Rust, temos que trabalhar um pouco mais para fazer isso. Um valor de propriedade\n" +"pode ter apenas um dono, então, para retirá-lo, precisamos colocar algo de volta –\n" "como Indiana Jones, substituindo o artefato por um saco de areia." #: src\idioms/mem-replace.md:110 #, fuzzy msgid "" -"This gets rid of the [Clone to satisfy the borrow " -"checker](../anti_patterns/borrow_clone.md)\n" +"This gets rid of the [Clone to satisfy the borrow checker](../anti_patterns/borrow_clone.md)\n" "anti-pattern in a specific case." msgstr "" -"Isso elimina o [Clone para satisfazer o verificador de " -"empréstimo](../anti_patterns/borrow_clone.md)\n" +"Isso elimina o [Clone para satisfazer o verificador de empréstimo](../anti_patterns/borrow_clone.md)\n" "antipadrão em um caso específico." #: src\idioms/on-stack-dyn-dispatch.md:1 @@ -1867,20 +1602,14 @@ msgstr "# Despacho Dinâmico On-Stack" #: src\idioms/on-stack-dyn-dispatch.md:5 #, fuzzy msgid "" -"We can dynamically dispatch over multiple values, however, to do so, we " -"need\n" -"to declare multiple variables to bind differently-typed objects. To extend " -"the\n" -"lifetime as necessary, we can use deferred conditional initialization, as " -"seen\n" +"We can dynamically dispatch over multiple values, however, to do so, we need\n" +"to declare multiple variables to bind differently-typed objects. To extend the\n" +"lifetime as necessary, we can use deferred conditional initialization, as seen\n" "below:" msgstr "" -"Podemos despachar dinamicamente vários valores, no entanto, para fazer isso, " -"precisamos\n" -"para declarar várias variáveis para vincular objetos de tipos diferentes. " -"Para estender o\n" -"tempo de vida conforme necessário, podemos usar a inicialização condicional " -"adiada, como visto\n" +"Podemos despachar dinamicamente vários valores, no entanto, para fazer isso, precisamos\n" +"para declarar várias variáveis para vincular objetos de tipos diferentes. Para estender o\n" +"tempo de vida conforme necessário, podemos usar a inicialização condicional adiada, como visto\n" "abaixo:" #: src\idioms/on-stack-dyn-dispatch.md:12 @@ -1915,32 +1644,24 @@ msgstr "" #, fuzzy msgid "" "Rust monomorphises code by default. This means a copy of the code will be\n" -"generated for each type it is used with and optimized independently. While " -"this\n" -"allows for very fast code on the hot path, it also bloats the code in " -"places\n" -"where performance is not of the essence, thus costing compile time and " -"cache\n" +"generated for each type it is used with and optimized independently. While this\n" +"allows for very fast code on the hot path, it also bloats the code in places\n" +"where performance is not of the essence, thus costing compile time and cache\n" "usage." msgstr "" -"Rust monomorfiza o código por padrão. Isso significa que uma cópia do código " -"será\n" -"gerado para cada tipo com o qual é usado e otimizado independentemente. " -"Enquanto isso\n" +"Rust monomorfiza o código por padrão. Isso significa que uma cópia do código será\n" +"gerado para cada tipo com o qual é usado e otimizado independentemente. Enquanto isso\n" "permite um código muito rápido no hot path, também incha o código em locais\n" -"onde o desempenho não é essencial, custando assim tempo de compilação e " -"cache\n" +"onde o desempenho não é essencial, custando assim tempo de compilação e cache\n" "uso." #: src\idioms/on-stack-dyn-dispatch.md:45 #, fuzzy msgid "" -"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly " -"ask\n" +"Luckily, Rust allows us to use dynamic dispatch, but we have to explicitly ask\n" "for it." msgstr "" -"Felizmente, o Rust nos permite usar o dispatch dinâmico, mas temos que " -"perguntar explicitamente\n" +"Felizmente, o Rust nos permite usar o dispatch dinâmico, mas temos que perguntar explicitamente\n" "para isso." #: src\idioms/on-stack-dyn-dispatch.md:50 @@ -1977,20 +1698,14 @@ msgstr "" msgid "" "Rust newcomers will usually learn that Rust requires all variables to be\n" "initialized _before use_, so it's easy to overlook the fact that _unused_\n" -"variables may well be uninitialized. Rust works quite hard to ensure that " -"this\n" -"works out fine and only the initialized values are dropped at the end of " -"their\n" +"variables may well be uninitialized. Rust works quite hard to ensure that this\n" +"works out fine and only the initialized values are dropped at the end of their\n" "scope." msgstr "" -"Os recém-chegados ao Rust geralmente aprenderão que o Rust exige que todas " -"as variáveis sejam\n" -"inicializado _antes de usar_, então é fácil ignorar o fato de que _não " -"usado_\n" -"as variáveis podem muito bem ser não inicializadas. Rust trabalha bastante " -"para garantir que este\n" -"funciona bem e apenas os valores inicializados são descartados no final de " -"sua\n" +"Os recém-chegados ao Rust geralmente aprenderão que o Rust exige que todas as variáveis sejam\n" +"inicializado _antes de usar_, então é fácil ignorar o fato de que _não usado_\n" +"as variáveis podem muito bem ser não inicializadas. Rust trabalha bastante para garantir que este\n" +"funciona bem e apenas os valores inicializados são descartados no final de sua\n" "escopo." #: src\idioms/on-stack-dyn-dispatch.md:76 @@ -2002,40 +1717,30 @@ msgstr "O exemplo atende a todas as restrições que Rust nos impõe:" #, fuzzy msgid "" "- All variables are initialized before using (in this case borrowing) them\n" -"- Each variable only holds values of a single type. In our example, `stdin` " -"is\n" -" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut " -"dyn Read`\n" +"- Each variable only holds values of a single type. In our example, `stdin` is\n" +" of type `Stdin`, `file` is of type `File` and `readable` is of type `&mut dyn Read`\n" "- Each borrowed value outlives all the references borrowed from it" msgstr "" -"- Todas as variáveis são inicializadas antes de serem usadas (neste caso, " -"emprestadas)\n" -"- Cada variável contém apenas valores de um único tipo. Em nosso exemplo, " -"`stdin` é\n" -" do tipo `Stdin`, `file` é do tipo `File` e `readable` é do tipo `&mut dyn " -"Read`\n" +"- Todas as variáveis são inicializadas antes de serem usadas (neste caso, emprestadas)\n" +"- Cada variável contém apenas valores de um único tipo. Em nosso exemplo, `stdin` é\n" +" do tipo `Stdin`, `file` é do tipo `File` e `readable` é do tipo `&mut dyn Read`\n" "- Cada valor emprestado sobrevive a todas as referências emprestadas dele" #: src\idioms/on-stack-dyn-dispatch.md:85 #, fuzzy msgid "" "- [Finalisation in destructors](dtor-finally.md) and\n" -" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight " -"control over\n" +" [RAII guards](../patterns/behavioural/RAII.md) can benefit from tight control over\n" " lifetimes.\n" "- For conditionally filled `Option<&T>`s of (mutable) references, one can\n" -" initialize an `Option` directly and use its [`.as_ref()`] method to get " -"an\n" +" initialize an `Option` directly and use its [`.as_ref()`] method to get an\n" " optional reference." msgstr "" "- [Finalização em destruidores](dtor-finally.md) e\n" -" [guardas RAII](../patterns/behavioural/RAII.md) podem se beneficiar de um " -"controle rígido sobre\n" +" [guardas RAII](../patterns/behavioural/RAII.md) podem se beneficiar de um controle rígido sobre\n" " vidas.\n" -"- Para `Option<&T>`s de referências (mutáveis) preenchidas condicionalmente, " -"pode-se\n" -" inicialize um `Option` diretamente e use seu método [`.as_ref()`] para " -"obter um\n" +"- Para `Option<&T>`s de referências (mutáveis) preenchidas condicionalmente, pode-se\n" +" inicialize um `Option` diretamente e use seu método [`.as_ref()`] para obter um\n" " referência opcional." #: src\idioms/ffi/intro.md:1 @@ -2051,15 +1756,13 @@ msgid "" "traps for inexperienced users of `unsafe` Rust." msgstr "" "Escrever código FFI é um curso completo em si.\n" -"No entanto, existem vários idiomas aqui que podem atuar como ponteiros e " -"evitar\n" +"No entanto, existem vários idiomas aqui que podem atuar como ponteiros e evitar\n" "armadilhas para usuários inexperientes de Rust `inseguro`." #: src\idioms/ffi/intro.md:7 #, fuzzy msgid "This section contains idioms that may be useful when doing FFI." -msgstr "" -"Esta seção contém expressões idiomáticas que podem ser úteis ao fazer FFI." +msgstr "Esta seção contém expressões idiomáticas que podem ser úteis ao fazer FFI." #: src\idioms/ffi/intro.md:9 #, fuzzy @@ -2071,12 +1774,10 @@ msgid "" "\n" "3. [Passing Strings](./passing-strings.md) to FFI functions" msgstr "" -"1. [Erros idiomáticos](./errors.md) - Tratamento de erros com códigos " -"inteiros e\n" +"1. [Erros idiomáticos](./errors.md) - Tratamento de erros com códigos inteiros e\n" " valores de retorno do sentinela (como ponteiros `NULL`)\n" "\n" -"2. [Accepting Strings](./accepting-strings.md) com o mínimo de código " -"inseguro\n" +"2. [Accepting Strings](./accepting-strings.md) com o mínimo de código inseguro\n" "\n" "3. [Passing Strings](./passing-strings.md) para funções FFI" @@ -2092,41 +1793,33 @@ msgid "" "However, Rust's type system allows much more rich error information to be\n" "captured and propogated through a full type." msgstr "" -"Em idiomas estrangeiros como C, os erros são representados por códigos de " -"retorno.\n" -"No entanto, o sistema de tipos do Rust permite que informações de erro muito " -"mais ricas sejam\n" +"Em idiomas estrangeiros como C, os erros são representados por códigos de retorno.\n" +"No entanto, o sistema de tipos do Rust permite que informações de erro muito mais ricas sejam\n" "capturado e propagado através de um tipo completo." #: src\idioms/ffi/errors.md:9 #, fuzzy msgid "" -"This best practice shows different kinds of error codes, and how to expose " -"them\n" +"This best practice shows different kinds of error codes, and how to expose them\n" "in a usable way:" msgstr "" -"Esta prática recomendada mostra diferentes tipos de códigos de erro e como " -"expô-los\n" +"Esta prática recomendada mostra diferentes tipos de códigos de erro e como expô-los\n" "de forma utilizável:" #: src\idioms/ffi/errors.md:12 #, fuzzy msgid "" "1. Flat Enums should be converted to integers and returned as codes.\n" -"2. Structured Enums should be converted to an integer code with a string " -"error\n" +"2. Structured Enums should be converted to an integer code with a string error\n" " message for detail.\n" "3. Custom Error Types should become \"transparent\", with a C representation." msgstr "" "1. Flat Enums devem ser convertidos em inteiros e retornados como códigos.\n" -"2. Enums estruturados devem ser convertidos em um código inteiro com um erro " -"de string\n" +"2. Enums estruturados devem ser convertidos em um código inteiro com um erro de string\n" " mensagem para detalhes.\n" -"3. Tipos de erro personalizados devem se tornar \"transparentes\", com uma " -"representação em C." +"3. Tipos de erro personalizados devem se tornar \"transparentes\", com uma representação em C." -#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 -#: src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 +#: src\idioms/ffi/errors.md:17 src\idioms/ffi/accepting-strings.md:29 src\idioms/ffi/passing-strings.md:26 src\patterns/ffi/export.md:40 #: src\patterns/ffi/wrappers.md:23 #, fuzzy msgid "## Code Example" @@ -2189,8 +1882,7 @@ msgid "" " ) -> *mut libc::c_char {\n" "\n" " let error: &DatabaseError = unsafe {\n" -" // SAFETY: pointer lifetime is greater than the current stack " -"frame\n" +" // SAFETY: pointer lifetime is greater than the current stack frame\n" " &*e\n" " };\n" "\n" @@ -2209,8 +1901,7 @@ msgid "" " let c_error = unsafe {\n" " // SAFETY: copying error_str to an allocated buffer with a NUL\n" " // character at the end\n" -" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as " -"*mut _;\n" +" let mut malloc: *mut u8 = libc::malloc(error_str.len() + 1) as *mut _;\n" "\n" " if malloc.is_null() {\n" " return std::ptr::null_mut();\n" @@ -2267,12 +1958,10 @@ msgstr "" #: src\idioms/ffi/errors.md:133 #, fuzzy msgid "" -"This ensures that the foreign language has clear access to error " -"information\n" +"This ensures that the foreign language has clear access to error information\n" "while not compromising the Rust code's API at all." msgstr "" -"Isso garante que o idioma estrangeiro tenha acesso claro às informações de " -"erro\n" +"Isso garante que o idioma estrangeiro tenha acesso claro às informações de erro\n" "sem comprometer a API do código Rust." #: src\idioms/ffi/errors.md:138 @@ -2292,66 +1981,51 @@ msgstr "# Aceitando Strings" #: src\idioms/ffi/accepting-strings.md:5 #, fuzzy msgid "" -"When accepting strings via FFI through pointers, there are two principles " -"that\n" +"When accepting strings via FFI through pointers, there are two principles that\n" "should be followed:" msgstr "" -"Ao aceitar strings via FFI por meio de ponteiros, existem dois princípios " -"que\n" +"Ao aceitar strings via FFI por meio de ponteiros, existem dois princípios que\n" "deve ser seguido:" #: src\idioms/ffi/accepting-strings.md:8 #, fuzzy msgid "" "1. Keep foreign strings \"borrowed\", rather than copying them directly.\n" -"2. Minimize the amount of complexity and `unsafe` code involved in " -"converting\n" +"2. Minimize the amount of complexity and `unsafe` code involved in converting\n" " from a C-style string to native Rust strings." msgstr "" -"1. Mantenha strings estrangeiras \"emprestadas\", em vez de copiá-las " -"diretamente.\n" +"1. Mantenha strings estrangeiras \"emprestadas\", em vez de copiá-las diretamente.\n" "2. Minimize a complexidade e o código \"inseguro\" envolvido na conversão\n" " de uma string estilo C para strings Rust nativas." #: src\idioms/ffi/accepting-strings.md:14 #, fuzzy -msgid "" -"The strings used in C have different behaviours to those used in Rust, " -"namely:" -msgstr "" -"As strings usadas em C possuem comportamentos diferentes das usadas em Rust, " -"a saber:" +msgid "The strings used in C have different behaviours to those used in Rust, namely:" +msgstr "As strings usadas em C possuem comportamentos diferentes das usadas em Rust, a saber:" #: src\idioms/ffi/accepting-strings.md:16 #, fuzzy msgid "" "- C strings are null-terminated while Rust strings store their length\n" -"- C strings can contain any arbitrary non-zero byte while Rust strings must " -"be\n" +"- C strings can contain any arbitrary non-zero byte while Rust strings must be\n" " UTF-8\n" "- C strings are accessed and manipulated using `unsafe` pointer operations\n" " while interactions with Rust strings go through safe methods" msgstr "" -"- As strings C são terminadas em nulo, enquanto as strings Rust armazenam " -"seu comprimento\n" -"- As strings C podem conter qualquer byte arbitrário diferente de zero, " -"enquanto as strings Rust devem ser\n" +"- As strings C são terminadas em nulo, enquanto as strings Rust armazenam seu comprimento\n" +"- As strings C podem conter qualquer byte arbitrário diferente de zero, enquanto as strings Rust devem ser\n" " UTF-8\n" -"- Strings C são acessadas e manipuladas usando operações de ponteiro " -"`inseguras`\n" +"- Strings C são acessadas e manipuladas usando operações de ponteiro `inseguras`\n" " enquanto as interações com strings Rust passam por métodos seguros" #: src\idioms/ffi/accepting-strings.md:22 #, fuzzy msgid "" -"The Rust standard library comes with C equivalents of Rust's `String` and " -"`&str`\n" -"called `CString` and `&CStr`, that allow us to avoid a lot of the " -"complexity\n" +"The Rust standard library comes with C equivalents of Rust's `String` and `&str`\n" +"called `CString` and `&CStr`, that allow us to avoid a lot of the complexity\n" "and `unsafe` code involved in converting between C strings and Rust strings." msgstr "" -"A biblioteca padrão do Rust vem com equivalentes em C de `String` e `&str` " -"do Rust\n" +"A biblioteca padrão do Rust vem com equivalentes em C de `String` e `&str` do Rust\n" "chamados `CString` e `&CStr`, que nos permitem evitar muita complexidade\n" "e código `inseguro` envolvido na conversão entre strings C e strings Rust." @@ -2361,8 +2035,7 @@ msgid "" "The `&CStr` type also allows us to work with borrowed data, meaning passing\n" "strings between Rust and C is a zero-cost operation." msgstr "" -"O tipo `&CStr` também nos permite trabalhar com dados emprestados, ou seja, " -"passar\n" +"O tipo `&CStr` também nos permite trabalhar com dados emprestados, ou seja, passar\n" "strings entre Rust e C é uma operação de custo zero." #: src\idioms/ffi/accepting-strings.md:31 @@ -2418,8 +2091,7 @@ msgid "" " reference" msgstr "" "1. O bloco `unsafe` é o menor possível.\n" -"2. O ponteiro com um tempo de vida \"não rastreado\" torna-se um " -"\"rastreado\" compartilhado\n" +"2. O ponteiro com um tempo de vida \"não rastreado\" torna-se um \"rastreado\" compartilhado\n" " referência" #: src\idioms/ffi/accepting-strings.md:76 @@ -2434,8 +2106,7 @@ msgid "" "\n" " // other module content\n" "\n" -" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: " -"libc::c_int) {\n" +" pub extern \"C\" fn mylib_log(msg: *const libc::c_char, level: libc::c_int) {\n" " // DO NOT USE THIS CODE.\n" " // IT IS UGLY, VERBOSE, AND CONTAINS A SUBTLE BUG.\n" "\n" @@ -2481,8 +2152,7 @@ msgstr "Este código é inferior ao original em dois aspectos:" #: src\idioms/ffi/accepting-strings.md:122 #, fuzzy msgid "" -"1. There is much more `unsafe` code, and more importantly, more invariants " -"it\n" +"1. There is much more `unsafe` code, and more importantly, more invariants it\n" " must uphold.\n" "2. Due to the extensive arithmetic required, there is a bug in this version\n" " that cases Rust `undefined behaviour`." @@ -2495,29 +2165,23 @@ msgstr "" #: src\idioms/ffi/accepting-strings.md:127 #, fuzzy msgid "" -"The bug here is a simple mistake in pointer arithmetic: the string was " -"copied,\n" +"The bug here is a simple mistake in pointer arithmetic: the string was copied,\n" "all `msg_len` bytes of it. However, the `NUL` terminator at the end was not." msgstr "" -"O bug aqui é um erro simples na aritmética do ponteiro: a string foi " -"copiada,\n" -"todos os bytes `msg_len` dele. No entanto, o terminador `NUL` no final não " -"era." +"O bug aqui é um erro simples na aritmética do ponteiro: a string foi copiada,\n" +"todos os bytes `msg_len` dele. No entanto, o terminador `NUL` no final não era." #: src\idioms/ffi/accepting-strings.md:130 #, fuzzy msgid "" -"The Vector then had its size _set_ to the length of the _zero padded string_ " -"--\n" +"The Vector then had its size _set_ to the length of the _zero padded string_ --\n" "rather than _resized_ to it, which could have added a zero at the end.\n" "As a result, the last byte in the Vector is uninitialized memory.\n" "When the `CString` is created at the bottom of the block, its read of the\n" "Vector will cause `undefined behaviour`!" msgstr "" -"O vetor então teve seu tamanho _definido_ para o comprimento da _string " -"preenchida com zero_ --\n" -"em vez de _redimensionado_ a ele, o que poderia ter adicionado um zero no " -"final.\n" +"O vetor então teve seu tamanho _definido_ para o comprimento da _string preenchida com zero_ --\n" +"em vez de _redimensionado_ a ele, o que poderia ter adicionado um zero no final.\n" "Como resultado, o último byte no Vector é memória não inicializada.\n" "Quando o `CString` é criado na parte inferior do bloco, sua leitura do\n" "O vetor causará `comportamento indefinido`!" @@ -2526,8 +2190,7 @@ msgstr "" #, fuzzy msgid "" "Like many such issues, this would be difficult issue to track down.\n" -"Sometimes it would panic because the string was not `UTF-8`, sometimes it " -"would\n" +"Sometimes it would panic because the string was not `UTF-8`, sometimes it would\n" "put a weird character at the end of the string, sometimes it would just\n" "completely crash." msgstr "" @@ -2536,8 +2199,7 @@ msgstr "" "colocar um caractere estranho no final da string, às vezes seria apenas\n" "travar completamente." -#: src\idioms/ffi/accepting-strings.md:143 -#: src\idioms/ffi/passing-strings.md:105 +#: src\idioms/ffi/accepting-strings.md:143 src\idioms/ffi/passing-strings.md:105 #, fuzzy msgid "None?" msgstr "Nenhum?" @@ -2550,8 +2212,7 @@ msgstr "# Passando Cordas" #: src\idioms/ffi/passing-strings.md:5 #, fuzzy msgid "" -"When passing strings to FFI functions, there are four principles that should " -"be\n" +"When passing strings to FFI functions, there are four principles that should be\n" "followed:" msgstr "" "Ao passar strings para funções FFI, existem quatro princípios que devem ser\n" @@ -2562,15 +2223,13 @@ msgstr "" msgid "" "1. Make the lifetime of owned strings as long as possible.\n" "2. Minimize `unsafe` code during the conversion.\n" -"3. If the C code can modify the string data, use `Vec` instead of " -"`CString`.\n" +"3. If the C code can modify the string data, use `Vec` instead of `CString`.\n" "4. Unless the Foreign Function API requires it, the ownership of the string\n" " should not transfer to the callee." msgstr "" "1. Faça com que a vida útil das strings próprias seja a maior possível.\n" "2. Minimize o código `inseguro` durante a conversão.\n" -"3. Se o código C puder modificar os dados da string, use `Vec` em vez de " -"`CString`.\n" +"3. Se o código C puder modificar os dados da string, use `Vec` em vez de `CString`.\n" "4. A menos que a API de função externa exija, a propriedade da string\n" " não deve transferir para o receptor." @@ -2578,32 +2237,25 @@ msgstr "" #, fuzzy msgid "" "Rust has built-in support for C-style strings with its `CString` and `CStr`\n" -"types. However, there are different approaches one can take with strings " -"that\n" +"types. However, there are different approaches one can take with strings that\n" "are being sent to a foreign function call from a Rust function." msgstr "" -"Rust tem suporte embutido para strings no estilo C com seus `CString` e " -"`CStr`\n" -"tipos. No entanto, existem diferentes abordagens que podem ser adotadas com " -"strings que\n" -"estão sendo enviados para uma chamada de função estrangeira de uma função " -"Rust." +"Rust tem suporte embutido para strings no estilo C com seus `CString` e `CStr`\n" +"tipos. No entanto, existem diferentes abordagens que podem ser adotadas com strings que\n" +"estão sendo enviados para uma chamada de função estrangeira de uma função Rust." #: src\idioms/ffi/passing-strings.md:20 #, fuzzy msgid "" "The best practice is simple: use `CString` in such a way as to minimize\n" "`unsafe` code. However, a secondary caveat is that\n" -"_the object must live long enough_, meaning the lifetime should be " -"maximized.\n" -"In addition, the documentation explains that \"round-tripping\" a `CString` " -"after\n" +"_the object must live long enough_, meaning the lifetime should be maximized.\n" +"In addition, the documentation explains that \"round-tripping\" a `CString` after\n" "modification is UB, so additional work is necessary in that case." msgstr "" "A melhor prática é simples: use `CString` de forma a minimizar\n" "código `inseguro`. No entanto, uma advertência secundária é que\n" -"_o objeto deve viver o suficiente_, o que significa que o tempo de vida deve " -"ser maximizado.\n" +"_o objeto deve viver o suficiente_, o que significa que o tempo de vida deve ser maximizado.\n" "Além disso, a documentação explica que \"transmitir\" um `CString` após\n" "modificação é UB, então trabalho adicional é necessário nesse caso." @@ -2616,8 +2268,7 @@ msgid "" "\n" " extern \"C\" {\n" " fn seterr(message: *const libc::c_char);\n" -" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> " -"libc::c_int;\n" +" fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> libc::c_int;\n" " }\n" "\n" " fn report_error_to_ffi>(\n" @@ -2626,8 +2277,7 @@ msgid "" " let c_err = std::ffi::CString::new(err.into())?;\n" "\n" " unsafe {\n" -" // SAFETY: calling an FFI whose documentation says the pointer " -"is\n" +" // SAFETY: calling an FFI whose documentation says the pointer is\n" " // const, so no modification should occur\n" " seterr(c_err.as_ptr());\n" " }\n" @@ -2684,8 +2334,7 @@ msgid "" "\n" " // other module content\n" "\n" -" fn report_error>(err: S) -> Result<(), " -"std::ffi::NulError> {\n" +" fn report_error>(err: S) -> Result<(), std::ffi::NulError> {\n" " unsafe {\n" " // SAFETY: whoops, this contains a dangling pointer!\n" " seterr(std::ffi::CString::new(err.into())?.as_ptr());\n" @@ -2700,31 +2349,24 @@ msgstr "" #, fuzzy msgid "" "This code will result in a dangling pointer, because the lifetime of the\n" -"`CString` is not extended by the pointer creation, unlike if a reference " -"were\n" +"`CString` is not extended by the pointer creation, unlike if a reference were\n" "created." msgstr "" "Este código resultará em um ponteiro pendente, porque o tempo de vida do\n" -"`CString` não é estendido pela criação do ponteiro, ao contrário de uma " -"referência\n" +"`CString` não é estendido pela criação do ponteiro, ao contrário de uma referência\n" "criada." #: src\idioms/ffi/passing-strings.md:98 #, fuzzy msgid "" -"Another issue frequently raised is that the initialization of a 1k vector " -"of\n" +"Another issue frequently raised is that the initialization of a 1k vector of\n" "zeroes is \"slow\". However, recent versions of Rust actually optimize that\n" -"particular macro to a call to `zmalloc`, meaning it is as fast as the " -"operating\n" +"particular macro to a call to `zmalloc`, meaning it is as fast as the operating\n" "system's ability to return zeroed memory (which is quite fast)." msgstr "" -"Outra questão frequentemente levantada é que a inicialização de um vetor 1k " -"de\n" -"zeros é \"lento\". No entanto, versões recentes do Rust realmente otimizam " -"isso\n" -"macro específica para uma chamada para `zmalloc`, o que significa que é tão " -"rápido quanto a operação\n" +"Outra questão frequentemente levantada é que a inicialização de um vetor 1k de\n" +"zeros é \"lento\". No entanto, versões recentes do Rust realmente otimizam isso\n" +"macro específica para uma chamada para `zmalloc`, o que significa que é tão rápido quanto a operação\n" "a capacidade do sistema de retornar memória zerada (o que é bastante rápido)." #: src\idioms/option-iter.md:1 @@ -2740,12 +2382,10 @@ msgid "" "can be used with generic code that needs such a type." msgstr "" "`Option` pode ser visto como um contêiner que contém zero ou um\n" -"elemento. Em particular, ele implementa o recurso `IntoIterator` e, como " -"tal,\n" +"elemento. Em particular, ele implementa o recurso `IntoIterator` e, como tal,\n" "pode ser usado com código genérico que precisa desse tipo." -#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 -#: src\patterns/structural/unsafe-mods.md:22 +#: src\idioms/option-iter.md:9 src\patterns/structural/small-crates.md:34 src\patterns/structural/unsafe-mods.md:22 #, fuzzy msgid "## Examples" msgstr "## Exemplos" @@ -2756,8 +2396,7 @@ msgid "" "Since `Option` implements `IntoIterator`, it can be used as an argument to\n" "[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" msgstr "" -"Como `Option` implementa `IntoIterator`, ele pode ser usado como um " -"argumento para\n" +"Como `Option` implementa `IntoIterator`, ele pode ser usado como um argumento para\n" "[`.extend()`](https://doc.rust-lang.org/std/iter/trait.Extend.html#tymethod.extend):" #: src\idioms/option-iter.md:14 @@ -2779,13 +2418,10 @@ msgstr "" #, fuzzy msgid "" "If you need to tack an `Option` to the end of an existing iterator, you can\n" -"pass it to " -"[`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +"pass it to [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" msgstr "" -"Se você precisar adicionar uma `Option` ao final de um iterador existente, " -"você pode\n" -"passe para " -"[`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" +"Se você precisar adicionar uma `Option` ao final de um iterador existente, você pode\n" +"passe para [`.chain()`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain):" #: src\idioms/option-iter.md:29 msgid "" @@ -2802,8 +2438,7 @@ msgstr "" #: src\idioms/option-iter.md:38 #, fuzzy msgid "" -"Note that if the `Option` is always `Some`, then it is more idiomatic to " -"use\n" +"Note that if the `Option` is always `Some`, then it is more idiomatic to use\n" "[`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) on the\n" "element instead." msgstr "" @@ -2814,56 +2449,42 @@ msgstr "" #: src\idioms/option-iter.md:42 #, fuzzy msgid "" -"Also, since `Option` implements `IntoIterator`, it's possible to iterate " -"over\n" -"it using a `for` loop. This is equivalent to matching it with `if let " -"Some(..)`,\n" +"Also, since `Option` implements `IntoIterator`, it's possible to iterate over\n" +"it using a `for` loop. This is equivalent to matching it with `if let Some(..)`,\n" "and in most cases you should prefer the latter." msgstr "" -"Além disso, como `Option` implementa `IntoIterator`, é possível iterar " -"sobre\n" -"usando um loop `for`. Isso é equivalente a combiná-lo com `if let " -"Some(..)`,\n" +"Além disso, como `Option` implementa `IntoIterator`, é possível iterar sobre\n" +"usando um loop `for`. Isso é equivalente a combiná-lo com `if let Some(..)`,\n" "e na maioria dos casos você deve preferir o último." #: src\idioms/option-iter.md:48 #, fuzzy msgid "" -"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is " -"an\n" -" iterator which yields exactly one element. It's a more readable " -"alternative to\n" +"- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) is an\n" +" iterator which yields exactly one element. It's a more readable alternative to\n" " `Some(foo).into_iter()`.\n" "\n" -"- " -"[`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" -" is a version of " -"[`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" is a version of [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" " specialized to mapping functions which return `Option`.\n" "\n" -"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides " -"functions\n" +"- The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" " for converting an `Option` to a zero- or one-element slice.\n" "\n" -"- [Documentation for " -"`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +"- [Documentation for `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" msgstr "" "- [`std::iter::once`](https://doc.rust-lang.org/std/iter/fn.once.html) é um\n" -" iterator que produz exatamente um elemento. É uma alternativa mais legível " -"para\n" +" iterator que produz exatamente um elemento. É uma alternativa mais legível para\n" " `Some(foo).into_iter()`.\n" "\n" -"- " -"[`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" -" é uma versão do " -"[`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" +"- [`Iterator::filter_map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.filter_map)\n" +" é uma versão do [`Iterator::map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map),\n" " especializado para funções de mapeamento que retornam `Option`.\n" "\n" "- A caixa [`ref_slice`](https://crates.io/crates/ref_slice) fornece funções\n" " para converter uma `Opção` em uma fatia de zero ou um elemento.\n" "\n" -"- [Documentação para " -"`Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" +"- [Documentação para `Option`](https://doc.rust-lang.org/std/option/enum.Option.html)" #: src\idioms/pass-var-to-closure.md:1 #, fuzzy @@ -2874,18 +2495,13 @@ msgstr "# Passa variáveis para encerramento" #, fuzzy msgid "" "By default, closures capture their environment by borrowing. Or you can use\n" -"`move`-closure to move whole environment. However, often you want to move " -"just\n" -"some variables to closure, give it copy of some data, pass it by reference, " -"or\n" +"`move`-closure to move whole environment. However, often you want to move just\n" +"some variables to closure, give it copy of some data, pass it by reference, or\n" "perform some other transformation." msgstr "" -"Por padrão, os fechamentos capturam seu ambiente por empréstimo. Ou você " -"pode usar\n" -"fechamento `move` para mover todo o ambiente. No entanto, muitas vezes você " -"deseja mover apenas\n" -"algumas variáveis para fechamento, dar-lhe cópia de alguns dados, passá-lo " -"por referência ou\n" +"Por padrão, os fechamentos capturam seu ambiente por empréstimo. Ou você pode usar\n" +"fechamento `move` para mover todo o ambiente. No entanto, muitas vezes você deseja mover apenas\n" +"algumas variáveis para fechamento, dar-lhe cópia de alguns dados, passá-lo por referência ou\n" "realizar alguma outra transformação." #: src\idioms/pass-var-to-closure.md:10 @@ -2942,27 +2558,21 @@ msgstr "" #: src\idioms/pass-var-to-closure.md:50 #, fuzzy msgid "" -"Copied data are grouped together with closure definition, so their purpose " -"is\n" -"more clear, and they will be dropped immediately even if they are not " -"consumed\n" +"Copied data are grouped together with closure definition, so their purpose is\n" +"more clear, and they will be dropped immediately even if they are not consumed\n" "by closure." msgstr "" -"Os dados copiados são agrupados com a definição de fechamento, portanto, sua " -"finalidade é\n" -"mais claros, e eles serão descartados imediatamente, mesmo que não sejam " -"consumidos\n" +"Os dados copiados são agrupados com a definição de fechamento, portanto, sua finalidade é\n" +"mais claros, e eles serão descartados imediatamente, mesmo que não sejam consumidos\n" "por fechamento." #: src\idioms/pass-var-to-closure.md:54 #, fuzzy msgid "" -"Closure uses same variable names as surrounding code whether data are copied " -"or\n" +"Closure uses same variable names as surrounding code whether data are copied or\n" "moved." msgstr "" -"Closure usa os mesmos nomes de variáveis que o código ao redor, sejam os " -"dados copiados ou\n" +"Closure usa os mesmos nomes de variáveis que o código ao redor, sejam os dados copiados ou\n" "mudou-se." #: src\idioms/pass-var-to-closure.md:59 @@ -2978,16 +2588,12 @@ msgstr "# `#[non_exhaustive]` e campos privados para extensibilidade" #: src\idioms/priv-extend.md:5 #, fuzzy msgid "" -"A small set of scenarios exist where a library author may want to add " -"public\n" -"fields to a public struct or new variants to an enum without breaking " -"backwards\n" +"A small set of scenarios exist where a library author may want to add public\n" +"fields to a public struct or new variants to an enum without breaking backwards\n" "compatibility." msgstr "" -"Existe um pequeno conjunto de cenários em que um autor de biblioteca pode " -"querer adicionar\n" -"campos para uma estrutura pública ou novas variantes para uma enumeração sem " -"quebrar para trás\n" +"Existe um pequeno conjunto de cenários em que um autor de biblioteca pode querer adicionar\n" +"campos para uma estrutura pública ou novas variantes para uma enumeração sem quebrar para trás\n" "compatibilidade." #: src\idioms/priv-extend.md:9 @@ -2999,22 +2605,17 @@ msgstr "Rust oferece duas soluções para este problema:" #, fuzzy msgid "" "- Use `#[non_exhaustive]` on `struct`s, `enum`s, and `enum` variants.\n" -" For extensive documentation on all the places where `#[non_exhaustive]` " -"can be\n" -" used, see [the " -"docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +" For extensive documentation on all the places where `#[non_exhaustive]` can be\n" +" used, see [the docs](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" "\n" "- You may add a private field to a struct to prevent it from being directly\n" " instantiated or matched against (see Alternative)" msgstr "" "- Use `#[non_exhaustive]` nas variantes `struct`s, `enum`s e `enum`.\n" -" Para documentação extensa sobre todos os lugares onde `#[non_exhaustive]` " -"pode ser\n" -" usado, consulte [os " -"documentos](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" +" Para documentação extensa sobre todos os lugares onde `#[non_exhaustive]` pode ser\n" +" usado, consulte [os documentos](https://doc.rust-lang.org/reference/attributes/type_system.html#the-non_exhaustive-attribute).\n" "\n" -"- Você pode adicionar um campo privado a uma estrutura para evitar que ela " -"seja diretamente\n" +"- Você pode adicionar um campo privado a uma estrutura para evitar que ela seja diretamente\n" " instanciado ou comparado (ver Alternativa)" #: src\idioms/priv-extend.md:20 @@ -3076,43 +2677,33 @@ msgstr "" msgid "" "Adding a field to a struct is a mostly backwards compatible change.\n" "However, if a client uses a pattern to deconstruct a struct instance, they\n" -"might name all the fields in the struct and adding a new one would break " -"that\n" +"might name all the fields in the struct and adding a new one would break that\n" "pattern.\n" -"The client could name some fields and use `..` in the pattern, in which case " -"adding\n" +"The client could name some fields and use `..` in the pattern, in which case adding\n" "another field is backwards compatible.\n" -"Making at least one of the struct's fields private forces clients to use the " -"latter\n" +"Making at least one of the struct's fields private forces clients to use the latter\n" "form of patterns, ensuring that the struct is future-proof." msgstr "" -"Adicionar um campo a uma estrutura é uma alteração compatível com versões " -"anteriores.\n" -"No entanto, se um cliente usar um padrão para desconstruir uma instância " -"struct, ele\n" +"Adicionar um campo a uma estrutura é uma alteração compatível com versões anteriores.\n" +"No entanto, se um cliente usar um padrão para desconstruir uma instância struct, ele\n" "pode nomear todos os campos na estrutura e adicionar um novo quebraria isso\n" "padrão.\n" -"O cliente pode nomear alguns campos e usar `..` no padrão, caso em que " -"adicionar\n" +"O cliente pode nomear alguns campos e usar `..` no padrão, caso em que adicionar\n" "outro campo é compatível com versões anteriores.\n" -"Tornar privado pelo menos um dos campos da estrutura obriga os clientes a " -"usar o último\n" +"Tornar privado pelo menos um dos campos da estrutura obriga os clientes a usar o último\n" "forma de padrões, garantindo que a estrutura seja à prova de futuro." #: src\idioms/priv-extend.md:71 #, fuzzy msgid "" -"The downside of this approach is that you might need to add an otherwise " -"unneeded\n" +"The downside of this approach is that you might need to add an otherwise unneeded\n" "field to the struct.\n" -"You can use the `()` type so that there is no runtime overhead and prepend " -"`_` to\n" +"You can use the `()` type so that there is no runtime overhead and prepend `_` to\n" "the field name to avoid the unused field warning." msgstr "" "A desvantagem dessa abordagem é que você pode precisar adicionar um\n" "campo para a estrutura.\n" -"Você pode usar o tipo `()` para que não haja sobrecarga de tempo de execução " -"e anexar `_` para\n" +"Você pode usar o tipo `()` para que não haja sobrecarga de tempo de execução e anexar `_` para\n" "o nome do campo para evitar o aviso de campo não utilizado." #: src\idioms/priv-extend.md:76 @@ -3120,8 +2711,7 @@ msgid "" "```rust\n" "pub struct S {\n" " pub a: i32,\n" -" // Because `b` is private, you cannot match on `S` without using `..` " -"and `S`\n" +" // Because `b` is private, you cannot match on `S` without using `..` and `S`\n" " // cannot be directly instantiated or matched against\n" " _b: ()\n" "}\n" @@ -3131,60 +2721,44 @@ msgstr "" #: src\idioms/priv-extend.md:87 #, fuzzy msgid "" -"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a " -"backwards\n" +"On `struct`s, `#[non_exhaustive]` allows adding additional fields in a backwards\n" "compatible way.\n" -"It will also prevent clients from using the struct constructor, even if all " -"the\n" +"It will also prevent clients from using the struct constructor, even if all the\n" "fields are public.\n" -"This may be helpful, but it's worth considering if you _want_ an additional " -"field\n" -"to be found by clients as a compiler error rather than something that may be " -"silently\n" +"This may be helpful, but it's worth considering if you _want_ an additional field\n" +"to be found by clients as a compiler error rather than something that may be silently\n" "undiscovered." msgstr "" -"Em `struct`s, `#[non_exhaustive]` permite adicionar campos adicionais de " -"forma inversa\n" +"Em `struct`s, `#[non_exhaustive]` permite adicionar campos adicionais de forma inversa\n" "maneira compatível.\n" -"Também impedirá que os clientes usem o construtor struct, mesmo que todos " -"os\n" +"Também impedirá que os clientes usem o construtor struct, mesmo que todos os\n" "campos são públicos.\n" -"Isso pode ser útil, mas vale a pena considerar se você _quer_ um campo " -"adicional\n" -"ser encontrado pelos clientes como um erro do compilador em vez de algo que " -"pode ser silenciosamente\n" +"Isso pode ser útil, mas vale a pena considerar se você _quer_ um campo adicional\n" +"ser encontrado pelos clientes como um erro do compilador em vez de algo que pode ser silenciosamente\n" "não descoberto." #: src\idioms/priv-extend.md:95 #, fuzzy msgid "" "`#[non_exhaustive]` can be applied to enum variants as well.\n" -"A `#[non_exhaustive]` variant behaves in the same way as a " -"`#[non_exhaustive]` struct." +"A `#[non_exhaustive]` variant behaves in the same way as a `#[non_exhaustive]` struct." msgstr "" "`#[non_exhaustive]` também pode ser aplicado a variantes de enumeração.\n" -"Uma variante `#[non_exhaustive]` se comporta da mesma forma que uma " -"estrutura `#[non_exhaustive]`." +"Uma variante `#[non_exhaustive]` se comporta da mesma forma que uma estrutura `#[non_exhaustive]`." #: src\idioms/priv-extend.md:98 #, fuzzy msgid "" -"Use this deliberately and with caution: incrementing the major version when " -"adding\n" +"Use this deliberately and with caution: incrementing the major version when adding\n" "fields or variants is often a better option.\n" -"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an " -"external\n" -"resource that may change out-of-sync with your library, but is not a general " -"purpose\n" +"`#[non_exhaustive]` may be appropriate in scenarios where you're modeling an external\n" +"resource that may change out-of-sync with your library, but is not a general purpose\n" "tool." msgstr "" -"Use isso deliberadamente e com cautela: incrementando a versão principal ao " -"adicionar\n" +"Use isso deliberadamente e com cautela: incrementando a versão principal ao adicionar\n" "campos ou variantes geralmente é uma opção melhor.\n" -"`#[non_exhaustive]` pode ser apropriado em cenários onde você está modelando " -"um externo\n" -"recurso que pode ficar fora de sincronia com sua biblioteca, mas não é um " -"propósito geral\n" +"`#[non_exhaustive]` pode ser apropriado em cenários onde você está modelando um externo\n" +"recurso que pode ficar fora de sincronia com sua biblioteca, mas não é um propósito geral\n" "ferramenta." #: src\idioms/priv-extend.md:104 @@ -3195,43 +2769,36 @@ msgstr "### Desvantagens" #: src\idioms/priv-extend.md:106 #, fuzzy msgid "" -"`#[non_exhaustive]` can make your code much less ergonomic to use, " -"especially when\n" +"`#[non_exhaustive]` can make your code much less ergonomic to use, especially when\n" "forced to handle unknown enum variants.\n" -"It should only be used when these sorts of evolutions are required " -"**without**\n" +"It should only be used when these sorts of evolutions are required **without**\n" "incrementing the major version." msgstr "" -"`#[non_exhaustive]` pode tornar seu código muito menos ergonômico de usar, " -"especialmente quando\n" +"`#[non_exhaustive]` pode tornar seu código muito menos ergonômico de usar, especialmente quando\n" "forçado a lidar com variantes de enumeração desconhecidas.\n" "Só deve ser usado quando esses tipos de evoluções são necessários **sem**\n" "incrementando a versão principal." #: src\idioms/priv-extend.md:111 msgid "" -"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle " -"a\n" +"When `#[non_exhaustive]` is applied to `enum`s, it forces clients to handle a\n" "wildcard variant.\n" -"If there is no sensible action to take in this case, this may lead to " -"awkward\n" +"If there is no sensible action to take in this case, this may lead to awkward\n" "code and code paths that are only executed in extremely rare circumstances.\n" -"If a client decides to `panic!()` in this scenario, it may have been better " -"to\n" +"If a client decides to `panic!()` in this scenario, it may have been better to\n" "expose this error at compile time.\n" -"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" " -"case;\n" +"In fact, `#[non_exhaustive]` forces clients to handle the \"Something else\" case;\n" "there is rarely a sensible action to take in this scenario." msgstr "" #: src\idioms/priv-extend.md:122 #, fuzzy msgid "" -"- [RFC introducing #[non_exhaustive] attribute for enums and " -"structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-exhaustive.md)" +"- [RFC introducing #[non_exhaustive] attribute for enums and structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" msgstr "" -"- [RFC introduzindo o atributo #[non_exhaustive] para enums e " -"structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-exhaustive.md)" +"- [RFC introduzindo o atributo #[non_exhaustive] para enums e structs](https://github.com/rust-lang/rfcs/blob/master/text/2008-non-" +"exhaustive.md)" #: src\idioms/rustdoc-init.md:1 #, fuzzy @@ -3241,16 +2808,12 @@ msgstr "# Fácil inicialização do documento\r" #: src\idioms/rustdoc-init.md:5 #, fuzzy msgid "" -"If a struct takes significant effort to initialize when writing docs, it can " -"be\r\n" -"quicker to wrap your example with a helper function which takes the struct " -"as an\r\n" +"If a struct takes significant effort to initialize when writing docs, it can be\r\n" +"quicker to wrap your example with a helper function which takes the struct as an\r\n" "argument." msgstr "" -"Se uma estrutura requer um esforço significativo para inicializar ao " -"escrever documentos, pode ser\r\n" -"mais rápido para agrupar seu exemplo com uma função auxiliar que usa a " -"estrutura como um\r\n" +"Se uma estrutura requer um esforço significativo para inicializar ao escrever documentos, pode ser\r\n" +"mais rápido para agrupar seu exemplo com uma função auxiliar que usa a estrutura como um\r\n" "argumento." #: src\idioms/rustdoc-init.md:9 @@ -3261,12 +2824,10 @@ msgstr "## Motivação\r" #: src\idioms/rustdoc-init.md:11 #, fuzzy msgid "" -"Sometimes there is a struct with multiple or complicated parameters and " -"several\r\n" +"Sometimes there is a struct with multiple or complicated parameters and several\r\n" "methods. Each of these methods should have examples." msgstr "" -"Às vezes, há uma estrutura com parâmetros múltiplos ou complicados e " -"vários\r\n" +"Às vezes, há uma estrutura com parâmetros múltiplos ou complicados e vários\r\n" "métodos. Cada um desses métodos deve ter exemplos." #: src\idioms/rustdoc-init.md:14 @@ -3289,10 +2850,8 @@ msgid "" " /// ```no_run\r\n" " /// # // Boilerplate are required to get an example working.\r\n" " /// # let stream = TcpStream::connect(\"127.0.0.1:34254\");\r\n" -" /// # let connection = Connection { name: \"foo\".to_owned(), stream " -"};\r\n" -" /// # let request = Request::new(\"RequestId\", RequestType::Get, " -"\"payload\");\r\n" +" /// # let connection = Connection { name: \"foo\".to_owned(), stream };\r\n" +" /// # let request = Request::new(\"RequestId\", RequestType::Get, \"payload\");\r\n" " /// let response = connection.send_request(request);\r\n" " /// assert!(response.is_ok());\r\n" " /// ```\r\n" @@ -3317,13 +2876,11 @@ msgstr "## Exemplo\r" #, fuzzy msgid "" "Instead of typing all of this boilerplate to create a `Connection` and\r\n" -"`Request`, it is easier to just create a wrapping helper function which " -"takes\r\n" +"`Request`, it is easier to just create a wrapping helper function which takes\r\n" "them as arguments:" msgstr "" "Em vez de digitar todo esse clichê para criar uma `Conexão` e\r\n" -"`Request`, é mais fácil apenas criar uma função auxiliar de empacotamento " -"que leva\r\n" +"`Request`, é mais fácil apenas criar uma função auxiliar de empacotamento que leva\r\n" "como argumentos:" #: src\idioms/rustdoc-init.md:51 @@ -3353,8 +2910,7 @@ msgstr "" #: src\idioms/rustdoc-init.md:73 msgid "" -"**Note** in the above example the line `assert!(response.is_ok());` will " -"not\r\n" +"**Note** in the above example the line `assert!(response.is_ok());` will not\r\n" "actually run while testing because it is inside a function which is never\r\n" "invoked." msgstr "" @@ -3377,19 +2933,13 @@ msgstr "## Desvantagens\r" #: src\idioms/rustdoc-init.md:83 #, fuzzy msgid "" -"As example is in a function, the code will not be tested. Though it will " -"still be\r\n" -"checked to make sure it compiles when running a `cargo test`. So this " -"pattern is\r\n" -"most useful when you need `no_run`. With this, you do not need to add " -"`no_run`." +"As example is in a function, the code will not be tested. Though it will still be\r\n" +"checked to make sure it compiles when running a `cargo test`. So this pattern is\r\n" +"most useful when you need `no_run`. With this, you do not need to add `no_run`." msgstr "" -"Como o exemplo está em uma função, o código não será testado. Embora ainda " -"seja\r\n" -"verificado para garantir que ele compila ao executar um `teste de carga`. " -"Então esse padrão é\r\n" -"mais útil quando você precisa de `no_run`. Com isso, você não precisa " -"adicionar `no_run`." +"Como o exemplo está em uma função, o código não será testado. Embora ainda seja\r\n" +"verificado para garantir que ele compila ao executar um `teste de carga`. Então esse padrão é\r\n" +"mais útil quando você precisa de `no_run`. Com isso, você não precisa adicionar `no_run`." #: src\idioms/rustdoc-init.md:87 #, fuzzy @@ -3404,18 +2954,13 @@ msgstr "Se as asserções não forem necessárias, esse padrão funcionará bem. #: src\idioms/rustdoc-init.md:91 #, fuzzy msgid "" -"If they are, an alternative can be to create a public method to create a " -"helper\r\n" -"instance which is annotated with `#[doc(hidden)]` (so that users won't see " -"it).\r\n" -"Then this method can be called inside of rustdoc because it is part of " -"the\r\n" +"If they are, an alternative can be to create a public method to create a helper\r\n" +"instance which is annotated with `#[doc(hidden)]` (so that users won't see it).\r\n" +"Then this method can be called inside of rustdoc because it is part of the\r\n" "crate's public API." msgstr "" -"Se forem, uma alternativa pode ser criar um método público para criar um " -"auxiliar\r\n" -"instância que é anotada com `#[doc(hidden)]` (para que os usuários não a " -"vejam).\r\n" +"Se forem, uma alternativa pode ser criar um método público para criar um auxiliar\r\n" +"instância que é anotada com `#[doc(hidden)]` (para que os usuários não a vejam).\r\n" "Então este método pode ser chamado dentro do rustdoc porque faz parte do\r\n" "API pública da caixa." @@ -3427,27 +2972,21 @@ msgstr "# Mutabilidade temporária" #: src\idioms/temporary-mutability.md:5 #, fuzzy msgid "" -"Often it is necessary to prepare and process some data, but after that data " -"are\n" -"only inspected and never modified. The intention can be made explicit by " -"redefining\n" +"Often it is necessary to prepare and process some data, but after that data are\n" +"only inspected and never modified. The intention can be made explicit by redefining\n" "the mutable variable as immutable." msgstr "" -"Muitas vezes é necessário preparar e processar alguns dados, mas depois " -"disso os dados são\n" -"apenas inspecionado e nunca modificado. A intenção pode ser tornada " -"explícita redefinindo\n" +"Muitas vezes é necessário preparar e processar alguns dados, mas depois disso os dados são\n" +"apenas inspecionado e nunca modificado. A intenção pode ser tornada explícita redefinindo\n" "a variável mutável como imutável." #: src\idioms/temporary-mutability.md:9 #, fuzzy msgid "" -"It can be done either by processing data within a nested block or by " -"redefining\n" +"It can be done either by processing data within a nested block or by redefining\n" "the variable." msgstr "" -"Isso pode ser feito processando dados dentro de um bloco aninhado ou " -"redefinindo\n" +"Isso pode ser feito processando dados dentro de um bloco aninhado ou redefinindo\n" "a variável." #: src\idioms/temporary-mutability.md:14 @@ -3491,11 +3030,8 @@ msgstr "" #: src\idioms/temporary-mutability.md:40 #, fuzzy -msgid "" -"Compiler ensures that you don't accidentally mutate data after some point." -msgstr "" -"O compilador garante que você não modifique dados acidentalmente após algum " -"ponto." +msgid "Compiler ensures that you don't accidentally mutate data after some point." +msgstr "O compilador garante que você não modifique dados acidentalmente após algum ponto." #: src\idioms/temporary-mutability.md:44 #, fuzzy @@ -3514,12 +3050,10 @@ msgstr "# Retorna o argumento consumido em caso de erro" #: src\idioms/return-consumed-arg-on-error.md:5 #, fuzzy msgid "" -"If a fallible function consumes (moves) an argument, return that argument " -"back inside\n" +"If a fallible function consumes (moves) an argument, return that argument back inside\n" "an error." msgstr "" -"Se uma função falível consumir (mover) um argumento, retorne esse argumento " -"para dentro\n" +"Se uma função falível consumir (mover) um argumento, retorne esse argumento para dentro\n" "um erro." #: src\idioms/return-consumed-arg-on-error.md:10 @@ -3529,8 +3063,7 @@ msgid "" " println!(\"using {value} in a meaningful way\");\n" " // Simulate non-deterministic fallible action.\n" " use std::time::SystemTime;\n" -" let period = " -"SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" +" let period = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();\n" " if period.subsec_nanos() % 2 == 1 {\n" " Ok(())\n" " } else {\n" @@ -3580,12 +3113,10 @@ msgid "" "is returned.\n" "You can get original vector back using `FromUtf8Error::into_bytes` method." msgstr "" -"A biblioteca padrão usa esta abordagem em, por exemplo, Método " -"`String::from_utf8`.\n" +"A biblioteca padrão usa esta abordagem em, por exemplo, Método `String::from_utf8`.\n" "Quando dado um vetor que não contém UTF-8 válido, um `FromUtf8Error`\n" "é devolvido.\n" -"Você pode recuperar o vetor original usando o método " -"`FromUtf8Error::into_bytes`." +"Você pode recuperar o vetor original usando o método `FromUtf8Error::into_bytes`." #: src\idioms/return-consumed-arg-on-error.md:57 #, fuzzy @@ -3605,24 +3136,17 @@ msgstr "# Padrões de design" #: src\patterns/index.md:3 #, fuzzy msgid "" -"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) " -"are\n" +"[Design patterns](https://en.wikipedia.org/wiki/Software_design_pattern) are\n" "\"general reusable solutions to a commonly occurring problem within a given\n" -"context in software design\". Design patterns are a great way to describe " -"the\n" -"culture of a programming language. Design patterns are very " -"language-specific -\n" +"context in software design\". Design patterns are a great way to describe the\n" +"culture of a programming language. Design patterns are very language-specific -\n" "what is a pattern in one language may be unnecessary in another due to a\n" "language feature, or impossible to express due to a missing feature." msgstr "" -"[Padrões de design](https://en.wikipedia.org/wiki/Software_design_pattern) " -"são\n" -"“soluções gerais reutilizáveis para um problema que ocorre comumente dentro " -"de um determinado\n" -"contexto no design de software\". Os padrões de design são uma ótima maneira " -"de descrever o\n" -"cultura de uma linguagem de programação. Os padrões de design são muito " -"específicos da linguagem -\n" +"[Padrões de design](https://en.wikipedia.org/wiki/Software_design_pattern) são\n" +"“soluções gerais reutilizáveis para um problema que ocorre comumente dentro de um determinado\n" +"contexto no design de software\". Os padrões de design são uma ótima maneira de descrever o\n" +"cultura de uma linguagem de programação. Os padrões de design são muito específicos da linguagem -\n" "o que é um padrão em um idioma pode ser desnecessário em outro devido a uma\n" "recurso de linguagem ou impossível de expressar devido a um recurso ausente." @@ -3630,28 +3154,21 @@ msgstr "" #, fuzzy msgid "" "If overused, design patterns can add unnecessary complexity to programs.\n" -"However, they are a great way to share intermediate and advanced level " -"knowledge\n" +"However, they are a great way to share intermediate and advanced level knowledge\n" "about a programming language." msgstr "" -"Se usados em excesso, os padrões de projeto podem adicionar complexidade " -"desnecessária aos programas.\n" -"No entanto, eles são uma ótima maneira de compartilhar conhecimentos de " -"nível intermediário e avançado\n" +"Se usados em excesso, os padrões de projeto podem adicionar complexidade desnecessária aos programas.\n" +"No entanto, eles são uma ótima maneira de compartilhar conhecimentos de nível intermediário e avançado\n" "sobre uma linguagem de programação." #: src\patterns/index.md:16 #, fuzzy msgid "" -"Rust has many unique features. These features give us great benefit by " -"removing\n" -"whole classes of problems. Some of them are also patterns that are _unique_ " -"to Rust." +"Rust has many unique features. These features give us great benefit by removing\n" +"whole classes of problems. Some of them are also patterns that are _unique_ to Rust." msgstr "" -"Rust tem muitos recursos exclusivos. Esses recursos nos dão grande benefício " -"ao remover\n" -"classes inteiras de problemas. Alguns deles também são padrões _exclusivos_ " -"do Rust." +"Rust tem muitos recursos exclusivos. Esses recursos nos dão grande benefício ao remover\n" +"classes inteiras de problemas. Alguns deles também são padrões _exclusivos_ do Rust." #: src\patterns/index.md:19 #, fuzzy @@ -3665,8 +3182,7 @@ msgid "" "It's a vital software design principle to apply as you write code." msgstr "" "YAGNI é um acrônimo que significa `You Are not Going to Need It`.\n" -"É um princípio de design de software vital a ser aplicado enquanto você " -"escreve o código." +"É um princípio de design de software vital a ser aplicado enquanto você escreve o código." #: src\patterns/index.md:24 #, fuzzy @@ -3676,19 +3192,13 @@ msgstr "> O melhor código que já escrevi foi um código que nunca escrevi." #: src\patterns/index.md:26 #, fuzzy msgid "" -"If we apply YAGNI to design patterns, we see that the features of Rust allow " -"us to\n" -"throw out many patterns. For instance, there is no need for the [strategy " -"pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"in Rust because we can just use " -"[traits](https://doc.rust-lang.org/book/traits.html)." +"If we apply YAGNI to design patterns, we see that the features of Rust allow us to\n" +"throw out many patterns. For instance, there is no need for the [strategy pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"in Rust because we can just use [traits](https://doc.rust-lang.org/book/traits.html)." msgstr "" -"Se aplicarmos o YAGNI aos padrões de projeto, veremos que os recursos do " -"Rust nos permitem\n" -"jogue fora muitos padrões. Por exemplo, não há necessidade do [padrão de " -"estratégia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"em Rust porque podemos usar apenas " -"[traits](https://doc.rust-lang.org/book/traits.html)." +"Se aplicarmos o YAGNI aos padrões de projeto, veremos que os recursos do Rust nos permitem\n" +"jogue fora muitos padrões. Por exemplo, não há necessidade do [padrão de estratégia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"em Rust porque podemos usar apenas [traits](https://doc.rust-lang.org/book/traits.html)." #: src\patterns/behavioural/intro.md:1 #, fuzzy @@ -3703,15 +3213,11 @@ msgstr "Da [Wikipedia](https://en.wikipedia.org/wiki/Behavioral_pattern):" #: src\patterns/behavioural/intro.md:5 #, fuzzy msgid "" -"> Design patterns that identify common communication patterns among " -"objects.\n" -"> By doing so, these patterns increase flexibility in carrying out " -"communication." +"> Design patterns that identify common communication patterns among objects.\n" +"> By doing so, these patterns increase flexibility in carrying out communication." msgstr "" -"> Padrões de design que identificam padrões comuns de comunicação entre " -"objetos.\n" -"> Ao fazer isso, esses padrões aumentam a flexibilidade na realização da " -"comunicação." +"> Padrões de design que identificam padrões comuns de comunicação entre objetos.\n" +"> Ao fazer isso, esses padrões aumentam a flexibilidade na realização da comunicação." #: src\patterns/behavioural/command.md:1 #, fuzzy @@ -3721,8 +3227,7 @@ msgstr "# Comando" #: src\patterns/behavioural/command.md:5 #, fuzzy msgid "" -"The basic idea of the Command pattern is to separate out actions into its " -"own\n" +"The basic idea of the Command pattern is to separate out actions into its own\n" "objects and pass them as parameters." msgstr "" "A ideia básica do padrão Command é separar as ações em seu próprio\n" @@ -3731,50 +3236,34 @@ msgstr "" #: src\patterns/behavioural/command.md:10 #, fuzzy msgid "" -"Suppose we have a sequence of actions or transactions encapsulated as " -"objects.\n" -"We want these actions or commands to be executed or invoked in some order " -"later\n" -"at different time. These commands may also be triggered as a result of some " -"event.\n" +"Suppose we have a sequence of actions or transactions encapsulated as objects.\n" +"We want these actions or commands to be executed or invoked in some order later\n" +"at different time. These commands may also be triggered as a result of some event.\n" "For example, when a user pushes a button, or on arrival of a data packet.\n" "In addition, these commands might be undoable. This may come in useful for\n" -"operations of an editor. We might want to store logs of executed commands so " -"that\n" +"operations of an editor. We might want to store logs of executed commands so that\n" "we could reapply the changes later if the system crashes." msgstr "" -"Suponha que tenhamos uma sequência de ações ou transações encapsuladas como " -"objetos.\n" -"Queremos que essas ações ou comandos sejam executados ou invocados em alguma " -"ordem posteriormente\n" -"em tempo diferente. Esses comandos também podem ser acionados como resultado " -"de algum evento.\n" -"Por exemplo, quando um usuário pressiona um botão ou na chegada de um pacote " -"de dados.\n" +"Suponha que tenhamos uma sequência de ações ou transações encapsuladas como objetos.\n" +"Queremos que essas ações ou comandos sejam executados ou invocados em alguma ordem posteriormente\n" +"em tempo diferente. Esses comandos também podem ser acionados como resultado de algum evento.\n" +"Por exemplo, quando um usuário pressiona um botão ou na chegada de um pacote de dados.\n" "Além disso, esses comandos podem ser desfeitos. Isso pode ser útil para\n" -"operações de um editor. Podemos querer armazenar logs de comandos executados " -"para que\n" +"operações de um editor. Podemos querer armazenar logs de comandos executados para que\n" "poderíamos reaplicar as alterações mais tarde se o sistema travar." #: src\patterns/behavioural/command.md:20 #, fuzzy msgid "" -"Define two database operations `create table` and `add field`. Each of " -"these\n" -"operations is a command which knows how to undo the command, e.g., `drop " -"table`\n" -"and `remove field`. When a user invokes a database migration operation then " -"each\n" -"command is executed in the defined order, and when the user invokes the " -"rollback\n" +"Define two database operations `create table` and `add field`. Each of these\n" +"operations is a command which knows how to undo the command, e.g., `drop table`\n" +"and `remove field`. When a user invokes a database migration operation then each\n" +"command is executed in the defined order, and when the user invokes the rollback\n" "operation then the whole set of commands is invoked in reverse order." msgstr "" -"Defina duas operações de banco de dados `create table` e `add field`. Cada " -"um desses\n" -"operações é um comando que sabe como desfazer o comando, por exemplo, `drop " -"table`\n" -"e `remover campo`. Quando um usuário invoca uma operação de migração de " -"banco de dados, cada\n" +"Defina duas operações de banco de dados `create table` e `add field`. Cada um desses\n" +"operações é um comando que sabe como desfazer o comando, por exemplo, `drop table`\n" +"e `remover campo`. Quando um usuário invoca uma operação de migração de banco de dados, cada\n" "comando é executado na ordem definida e quando o usuário invoca o rollback\n" "operação, então todo o conjunto de comandos é invocado na ordem inversa." @@ -3789,10 +3278,8 @@ msgid "" "We define a common trait which encapsulates our command with two operations\n" "`execute` and `rollback`. All command `structs` must implement this trait." msgstr "" -"Definimos uma característica comum que encapsula nosso comando com duas " -"operações\n" -"`execute` e `rollback`. Todos os `structs` de comando devem implementar esta " -"característica." +"Definimos uma característica comum que encapsula nosso comando com duas operações\n" +"`execute` e `rollback`. Todos os `structs` de comando devem implementar esta característica." #: src\patterns/behavioural/command.md:31 msgid "" @@ -3870,18 +3357,14 @@ msgstr "## Abordagem: Usando ponteiros de função" #, fuzzy msgid "" "We could follow another approach by creating each individual command as\n" -"a different function and store function pointers to invoke these functions " -"later\n" -"at a different time. Since function pointers implement all three traits " -"`Fn`,\n" +"a different function and store function pointers to invoke these functions later\n" +"at a different time. Since function pointers implement all three traits `Fn`,\n" "`FnMut`, and `FnOnce` we could as well pass and store closures instead of\n" "function pointers." msgstr "" "Poderíamos seguir outra abordagem criando cada comando individual como\n" -"uma função diferente e armazenar ponteiros de função para invocar essas " -"funções mais tarde\n" -"em um momento diferente. Como os ponteiros de função implementam todas as " -"três características `Fn`,\n" +"uma função diferente e armazenar ponteiros de função para invocar essas funções mais tarde\n" +"em um momento diferente. Como os ponteiros de função implementam todas as três características `Fn`,\n" "`FnMut` e `FnOnce`, poderíamos passar e armazenar encerramentos em vez de\n" "ponteiros de função." @@ -3927,8 +3410,7 @@ msgid "" "\n" "fn main() {\n" " let mut schema = Schema::new();\n" -" schema.add_migration(|| \"create table\".to_string(), || \"drop " -"table\".to_string());\n" +" schema.add_migration(|| \"create table\".to_string(), || \"drop table\".to_string());\n" " schema.add_migration(add_field, remove_field);\n" " assert_eq!(vec![\"create table\", \"add field\"], schema.execute());\n" " assert_eq!(vec![\"remove field\", \"drop table\"], schema.rollback());\n" @@ -3947,8 +3429,7 @@ msgid "" "Finally, instead of defining a common command trait we could store\n" "each command implementing the `Fn` trait separately in vectors." msgstr "" -"Finalmente, em vez de definir um traço de comando comum, poderíamos " -"armazenar\n" +"Finalmente, em vez de definir um traço de comando comum, poderíamos armazenar\n" "cada comando implementando o traço `Fn` separadamente em vetores." #: src\patterns/behavioural/command.md:155 @@ -4005,59 +3486,47 @@ msgstr "" #: src\patterns/behavioural/command.md:205 #, fuzzy msgid "" -"If our commands are small and may be defined as functions or passed as a " -"closure\n" +"If our commands are small and may be defined as functions or passed as a closure\n" "then using function pointers might be preferable since it does not exploit\n" -"dynamic dispatch. But if our command is a whole struct with a bunch of " -"functions\n" +"dynamic dispatch. But if our command is a whole struct with a bunch of functions\n" "and variables defined as seperated module then using trait objects would be\n" -"more suitable. A case of application can be found in " -"[`actix`](https://actix.rs/),\n" +"more suitable. A case of application can be found in [`actix`](https://actix.rs/),\n" "which uses trait objects when it registers a handler function for routes.\n" -"In case of using `Fn` trait objects we can create and use commands in the " -"same\n" +"In case of using `Fn` trait objects we can create and use commands in the same\n" "way as we used in case of function pointers." msgstr "" -"Se nossos comandos são pequenos e podem ser definidos como funções ou " -"passados como encerramento\n" +"Se nossos comandos são pequenos e podem ser definidos como funções ou passados como encerramento\n" "usar ponteiros de função pode ser preferível, pois não explora\n" -"despacho dinâmico. Mas se nosso comando for uma estrutura inteira com um " -"monte de funções\n" -"e variáveis definidas como módulo separado, então usar objetos de " -"característica seria\n" -"mais adequado. Um caso de aplicação pode ser encontrado em " -"[`actix`](https://actix.rs/),\n" +"despacho dinâmico. Mas se nosso comando for uma estrutura inteira com um monte de funções\n" +"e variáveis definidas como módulo separado, então usar objetos de característica seria\n" +"mais adequado. Um caso de aplicação pode ser encontrado em [`actix`](https://actix.rs/),\n" "que usa objetos trait quando registra uma função de manipulador para rotas.\n" -"No caso de usar objetos de característica `Fn`, podemos criar e usar " -"comandos no mesmo\n" +"No caso de usar objetos de característica `Fn`, podemos criar e usar comandos no mesmo\n" "maneira como usamos no caso de ponteiros de função." #: src\patterns/behavioural/command.md:214 #, fuzzy msgid "" "As performance, there is always a trade-off between performance and code\n" -"simplicity and organisation. Static dispatch gives faster performance, " -"while\n" +"simplicity and organisation. Static dispatch gives faster performance, while\n" "dynamic dispatch provides flexibility when we structure our application." msgstr "" "Como desempenho, sempre há uma troca entre desempenho e código\n" -"simplicidade e organização. O despacho estático oferece desempenho mais " -"rápido, enquanto\n" -"o despacho dinâmico fornece flexibilidade quando estruturamos nosso " -"aplicativo." +"simplicidade e organização. O despacho estático oferece desempenho mais rápido, enquanto\n" +"o despacho dinâmico fornece flexibilidade quando estruturamos nosso aplicativo." #: src\patterns/behavioural/command.md:220 #, fuzzy msgid "" "- [Command pattern](https://en.wikipedia.org/wiki/Command_pattern)\n" "\n" -"- [Another example for the `command` " -"pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-rust)" +"- [Another example for the `command` pattern](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-" +"pattern-rust)" msgstr "" "- [Padrão de comando](https://en.wikipedia.org/wiki/Command_pattern)\n" "\n" -"- [Outro exemplo para o padrão " -"`command`](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-rust)" +"- [Outro exemplo para o padrão `command`](https://web.archive.org/web/20210223131236/https://chercher.tech/rust/command-design-pattern-" +"rust)" #: src\patterns/behavioural/interpreter.md:1 #, fuzzy @@ -4067,18 +3536,13 @@ msgstr "# Intérprete" #: src\patterns/behavioural/interpreter.md:5 #, fuzzy msgid "" -"If a problem occurs very often and requires long and repetitive steps to " -"solve\n" -"it, then the problem instances might be expressed in a simple language and " -"an\n" -"interpreter object could solve it by interpreting the sentences written in " -"this\n" +"If a problem occurs very often and requires long and repetitive steps to solve\n" +"it, then the problem instances might be expressed in a simple language and an\n" +"interpreter object could solve it by interpreting the sentences written in this\n" "simple language." msgstr "" -"Se um problema ocorre com muita frequência e requer etapas longas e " -"repetitivas para resolver\n" -"isso, então as instâncias do problema podem ser expressas em uma linguagem " -"simples e um\n" +"Se um problema ocorre com muita frequência e requer etapas longas e repetitivas para resolver\n" +"isso, então as instâncias do problema podem ser expressas em uma linguagem simples e um\n" "objeto intérprete poderia resolvê-lo interpretando as frases escritas neste\n" "linguagem simples." @@ -4090,33 +3554,26 @@ msgstr "Basicamente, para qualquer tipo de problema definimos:" #: src\patterns/behavioural/interpreter.md:12 #, fuzzy msgid "" -"- A [domain specific " -"language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- A [domain specific language](https://en.wikipedia.org/wiki/Domain-specific_language),\n" "- A grammar for this language,\n" "- An interpreter that solves the problem instances." msgstr "" -"- Um [idioma específico do " -"domínio](https://en.wikipedia.org/wiki/Domain-specific_language),\n" +"- Um [idioma específico do domínio](https://en.wikipedia.org/wiki/Domain-specific_language),\n" "- Uma gramática para esta linguagem,\n" "- Um interpretador que resolve as instâncias do problema." #: src\patterns/behavioural/interpreter.md:18 #, fuzzy msgid "" -"Our goal is to translate simple mathematical expressions into postfix " -"expressions\n" -"(or [Reverse Polish " -"notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Our goal is to translate simple mathematical expressions into postfix expressions\n" +"(or [Reverse Polish notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" "For simplicity, our expressions consist of ten digits `0`, ..., `9` and two\n" "operations `+`, `-`. For example, the expression `2 + 4` is translated into\n" "`2 4 +`." msgstr "" -"Nosso objetivo é traduzir expressões matemáticas simples em expressões " -"pós-fixadas\n" -"(ou [notação polonesa " -"reversa](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" -"Para simplificar, nossas expressões consistem em dez dígitos `0`, ..., `9` e " -"dois\n" +"Nosso objetivo é traduzir expressões matemáticas simples em expressões pós-fixadas\n" +"(ou [notação polonesa reversa](https://en.wikipedia.org/wiki/Reverse_Polish_notation))\n" +"Para simplificar, nossas expressões consistem em dez dígitos `0`, ..., `9` e dois\n" "operações `+`, `-`. Por exemplo, a expressão `2 + 4` é traduzida para\n" "`2 4 +`." @@ -4128,16 +3585,12 @@ msgstr "## Gramática livre de contexto para o nosso problema" #: src\patterns/behavioural/interpreter.md:26 #, fuzzy msgid "" -"Our task is translating infix expressions into postfix ones. Let's define a " -"context\n" -"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and " -"`-`,\n" +"Our task is translating infix expressions into postfix ones. Let's define a context\n" +"free grammar for a set of infix expressions over `0`, ..., `9`, `+`, and `-`,\n" "where:" msgstr "" -"Nossa tarefa é traduzir expressões infixas em pós-fixadas. Vamos definir um " -"contexto\n" -"gramática livre para um conjunto de expressões infixas sobre `0`, ..., `9`, " -"`+` e `-`,\n" +"Nossa tarefa é traduzir expressões infixas em pós-fixadas. Vamos definir um contexto\n" +"gramática livre para um conjunto de expressões infixas sobre `0`, ..., `9`, `+` e `-`,\n" "onde:" #: src\patterns/behavioural/interpreter.md:30 @@ -4166,19 +3619,16 @@ msgstr "" #: src\patterns/behavioural/interpreter.md:42 #, fuzzy msgid "" -"**NOTE:** This grammar should be further transformed depending on what we " -"are going\n" -"to do with it. For example, we might need to remove left recursion. For " -"more\n" -"details please see [Compilers: Principles,Techniques, and " -"Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools)\n" +"**NOTE:** This grammar should be further transformed depending on what we are going\n" +"to do with it. For example, we might need to remove left recursion. For more\n" +"details please see [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques," +"_and_Tools)\n" "(aka Dragon Book)." msgstr "" "**NOTA:** Esta gramática deve ser transformada dependendo do que vamos\n" -"fazer com isso. Por exemplo, podemos precisar remover a recursão à esquerda. " -"Para mais\n" -"detalhes, consulte [Compilers: Principles,Techniques, and " -"Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools)\n" +"fazer com isso. Por exemplo, podemos precisar remover a recursão à esquerda. Para mais\n" +"detalhes, consulte [Compilers: Principles,Techniques, and Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques," +"_and_Tools)\n" "(também conhecido como Livro do Dragão)." #: src\patterns/behavioural/interpreter.md:47 @@ -4189,16 +3639,12 @@ msgstr "## Solução" #: src\patterns/behavioural/interpreter.md:49 #, fuzzy msgid "" -"We simply implement a recursive descent parser. For simplicity's sake, the " -"code\n" -"panics when an expression is syntactically wrong (for example `2-34` or " -"`2+5-`\n" +"We simply implement a recursive descent parser. For simplicity's sake, the code\n" +"panics when an expression is syntactically wrong (for example `2-34` or `2+5-`\n" "are wrong according to the grammar definition)." msgstr "" -"Simplesmente implementamos um analisador descendente recursivo. Para " -"simplificar, o código\n" -"entra em pânico quando uma expressão está sintaticamente errada (por exemplo " -"`2-34` ou `2+5-`\n" +"Simplesmente implementamos um analisador descendente recursivo. Para simplificar, o código\n" +"entra em pânico quando uma expressão está sintaticamente errada (por exemplo `2-34` ou `2+5-`\n" "estão errados de acordo com a definição gramatical)." #: src\patterns/behavioural/interpreter.md:53 @@ -4257,28 +3703,18 @@ msgstr "" #: src\patterns/behavioural/interpreter.md:105 #, fuzzy msgid "" -"There may be a wrong perception that the Interpreter design pattern is about " -"design\n" -"grammars for formal languages and implementation of parsers for these " -"grammars.\n" -"In fact, this pattern is about expressing problem instances in a more " -"specific\n" -"way and implementing functions/classes/structs that solve these problem " -"instances.\n" -"Rust language has `macro_rules!` that allow us to define special syntax and " -"rules\n" +"There may be a wrong perception that the Interpreter design pattern is about design\n" +"grammars for formal languages and implementation of parsers for these grammars.\n" +"In fact, this pattern is about expressing problem instances in a more specific\n" +"way and implementing functions/classes/structs that solve these problem instances.\n" +"Rust language has `macro_rules!` that allow us to define special syntax and rules\n" "on how to expand this syntax into source code." msgstr "" -"Pode haver uma percepção errada de que o padrão de projeto Interpreter é " -"sobre design\n" -"gramáticas para linguagens formais e implementação de parsers para essas " -"gramáticas.\n" -"Na verdade, esse padrão é sobre expressar instâncias de problemas de uma " -"forma mais específica.\n" -"maneira e implementando funções/classes/estruturas que resolvem essas " -"instâncias do problema.\n" -"A linguagem Rust tem `macro_rules!` que nos permite definir sintaxe e regras " -"especiais\n" +"Pode haver uma percepção errada de que o padrão de projeto Interpreter é sobre design\n" +"gramáticas para linguagens formais e implementação de parsers para essas gramáticas.\n" +"Na verdade, esse padrão é sobre expressar instâncias de problemas de uma forma mais específica.\n" +"maneira e implementando funções/classes/estruturas que resolvem essas instâncias do problema.\n" +"A linguagem Rust tem `macro_rules!` que nos permite definir sintaxe e regras especiais\n" "sobre como expandir essa sintaxe no código-fonte." #: src\patterns/behavioural/interpreter.md:112 @@ -4286,19 +3722,14 @@ msgstr "" msgid "" "In the following example we create a simple `macro_rules!` that computes\n" "[Euclidean length](https://en.wikipedia.org/wiki/Euclidean_distance) of `n`\n" -"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and " -"more\n" -"efficient than packing `x,1,2` into a `Vec` and calling a function " -"computing\n" +"dimensional vectors. Writing `norm!(x,1,2)` might be easier to express and more\n" +"efficient than packing `x,1,2` into a `Vec` and calling a function computing\n" "the length." msgstr "" "No exemplo a seguir, criamos um `macro_rules!` simples que calcula\n" -"[Comprimento euclidiano](https://en.wikipedia.org/wiki/Euclidean_distance) " -"de `n`\n" -"vetores dimensionais. Escrever `norma!(x,1,2)` pode ser mais fácil de " -"expressar e mais\n" -"eficiente do que empacotar `x,1,2` em um `Vec` e chamar uma função de " -"computação\n" +"[Comprimento euclidiano](https://en.wikipedia.org/wiki/Euclidean_distance) de `n`\n" +"vetores dimensionais. Escrever `norma!(x,1,2)` pode ser mais fácil de expressar e mais\n" +"eficiente do que empacotar `x,1,2` em um `Vec` e chamar uma função de computação\n" "O comprimento." #: src\patterns/behavioural/interpreter.md:118 @@ -4332,13 +3763,11 @@ msgstr "" #, fuzzy msgid "" "- [Interpreter pattern](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" -"- [Context free " -"grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [Context free grammar](https://en.wikipedia.org/wiki/Context-free_grammar)\n" "- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" msgstr "" "- [Padrão de intérprete](https://en.wikipedia.org/wiki/Interpreter_pattern)\n" -"- [Gramática livre de " -"contexto](https://en.wikipedia.org/wiki/Context-free_grammar)\n" +"- [Gramática livre de contexto](https://en.wikipedia.org/wiki/Context-free_grammar)\n" "- [macro_rules!](https://doc.rust-lang.org/rust-by-example/macros.html)" #: src\patterns/behavioural/newtype.md:1 @@ -4353,43 +3782,35 @@ msgid "" "enforce some behaviour at compile time when using only type aliases would\n" "not be enough?" msgstr "" -"E se em alguns casos quisermos que um tipo se comporte de maneira semelhante " -"a outro tipo ou\n" -"impor algum comportamento em tempo de compilação ao usar apenas aliases de " -"tipo\n" +"E se em alguns casos quisermos que um tipo se comporte de maneira semelhante a outro tipo ou\n" +"impor algum comportamento em tempo de compilação ao usar apenas aliases de tipo\n" "não ser suficiente?" #: src\patterns/behavioural/newtype.md:7 #, fuzzy msgid "" -"For example, if we want to create a custom `Display` implementation for " -"`String`\n" +"For example, if we want to create a custom `Display` implementation for `String`\n" "due to security considerations (e.g. passwords)." msgstr "" -"Por exemplo, se quisermos criar uma implementação `Display` personalizada " -"para `String`\n" +"Por exemplo, se quisermos criar uma implementação `Display` personalizada para `String`\n" "devido a considerações de segurança (por exemplo, senhas)." #: src\patterns/behavioural/newtype.md:10 #, fuzzy msgid "" -"For such cases we could use the `Newtype` pattern to provide **type " -"safety**\n" +"For such cases we could use the `Newtype` pattern to provide **type safety**\n" "and **encapsulation**." msgstr "" -"Para tais casos, poderíamos usar o padrão `Newtype` para fornecer ** " -"segurança de tipo **\n" +"Para tais casos, poderíamos usar o padrão `Newtype` para fornecer ** segurança de tipo **\n" "e **encapsulamento**." #: src\patterns/behavioural/newtype.md:15 #, fuzzy msgid "" -"Use a tuple struct with a single field to make an opaque wrapper for a " -"type.\n" +"Use a tuple struct with a single field to make an opaque wrapper for a type.\n" "This creates a new type, rather than an alias to a type (`type` items)." msgstr "" -"Use uma estrutura de tupla com um único campo para criar um wrapper opaco " -"para um tipo.\n" +"Use uma estrutura de tupla com um único campo para criar um wrapper opaco para um tipo.\n" "Isso cria um novo tipo, em vez de um alias para um tipo (itens `type`)." #: src\patterns/behavioural/newtype.md:20 @@ -4435,19 +3856,14 @@ msgstr "" #, fuzzy msgid "" "The primary motivation for newtypes is abstraction. It allows you to share\n" -"implementation details between types while precisely controlling the " -"interface.\n" -"By using a newtype rather than exposing the implementation type as part of " -"an\n" +"implementation details between types while precisely controlling the interface.\n" +"By using a newtype rather than exposing the implementation type as part of an\n" "API, it allows you to change implementation backwards compatibly." msgstr "" -"A principal motivação para newtypes é a abstração. Ele permite que você " -"compartilhe\n" -"detalhes de implementação entre tipos enquanto controla com precisão a " -"interface.\n" +"A principal motivação para newtypes é a abstração. Ele permite que você compartilhe\n" +"detalhes de implementação entre tipos enquanto controla com precisão a interface.\n" "Usando um newtype em vez de expor o tipo de implementação como parte de um\n" -"API, permite que você altere a implementação de forma compatível com versões " -"anteriores." +"API, permite que você altere a implementação de forma compatível com versões anteriores." #: src\patterns/behavioural/newtype.md:63 #, fuzzy @@ -4455,89 +3871,69 @@ msgid "" "Newtypes can be used for distinguishing units, e.g., wrapping `f64` to give\n" "distinguishable `Miles` and `Kilometres`." msgstr "" -"Newtypes podem ser usados para distinguir unidades, por exemplo, agrupando " -"`f64` para dar\n" +"Newtypes podem ser usados para distinguir unidades, por exemplo, agrupando `f64` para dar\n" "distinguíveis 'Milhas' e 'Quilômetros'." #: src\patterns/behavioural/newtype.md:68 #, fuzzy msgid "" "The wrapped and wrapper types are not type compatible (as opposed to using\n" -"`type`), so users of the newtype will never 'confuse' the wrapped and " -"wrapper\n" +"`type`), so users of the newtype will never 'confuse' the wrapped and wrapper\n" "types." msgstr "" "Os tipos wrapper e wrapper não são compatíveis (ao contrário de usar\n" -"`type`), então os usuários do newtype nunca irão 'confundir' o wrapper e o " -"wrapper\n" +"`type`), então os usuários do newtype nunca irão 'confundir' o wrapper e o wrapper\n" "tipos." #: src\patterns/behavioural/newtype.md:72 #, fuzzy msgid "Newtypes are a zero-cost abstraction - there is no runtime overhead." -msgstr "" -"Newtypes são uma abstração de custo zero - não há sobrecarga de tempo de " -"execução." +msgstr "Newtypes são uma abstração de custo zero - não há sobrecarga de tempo de execução." #: src\patterns/behavioural/newtype.md:74 #, fuzzy msgid "" -"The privacy system ensures that users cannot access the wrapped type (if " -"the\n" +"The privacy system ensures that users cannot access the wrapped type (if the\n" "field is private, which it is by default)." msgstr "" -"O sistema de privacidade garante que os usuários não possam acessar o tipo " -"encapsulado (se o\n" +"O sistema de privacidade garante que os usuários não possam acessar o tipo encapsulado (se o\n" "campo é privado, o que é por padrão)." #: src\patterns/behavioural/newtype.md:79 #, fuzzy msgid "" -"The downside of newtypes (especially compared with type aliases), is that " -"there\n" -"is no special language support. This means there can be _a lot_ of " -"boilerplate.\n" +"The downside of newtypes (especially compared with type aliases), is that there\n" +"is no special language support. This means there can be _a lot_ of boilerplate.\n" "You need a 'pass through' method for every method you want to expose on the\n" -"wrapped type, and an impl for every trait you want to also be implemented " -"for\n" +"wrapped type, and an impl for every trait you want to also be implemented for\n" "the wrapper type." msgstr "" -"A desvantagem de newtypes (especialmente em comparação com aliases de tipo) " -"é que há\n" -"não há suporte de idioma especial. Isso significa que pode haver _muito_ " -"clichê.\n" -"Você precisa de um método 'pass through' para cada método que deseja expor " -"no\n" -"tipo embrulhado e um impl para cada característica que você deseja que " -"também seja implementado para\n" +"A desvantagem de newtypes (especialmente em comparação com aliases de tipo) é que há\n" +"não há suporte de idioma especial. Isso significa que pode haver _muito_ clichê.\n" +"Você precisa de um método 'pass through' para cada método que deseja expor no\n" +"tipo embrulhado e um impl para cada característica que você deseja que também seja implementado para\n" "o tipo de invólucro." #: src\patterns/behavioural/newtype.md:87 #, fuzzy msgid "" -"Newtypes are very common in Rust code. Abstraction or representing units are " -"the\n" +"Newtypes are very common in Rust code. Abstraction or representing units are the\n" "most common uses, but they can be used for other reasons:" msgstr "" -"Newtypes são muito comuns em código Rust. Unidades de abstração ou " -"representação são as\n" +"Newtypes são muito comuns em código Rust. Unidades de abstração ou representação são as\n" "usos mais comuns, mas podem ser usados por outros motivos:" #: src\patterns/behavioural/newtype.md:90 #, fuzzy msgid "" -"- restricting functionality (reduce the functions exposed or traits " -"implemented),\n" +"- restricting functionality (reduce the functions exposed or traits implemented),\n" "- making a type with copy semantics have move semantics,\n" -"- abstraction by providing a more concrete type and thus hiding internal " -"types,\n" +"- abstraction by providing a more concrete type and thus hiding internal types,\n" " e.g.," msgstr "" -"- funcionalidade restritiva (reduzir as funções expostas ou características " -"implementadas),\n" +"- funcionalidade restritiva (reduzir as funções expostas ou características implementadas),\n" "- fazer um tipo com semântica de cópia tem semântica de movimento,\n" -"- abstração ao fornecer um tipo mais concreto e, assim, ocultar os tipos " -"internos,\n" +"- abstração ao fornecer um tipo mais concreto e, assim, ocultar os tipos internos,\n" " por exemplo.," #: src\patterns/behavioural/newtype.md:95 @@ -4550,47 +3946,34 @@ msgstr "" #: src\patterns/behavioural/newtype.md:99 #, fuzzy msgid "" -"Here, `Bar` might be some public, generic type and `T1` and `T2` are some " -"internal\n" -"types. Users of our module shouldn't know that we implement `Foo` by using a " -"`Bar`,\n" -"but what we're really hiding here is the types `T1` and `T2`, and how they " -"are used\n" +"Here, `Bar` might be some public, generic type and `T1` and `T2` are some internal\n" +"types. Users of our module shouldn't know that we implement `Foo` by using a `Bar`,\n" +"but what we're really hiding here is the types `T1` and `T2`, and how they are used\n" "with `Bar`." msgstr "" -"Aqui, `Bar` pode ser algum tipo público e genérico e `T1` e `T2` são alguns " -"tipos internos\n" -"tipos. Os usuários do nosso módulo não devem saber que implementamos `Foo` " -"usando um `Bar`,\n" -"mas o que realmente estamos escondendo aqui são os tipos `T1` e `T2`, e como " -"eles são usados\n" +"Aqui, `Bar` pode ser algum tipo público e genérico e `T1` e `T2` são alguns tipos internos\n" +"tipos. Os usuários do nosso módulo não devem saber que implementamos `Foo` usando um `Bar`,\n" +"mas o que realmente estamos escondendo aqui são os tipos `T1` e `T2`, e como eles são usados\n" "com 'Barra'." #: src\patterns/behavioural/newtype.md:106 #, fuzzy msgid "" -"- [Advanced Types in the " -"book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-type-safety-and-abstraction)\n" +"- [Advanced Types in the book](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-" +"for-type-safety-and-abstraction)\n" "- [Newtypes in Haskell](https://wiki.haskell.org/Newtype)\n" -"- [Type " -"aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" -"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving " -"many\n" +"- [Type aliases](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), a crate for deriving many\n" " builtin traits on newtypes.\n" -"- [The Newtype Pattern In " -"Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +"- [The Newtype Pattern In Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" msgstr "" -"- [Tipos avançados no " -"livro](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-for-type-safety " -"-e-abstração)\n" +"- [Tipos avançados no livro](https://doc.rust-lang.org/book/ch19-04-advanced-types.html?highlight=newtype#using-the-newtype-pattern-" +"for-type-safety -e-abstração)\n" "- [Novos tipos em Haskell](https://wiki.haskell.org/Newtype)\n" -"- [aliases de " -"tipo](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" -"- [derive_more](https://crates.io/crates/derive_more), uma caixa para " -"derivar muitos\n" +"- [aliases de tipo](https://doc.rust-lang.org/stable/book/ch19-04-advanced-types.html#creating-type-synonyms-with-type-aliases)\n" +"- [derive_more](https://crates.io/crates/derive_more), uma caixa para derivar muitos\n" " traços embutidos em novos tipos.\n" -"- [O padrão Newtype em " -"Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" +"- [O padrão Newtype em Rust](https://www.worthe-it.co.za/blog/2020-10-31-newtype-pattern-in-rust.html)" #: src\patterns/behavioural/RAII.md:1 #, fuzzy @@ -4600,32 +3983,22 @@ msgstr "# RAII com guardas" #: src\patterns/behavioural/RAII.md:5 #, fuzzy msgid "" -"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" " -"which is a\n" -"terrible name. The essence of the pattern is that resource initialisation is " -"done\n" -"in the constructor of an object and finalisation in the destructor. This " -"pattern\n" -"is extended in Rust by using a RAII object as a guard of some resource and " -"relying\n" -"on the type system to ensure that access is always mediated by the guard " -"object." -msgstr "" -"[RAII][wikipedia] significa \"Resource Acquisition is Initialisation\" que é " -"um\n" -"nome terrível. A essência do padrão é que a inicialização do recurso é " -"feita\n" +"[RAII][wikipedia] stands for \"Resource Acquisition is Initialisation\" which is a\n" +"terrible name. The essence of the pattern is that resource initialisation is done\n" +"in the constructor of an object and finalisation in the destructor. This pattern\n" +"is extended in Rust by using a RAII object as a guard of some resource and relying\n" +"on the type system to ensure that access is always mediated by the guard object." +msgstr "" +"[RAII][wikipedia] significa \"Resource Acquisition is Initialisation\" que é um\n" +"nome terrível. A essência do padrão é que a inicialização do recurso é feita\n" "no construtor de um objeto e a finalização no destruidor. Esse padrão\n" -"é estendido em Rust usando um objeto RAII como guarda de algum recurso e " -"contando\n" -"no sistema de tipos para garantir que o acesso seja sempre mediado pelo " -"objeto de guarda." +"é estendido em Rust usando um objeto RAII como guarda de algum recurso e contando\n" +"no sistema de tipos para garantir que o acesso seja sempre mediado pelo objeto de guarda." #: src\patterns/behavioural/RAII.md:13 #, fuzzy msgid "" -"Mutex guards are the classic example of this pattern from the std library " -"(this\n" +"Mutex guards are the classic example of this pattern from the std library (this\n" "is a simplified version of the real implementation):" msgstr "" "Mutex guards são o exemplo clássico deste padrão da biblioteca std (este\n" @@ -4682,12 +4055,10 @@ msgid "" "fn baz(x: Mutex) {\n" " let xx = x.lock();\n" " xx.foo(); // foo is a method on Foo.\n" -" // The borrow checker ensures we can't store a reference to the " -"underlying\n" +" // The borrow checker ensures we can't store a reference to the underlying\n" " // Foo which will outlive the guard xx.\n" "\n" -" // x is unlocked when we exit this function and xx's destructor is " -"executed.\n" +" // x is unlocked when we exit this function and xx's destructor is executed.\n" "}\n" "```" msgstr "" @@ -4696,20 +4067,17 @@ msgstr "" #, fuzzy msgid "" "Where a resource must be finalised after use, RAII can be used to do this\n" -"finalisation. If it is an error to access that resource after finalisation, " -"then\n" +"finalisation. If it is an error to access that resource after finalisation, then\n" "this pattern can be used to prevent such errors." msgstr "" -"Onde um recurso deve ser finalizado após o uso, o RAII pode ser usado para " -"fazer isso\n" +"Onde um recurso deve ser finalizado após o uso, o RAII pode ser usado para fazer isso\n" "finalização. Se for um erro acessar esse recurso após a finalização, então\n" "esse padrão pode ser usado para evitar tais erros." #: src\patterns/behavioural/RAII.md:80 #, fuzzy msgid "" -"Prevents errors where a resource is not finalised and where a resource is " -"used\n" +"Prevents errors where a resource is not finalised and where a resource is used\n" "after finalisation." msgstr "" "Evita erros onde um recurso não é finalizado e onde um recurso é usado\n" @@ -4719,41 +4087,30 @@ msgstr "" #, fuzzy msgid "" "RAII is a useful pattern for ensuring resources are properly deallocated or\n" -"finalised. We can make use of the borrow checker in Rust to statically " -"prevent\n" +"finalised. We can make use of the borrow checker in Rust to statically prevent\n" "errors stemming from using resources after finalisation takes place." msgstr "" -"RAII é um padrão útil para garantir que os recursos sejam devidamente " -"desalocados ou\n" -"finalizado. Podemos usar o verificador de empréstimo no Rust para prevenir " -"estaticamente\n" +"RAII é um padrão útil para garantir que os recursos sejam devidamente desalocados ou\n" +"finalizado. Podemos usar o verificador de empréstimo no Rust para prevenir estaticamente\n" "erros decorrentes do uso de recursos após a finalização." #: src\patterns/behavioural/RAII.md:89 #, fuzzy msgid "" -"The core aim of the borrow checker is to ensure that references to data do " -"not\n" +"The core aim of the borrow checker is to ensure that references to data do not\n" "outlive that data. The RAII guard pattern works because the guard object\n" "contains a reference to the underlying resource and only exposes such\n" -"references. Rust ensures that the guard cannot outlive the underlying " -"resource\n" -"and that references to the resource mediated by the guard cannot outlive " -"the\n" -"guard. To see how this works it is helpful to examine the signature of " -"`deref`\n" +"references. Rust ensures that the guard cannot outlive the underlying resource\n" +"and that references to the resource mediated by the guard cannot outlive the\n" +"guard. To see how this works it is helpful to examine the signature of `deref`\n" "without lifetime elision:" msgstr "" -"O principal objetivo do verificador de empréstimos é garantir que as " -"referências aos dados não\n" -"sobreviver a esses dados. O padrão de guarda RAII funciona porque o objeto " -"de guarda\n" +"O principal objetivo do verificador de empréstimos é garantir que as referências aos dados não\n" +"sobreviver a esses dados. O padrão de guarda RAII funciona porque o objeto de guarda\n" "contém uma referência ao recurso subjacente e apenas expõe tal\n" -"referências. A ferrugem garante que o guarda não sobreviva ao recurso " -"subjacente\n" +"referências. A ferrugem garante que o guarda não sobreviva ao recurso subjacente\n" "e que as referências ao recurso mediado pela guarda não podem sobreviver ao\n" -"guarda. Para ver como isso funciona, é útil examinar a assinatura de " -"`deref`\n" +"guarda. Para ver como isso funciona, é útil examinar a assinatura de `deref`\n" "sem elisão vitalícia:" #: src\patterns/behavioural/RAII.md:97 @@ -4768,31 +4125,23 @@ msgstr "" #: src\patterns/behavioural/RAII.md:103 #, fuzzy msgid "" -"The returned reference to the resource has the same lifetime as `self` " -"(`'a`).\n" -"The borrow checker therefore ensures that the lifetime of the reference to " -"`T`\n" +"The returned reference to the resource has the same lifetime as `self` (`'a`).\n" +"The borrow checker therefore ensures that the lifetime of the reference to `T`\n" "is shorter than the lifetime of `self`." msgstr "" -"A referência retornada ao recurso tem o mesmo tempo de vida que `self` " -"(`'a`).\n" -"O verificador de empréstimo, portanto, garante que o tempo de vida da " -"referência a `T`\n" +"A referência retornada ao recurso tem o mesmo tempo de vida que `self` (`'a`).\n" +"O verificador de empréstimo, portanto, garante que o tempo de vida da referência a `T`\n" "é mais curto que o tempo de vida de `self`." #: src\patterns/behavioural/RAII.md:107 #, fuzzy msgid "" -"Note that implementing `Deref` is not a core part of this pattern, it only " -"makes\n" -"using the guard object more ergonomic. Implementing a `get` method on the " -"guard\n" +"Note that implementing `Deref` is not a core part of this pattern, it only makes\n" +"using the guard object more ergonomic. Implementing a `get` method on the guard\n" "works just as well." msgstr "" -"Observe que a implementação de `Deref` não é uma parte essencial desse " -"padrão, apenas torna\n" -"usando o objeto de guarda mais ergonômico. Implementando um método `get` no " -"guarda\n" +"Observe que a implementação de `Deref` não é uma parte essencial desse padrão, apenas torna\n" +"usando o objeto de guarda mais ergonômico. Implementando um método `get` no guarda\n" "funciona tão bem." #: src\patterns/behavioural/RAII.md:113 @@ -4803,23 +4152,19 @@ msgstr "[Finalização no idioma dos destruidores](../../idioms/dtor-finally.md) #: src\patterns/behavioural/RAII.md:115 #, fuzzy msgid "" -"RAII is a common pattern in C++: " -"[cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"RAII is a common pattern in C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" "[wikipedia][wikipedia]." msgstr "" -"RAII é um padrão comum em C++: " -"[cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" +"RAII é um padrão comum em C++: [cppreference.com](http://en.cppreference.com/w/cpp/language/raii),\n" "[wikipedia][wikipedia]." #: src\patterns/behavioural/RAII.md:120 #, fuzzy msgid "" -"[Style guide " -"entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"[Style guide entry](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" "(currently just a placeholder)." msgstr "" -"[Entrada do guia de " -"estilo](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" +"[Entrada do guia de estilo](https://doc.rust-lang.org/1.0.0/style/ownership/raii.html)\n" "(atualmente apenas um espaço reservado)." #: src\patterns/behavioural/strategy.md:1 @@ -4830,94 +4175,68 @@ msgstr "# Estratégia (também conhecida como Política)" #: src\patterns/behavioural/strategy.md:5 #, fuzzy msgid "" -"The [Strategy design " -"pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"The [Strategy design pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" "is a technique that enables separation of concerns.\n" -"It also allows to decouple software modules through [Dependency " -"Inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +"It also allows to decouple software modules through [Dependency Inversion](https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." msgstr "" -"O [padrão de design de " -"estratégia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" +"O [padrão de design de estratégia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" "é uma técnica que permite a separação de preocupações.\n" -"Também permite desacoplar módulos de software por meio de [Inversão de " -"dependência](https://en.wikipedia.org/wiki/Dependency_inversion_principle)." +"Também permite desacoplar módulos de software por meio de [Inversão de dependência](https://en.wikipedia.org/wiki/" +"Dependency_inversion_principle)." #: src\patterns/behavioural/strategy.md:9 #, fuzzy msgid "" -"The basic idea behind the Strategy pattern is that, given an algorithm " -"solving\n" -"a particular problem, we define only the skeleton of the algorithm at an " -"abstract\n" -"level, and we separate the specific algorithm’s implementation into " -"different parts." +"The basic idea behind the Strategy pattern is that, given an algorithm solving\n" +"a particular problem, we define only the skeleton of the algorithm at an abstract\n" +"level, and we separate the specific algorithm’s implementation into different parts." msgstr "" -"A ideia básica por trás do padrão Strategy é que, dado um algoritmo " -"resolvendo\n" -"um problema particular, definimos apenas o esqueleto do algoritmo em um " -"resumo\n" -"nível, e separamos a implementação do algoritmo específico em diferentes " -"partes." +"A ideia básica por trás do padrão Strategy é que, dado um algoritmo resolvendo\n" +"um problema particular, definimos apenas o esqueleto do algoritmo em um resumo\n" +"nível, e separamos a implementação do algoritmo específico em diferentes partes." #: src\patterns/behavioural/strategy.md:13 #, fuzzy msgid "" -"In this way, a client using the algorithm may choose a specific " -"implementation,\n" -"while the general algorithm workflow remains the same. In other words, the " -"abstract\n" -"specification of the class does not depend on the specific implementation of " -"the\n" -"derived class, but specific implementation must adhere to the abstract " -"specification.\n" +"In this way, a client using the algorithm may choose a specific implementation,\n" +"while the general algorithm workflow remains the same. In other words, the abstract\n" +"specification of the class does not depend on the specific implementation of the\n" +"derived class, but specific implementation must adhere to the abstract specification.\n" "This is why we call it \"Dependency Inversion\"." msgstr "" -"Desta forma, um cliente usando o algoritmo pode escolher uma implementação " -"específica,\n" -"enquanto o fluxo de trabalho do algoritmo geral permanece o mesmo. Em outras " -"palavras, o resumo\n" +"Desta forma, um cliente usando o algoritmo pode escolher uma implementação específica,\n" +"enquanto o fluxo de trabalho do algoritmo geral permanece o mesmo. Em outras palavras, o resumo\n" "especificação da classe não depende da implementação específica do\n" -"classe derivada, mas a implementação específica deve aderir à especificação " -"abstrata.\n" +"classe derivada, mas a implementação específica deve aderir à especificação abstrata.\n" "É por isso que chamamos de \"Inversão de Dependência\"." #: src\patterns/behavioural/strategy.md:21 #, fuzzy msgid "" "Imagine we are working on a project that generates reports every month.\n" -"We need the reports to be generated in different formats (strategies), " -"e.g.,\n" +"We need the reports to be generated in different formats (strategies), e.g.,\n" "in `JSON` or `Plain Text` formats.\n" -"But things vary over time, and we don't know what kind of requirement we may " -"get\n" -"in the future. For example, we may need to generate our report in a " -"completely new\n" +"But things vary over time, and we don't know what kind of requirement we may get\n" +"in the future. For example, we may need to generate our report in a completely new\n" "format, or just modify one of the existing formats." msgstr "" -"Imagine que estamos trabalhando em um projeto que gera relatórios todos os " -"meses.\n" -"Precisamos que os relatórios sejam gerados em diferentes formatos " -"(estratégias), por exemplo,\n" +"Imagine que estamos trabalhando em um projeto que gera relatórios todos os meses.\n" +"Precisamos que os relatórios sejam gerados em diferentes formatos (estratégias), por exemplo,\n" "nos formatos `JSON` ou `Texto Simples`.\n" -"Mas as coisas variam ao longo do tempo e não sabemos que tipo de exigência " -"podemos obter\n" -"no futuro. Por exemplo, podemos precisar gerar nosso relatório em um formato " -"completamente novo\n" +"Mas as coisas variam ao longo do tempo e não sabemos que tipo de exigência podemos obter\n" +"no futuro. Por exemplo, podemos precisar gerar nosso relatório em um formato completamente novo\n" "formato, ou apenas modifique um dos formatos existentes." #: src\patterns/behavioural/strategy.md:30 #, fuzzy msgid "" -"In this example our invariants (or abstractions) are `Context`, " -"`Formatter`,\n" -"and `Report`, while `Text` and `Json` are our strategy structs. These " -"strategies\n" +"In this example our invariants (or abstractions) are `Context`, `Formatter`,\n" +"and `Report`, while `Text` and `Json` are our strategy structs. These strategies\n" "have to implement the `Formatter` trait." msgstr "" -"Neste exemplo, nossas invariantes (ou abstrações) são `Context`, " -"`Formatter`,\n" -"e `Report`, enquanto `Text` e `Json` são nossas estruturas de estratégia. " -"Essas estratégias\n" +"Neste exemplo, nossas invariantes (ou abstrações) são `Context`, `Formatter`,\n" +"e `Report`, enquanto `Text` e `Json` são nossas estruturas de estratégia. Essas estratégias\n" "tem que implementar o trait `Formatter`." #: src\patterns/behavioural/strategy.md:34 @@ -4934,8 +4253,7 @@ msgid "" "struct Report;\n" "\n" "impl Report {\n" -" // Write should be used but we kept it as String to ignore error " -"handling\n" +" // Write should be used but we kept it as String to ignore error handling\n" " fn generate(g: T, s: &mut String) {\n" " // backend operations...\n" " let mut data = HashMap::new();\n" @@ -4950,8 +4268,7 @@ msgid "" "impl Formatter for Text {\n" " fn format(&self, data: &Data, buf: &mut String) {\n" " for (k, v) in data {\n" -" let entry = format!(\"{} {}\\n" -"\", k, v);\n" +" let entry = format!(\"{} {}\\n\", k, v);\n" " buf.push_str(&entry);\n" " }\n" " }\n" @@ -4990,37 +4307,27 @@ msgstr "" #: src\patterns/behavioural/strategy.md:98 #, fuzzy msgid "" -"The main advantage is separation of concerns. For example, in this case " -"`Report`\n" +"The main advantage is separation of concerns. For example, in this case `Report`\n" "does not know anything about specific implementations of `Json` and `Text`,\n" -"whereas the output implementations does not care about how data is " -"preprocessed,\n" -"stored, and fetched. The only thing they have to know is context and a " -"specific\n" +"whereas the output implementations does not care about how data is preprocessed,\n" +"stored, and fetched. The only thing they have to know is context and a specific\n" "trait and method to implement, i.e,`Formatter` and `run`." msgstr "" -"A principal vantagem é a separação de interesses. Por exemplo, neste caso " -"`Relatório`\n" +"A principal vantagem é a separação de interesses. Por exemplo, neste caso `Relatório`\n" "não sabe nada sobre implementações específicas de `Json` e `Text`,\n" -"considerando que as implementações de saída não se preocupam com a forma " -"como os dados são pré-processados,\n" -"armazenado e obtido. A única coisa que eles precisam saber é o contexto e " -"um\n" +"considerando que as implementações de saída não se preocupam com a forma como os dados são pré-processados,\n" +"armazenado e obtido. A única coisa que eles precisam saber é o contexto e um\n" "trait e método para implementar, ou seja, `Formatter` e `run`." #: src\patterns/behavioural/strategy.md:106 #, fuzzy msgid "" -"For each strategy there must be implemented at least one module, so number " -"of modules\n" -"increases with number of strategies. If there are many strategies to choose " -"from\n" +"For each strategy there must be implemented at least one module, so number of modules\n" +"increases with number of strategies. If there are many strategies to choose from\n" "then users have to know how strategies differ from one another." msgstr "" -"Para cada estratégia deve ser implementado pelo menos um módulo, então o " -"número de módulos\n" -"aumenta com o número de estratégias. Se houver muitas estratégias para " -"escolher\n" +"Para cada estratégia deve ser implementado pelo menos um módulo, então o número de módulos\n" +"aumenta com o número de estratégias. Se houver muitas estratégias para escolher\n" "então os usuários precisam saber como as estratégias diferem umas das outras." #: src\patterns/behavioural/strategy.md:112 @@ -5029,70 +4336,51 @@ msgid "" "In the previous example all strategies are implemented in a single file.\n" "Ways of providing different strategies includes:" msgstr "" -"No exemplo anterior todas as estratégias são implementadas em um único " -"arquivo.\n" +"No exemplo anterior todas as estratégias são implementadas em um único arquivo.\n" "Formas de fornecer diferentes estratégias incluem:" #: src\patterns/behavioural/strategy.md:115 #, fuzzy msgid "" -"- All in one file (as shown in this example, similar to being separated as " -"modules)\n" -"- Separated as modules, E.g. `formatter::json` module, `formatter::text` " -"module\n" +"- All in one file (as shown in this example, similar to being separated as modules)\n" +"- Separated as modules, E.g. `formatter::json` module, `formatter::text` module\n" "- Use compiler feature flags, E.g. `json` feature, `text` feature\n" "- Separated as crates, E.g. `json` crate, `text` crate" msgstr "" -"- Tudo em um arquivo (conforme mostrado neste exemplo, semelhante a ser " -"separado como módulos)\n" -"- Separados como módulos, por ex. módulo `formatter::json`, módulo " -"`formatter::text`\n" -"- Use sinalizadores de recursos do compilador, por exemplo recurso `json`, " -"recurso `texto`\n" +"- Tudo em um arquivo (conforme mostrado neste exemplo, semelhante a ser separado como módulos)\n" +"- Separados como módulos, por ex. módulo `formatter::json`, módulo `formatter::text`\n" +"- Use sinalizadores de recursos do compilador, por exemplo recurso `json`, recurso `texto`\n" "- Separados como caixotes, por ex. caixa `json`, caixa `text`" #: src\patterns/behavioural/strategy.md:120 #, fuzzy msgid "" -"Serde crate is a good example of the `Strategy` pattern in action. Serde " -"allows\n" -"[full customization](https://serde.rs/custom-serialization.html) of the " -"serialization\n" -"behavior by manually implementing `Serialize` and `Deserialize` traits for " -"our\n" -"type. For example, we could easily swap `serde_json` with `serde_cbor` since " -"they\n" -"expose similar methods. Having this makes the helper crate `serde_transcode` " -"much\n" +"Serde crate is a good example of the `Strategy` pattern in action. Serde allows\n" +"[full customization](https://serde.rs/custom-serialization.html) of the serialization\n" +"behavior by manually implementing `Serialize` and `Deserialize` traits for our\n" +"type. For example, we could easily swap `serde_json` with `serde_cbor` since they\n" +"expose similar methods. Having this makes the helper crate `serde_transcode` much\n" "more useful and ergonomic." msgstr "" "Serde crate é um bom exemplo do padrão `Strategy` em ação. Serde permite\n" -"[customização completa](https://serde.rs/custom-serialization.html) da " -"serialização\n" -"comportamento implementando manualmente as características `Serialize` e " -"`Deserialize` para o nosso\n" -"tipo. Por exemplo, poderíamos facilmente trocar `serde_json` por " -"`serde_cbor` já que eles\n" -"expor métodos semelhantes. Ter isso faz com que o auxiliar crie " -"`serde_transcode` muito\n" +"[customização completa](https://serde.rs/custom-serialization.html) da serialização\n" +"comportamento implementando manualmente as características `Serialize` e `Deserialize` para o nosso\n" +"tipo. Por exemplo, poderíamos facilmente trocar `serde_json` por `serde_cbor` já que eles\n" +"expor métodos semelhantes. Ter isso faz com que o auxiliar crie `serde_transcode` muito\n" "mais útil e ergonômico." #: src\patterns/behavioural/strategy.md:127 #, fuzzy -msgid "" -"However, we don't need to use traits in order to design this pattern in Rust." -msgstr "" -"No entanto, não precisamos usar traits para projetar esse padrão no Rust." +msgid "However, we don't need to use traits in order to design this pattern in Rust." +msgstr "No entanto, não precisamos usar traits para projetar esse padrão no Rust." #: src\patterns/behavioural/strategy.md:129 #, fuzzy msgid "" -"The following toy example demonstrates the idea of the Strategy pattern " -"using Rust\n" +"The following toy example demonstrates the idea of the Strategy pattern using Rust\n" "`closures`:" msgstr "" -"O exemplo de brinquedo a seguir demonstra a ideia do padrão Strategy usando " -"Rust\n" +"O exemplo de brinquedo a seguir demonstra a ideia do padrão Strategy usando Rust\n" "`encerramentos`:" #: src\patterns/behavioural/strategy.md:132 @@ -5150,16 +4438,12 @@ msgstr "" #, fuzzy msgid "" "- [Strategy Pattern](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"- [Dependency " -"Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" -"- [Policy Based " -"Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +"- [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Policy Based Design](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" msgstr "" "- [Padrão de Estratégia](https://en.wikipedia.org/wiki/Strategy_pattern)\n" -"- [Injeção de " -"dependência](https://en.wikipedia.org/wiki/Dependency_injection)\n" -"- [Design baseado em " -"políticas](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" +"- [Injeção de dependência](https://en.wikipedia.org/wiki/Dependency_injection)\n" +"- [Design baseado em políticas](https://en.wikipedia.org/wiki/Modern_C++_Design#Policy-based_design)" #: src\patterns/behavioural/visitor.md:1 #, fuzzy @@ -5170,14 +4454,12 @@ msgstr "# Visitante" #, fuzzy msgid "" "A visitor encapsulates an algorithm that operates over a heterogeneous\n" -"collection of objects. It allows multiple different algorithms to be " -"written\n" +"collection of objects. It allows multiple different algorithms to be written\n" "over the same data without having to modify the data (or their primary\n" "behaviour)." msgstr "" "Um visitante encapsula um algoritmo que opera em uma rede heterogênea\n" -"coleção de objetos. Ele permite que vários algoritmos diferentes sejam " -"escritos\n" +"coleção de objetos. Ele permite que vários algoritmos diferentes sejam escritos\n" "sobre os mesmos dados sem ter que modificar os dados (ou seus principais\n" "comportamento)." @@ -5225,8 +4507,7 @@ msgid "" "use visit::*;\n" "use ast::*;\n" "\n" -"// An example concrete implementation - walks the AST interpreting it as " -"code.\n" +"// An example concrete implementation - walks the AST interpreting it as code.\n" "struct Interpreter;\n" "impl Visitor for Interpreter {\n" " fn visit_name(&mut self, n: &Name) -> i64 { panic!() }\n" @@ -5240,10 +4521,8 @@ msgid "" " fn visit_expr(&mut self, e: &Expr) -> i64 {\n" " match *e {\n" " Expr::IntLit(n) => n,\n" -" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + " -"self.visit_expr(rhs),\n" -" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - " -"self.visit_expr(rhs),\n" +" Expr::Add(ref lhs, ref rhs) => self.visit_expr(lhs) + self.visit_expr(rhs),\n" +" Expr::Sub(ref lhs, ref rhs) => self.visit_expr(lhs) - self.visit_expr(rhs),\n" " }\n" " }\n" "}\n" @@ -5253,51 +4532,38 @@ msgstr "" #: src\patterns/behavioural/visitor.md:69 #, fuzzy msgid "" -"One could implement further visitors, for example a type checker, without " -"having\n" +"One could implement further visitors, for example a type checker, without having\n" "to modify the AST data." msgstr "" -"Pode-se implementar mais visitantes, por exemplo, um verificador de tipo, " -"sem ter\n" +"Pode-se implementar mais visitantes, por exemplo, um verificador de tipo, sem ter\n" "para modificar os dados AST." #: src\patterns/behavioural/visitor.md:74 #, fuzzy msgid "" -"The visitor pattern is useful anywhere that you want to apply an algorithm " -"to\n" -"heterogeneous data. If data is homogeneous, you can use an iterator-like " -"pattern.\n" -"Using a visitor object (rather than a functional approach) allows the " -"visitor to\n" +"The visitor pattern is useful anywhere that you want to apply an algorithm to\n" +"heterogeneous data. If data is homogeneous, you can use an iterator-like pattern.\n" +"Using a visitor object (rather than a functional approach) allows the visitor to\n" "be stateful and thus communicate information between nodes." msgstr "" -"O padrão do visitante é útil em qualquer lugar que você deseja aplicar um " -"algoritmo para\n" -"dados heterogêneos. Se os dados forem homogêneos, você pode usar um padrão " -"do tipo iterador.\n" -"O uso de um objeto de visitante (em vez de uma abordagem funcional) permite " -"que o visitante\n" +"O padrão do visitante é útil em qualquer lugar que você deseja aplicar um algoritmo para\n" +"dados heterogêneos. Se os dados forem homogêneos, você pode usar um padrão do tipo iterador.\n" +"O uso de um objeto de visitante (em vez de uma abordagem funcional) permite que o visitante\n" "ser stateful e, assim, comunicar informações entre os nós." #: src\patterns/behavioural/visitor.md:81 #, fuzzy msgid "" "It is common for the `visit_*` methods to return void (as opposed to in the\n" -"example). In that case it is possible to factor out the traversal code and " -"share\n" -"it between algorithms (and also to provide noop default methods). In Rust, " -"the\n" +"example). In that case it is possible to factor out the traversal code and share\n" +"it between algorithms (and also to provide noop default methods). In Rust, the\n" "common way to do this is to provide `walk_*` functions for each datum. For\n" "example," msgstr "" "É comum que os métodos `visit_*` retornem void (em oposição ao método\n" -"exemplo). Nesse caso, é possível fatorar o código de travessia e " -"compartilhar\n" -"entre algoritmos (e também para fornecer métodos padrão noop). Em Ferrugem, " -"o\n" -"A maneira comum de fazer isso é fornecer funções `walk_*` para cada dado. " -"Para\n" +"exemplo). Nesse caso, é possível fatorar o código de travessia e compartilhar\n" +"entre algoritmos (e também para fornecer métodos padrão noop). Em Ferrugem, o\n" +"A maneira comum de fazer isso é fornecer funções `walk_*` para cada dado. Para\n" "exemplo," #: src\patterns/behavioural/visitor.md:87 @@ -5322,20 +4588,16 @@ msgstr "" #: src\patterns/behavioural/visitor.md:103 #, fuzzy msgid "" -"In other languages (e.g., Java) it is common for data to have an `accept` " -"method\n" +"In other languages (e.g., Java) it is common for data to have an `accept` method\n" "which performs the same duty." msgstr "" -"Em outras linguagens (por exemplo, Java) é comum que os dados tenham um " -"método `accept`\n" +"Em outras linguagens (por exemplo, Java) é comum que os dados tenham um método `accept`\n" "que cumpre a mesma função." #: src\patterns/behavioural/visitor.md:108 #, fuzzy msgid "The visitor pattern is a common pattern in most OO languages." -msgstr "" -"O padrão de visitante é um padrão comum na maioria das linguagens orientadas " -"a objetos." +msgstr "O padrão de visitante é um padrão comum na maioria das linguagens orientadas a objetos." #: src\patterns/behavioural/visitor.md:110 #, fuzzy @@ -5345,12 +4607,10 @@ msgstr "[Artigo da Wikipédia](https://en.wikipedia.org/wiki/Visitor_pattern)" #: src\patterns/behavioural/visitor.md:112 #, fuzzy msgid "" -"The [fold](../creational/fold.md) pattern is similar to visitor but " -"produces\n" +"The [fold](../creational/fold.md) pattern is similar to visitor but produces\n" "a new version of the visited data structure." msgstr "" -"O padrão [fold](../creational/fold.md) é semelhante ao do visitante, mas " -"produz\n" +"O padrão [fold](../creational/fold.md) é semelhante ao do visitante, mas produz\n" "uma nova versão da estrutura de dados visitada." #: src\patterns/creational/intro.md:1 @@ -5366,22 +4626,15 @@ msgstr "Da [Wikipedia](https://en.wikipedia.org/wiki/Creational_pattern):" #: src\patterns/creational/intro.md:5 #, fuzzy msgid "" -"> Design patterns that deal with object creation mechanisms, trying to " -"create objects\n" -"> in a manner suitable to the situation. The basic form of object creation " -"could\n" -"> result in design problems or in added complexity to the design. Creational " -"design\n" +"> Design patterns that deal with object creation mechanisms, trying to create objects\n" +"> in a manner suitable to the situation. The basic form of object creation could\n" +"> result in design problems or in added complexity to the design. Creational design\n" "> patterns solve this problem by somehow controlling this object creation." msgstr "" -"> Padrões de design que lidam com mecanismos de criação de objetos, tentando " -"criar objetos\n" -"> de forma adequada à situação. A forma básica de criação de objetos " -"poderia\n" -"> resultar em problemas de projeto ou em complexidade adicional ao projeto. " -"design criacional\n" -"> os padrões resolvem esse problema controlando de alguma forma a criação " -"desse objeto." +"> Padrões de design que lidam com mecanismos de criação de objetos, tentando criar objetos\n" +"> de forma adequada à situação. A forma básica de criação de objetos poderia\n" +"> resultar em problemas de projeto ou em complexidade adicional ao projeto. design criacional\n" +"> os padrões resolvem esse problema controlando de alguma forma a criação desse objeto." #: src\patterns/creational/builder.md:1 #, fuzzy @@ -5424,19 +4677,16 @@ msgid "" " }\n" "\n" " pub fn name(mut self, bar: String) -> FooBuilder {\n" -" // Set the name on the builder itself, and return the builder by " -"value.\n" +" // Set the name on the builder itself, and return the builder by value.\n" " self.bar = bar;\n" " self\n" " }\n" "\n" " // If we can get away with not consuming the Builder here, that is an\n" -" // advantage. It means we can use the FooBuilder as a template for " -"constructing\n" +" // advantage. It means we can use the FooBuilder as a template for constructing\n" " // many Foos.\n" " pub fn build(self) -> Foo {\n" -" // Create a Foo from the FooBuilder, applying all settings in " -"FooBuilder\n" +" // Create a Foo from the FooBuilder, applying all settings in FooBuilder\n" " // to Foo.\n" " Foo { bar: self.bar }\n" " }\n" @@ -5447,8 +4697,7 @@ msgid "" " let foo = Foo {\n" " bar: String::from(\"Y\"),\n" " };\n" -" let foo_from_builder: Foo = " -"FooBuilder::new().name(String::from(\"Y\")).build();\n" +" let foo_from_builder: Foo = FooBuilder::new().name(String::from(\"Y\")).build();\n" " assert_eq!(foo, foo_from_builder);\n" "}\n" "```" @@ -5475,81 +4724,57 @@ msgstr "Previne a proliferação de construtores." #: src\patterns/creational/builder.md:74 #, fuzzy -msgid "" -"Can be used for one-liner initialisation as well as more complex " -"construction." -msgstr "" -"Pode ser usado para inicialização de uma linha, bem como construções mais " -"complexas." +msgid "Can be used for one-liner initialisation as well as more complex construction." +msgstr "Pode ser usado para inicialização de uma linha, bem como construções mais complexas." #: src\patterns/creational/builder.md:78 #, fuzzy msgid "" -"More complex than creating a struct object directly, or a simple " -"constructor\n" +"More complex than creating a struct object directly, or a simple constructor\n" "function." msgstr "" -"Mais complexo do que criar um objeto struct diretamente ou um construtor " -"simples\n" +"Mais complexo do que criar um objeto struct diretamente ou um construtor simples\n" "função." #: src\patterns/creational/builder.md:83 #, fuzzy msgid "" -"This pattern is seen more frequently in Rust (and for simpler objects) than " -"in\n" -"many other languages because Rust lacks overloading. Since you can only have " -"a\n" -"single method with a given name, having multiple constructors is less nice " -"in\n" +"This pattern is seen more frequently in Rust (and for simpler objects) than in\n" +"many other languages because Rust lacks overloading. Since you can only have a\n" +"single method with a given name, having multiple constructors is less nice in\n" "Rust than in C++, Java, or others." msgstr "" -"Esse padrão é visto com mais frequência em Rust (e para objetos mais " -"simples) do que em\n" -"muitas outras linguagens porque Rust não tem sobrecarga. Como você só pode " -"ter um\n" -"método único com um determinado nome, ter vários construtores é menos " -"agradável em\n" +"Esse padrão é visto com mais frequência em Rust (e para objetos mais simples) do que em\n" +"muitas outras linguagens porque Rust não tem sobrecarga. Como você só pode ter um\n" +"método único com um determinado nome, ter vários construtores é menos agradável em\n" "Rust do que em C++, Java ou outros." #: src\patterns/creational/builder.md:88 #, fuzzy msgid "" -"This pattern is often used where the builder object is useful in its own " -"right,\n" +"This pattern is often used where the builder object is useful in its own right,\n" "rather than being just a builder. For example, see\n" "[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" -"is a builder for " -"[`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" -"(a process). In these cases, the `T` and `TBuilder` naming pattern is not " -"used." +"is a builder for [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(a process). In these cases, the `T` and `TBuilder` naming pattern is not used." msgstr "" -"Esse padrão é frequentemente usado onde o objeto construtor é útil por si " -"só,\n" +"Esse padrão é frequentemente usado onde o objeto construtor é útil por si só,\n" "em vez de ser apenas um construtor. Por exemplo, veja\n" "[`std::process::Command`](https://doc.rust-lang.org/std/process/struct.Command.html)\n" -"é um construtor para " -"[`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" -"(um processo). Nesses casos, o padrão de nomenclatura `T` e `TBuilder` não é " -"usado." +"é um construtor para [`Child`](https://doc.rust-lang.org/std/process/struct.Child.html)\n" +"(um processo). Nesses casos, o padrão de nomenclatura `T` e `TBuilder` não é usado." #: src\patterns/creational/builder.md:94 #, fuzzy msgid "" -"The example takes and returns the builder by value. It is often more " -"ergonomic\n" -"(and more efficient) to take and return the builder as a mutable reference. " -"The\n" -"borrow checker makes this work naturally. This approach has the advantage " -"that\n" +"The example takes and returns the builder by value. It is often more ergonomic\n" +"(and more efficient) to take and return the builder as a mutable reference. The\n" +"borrow checker makes this work naturally. This approach has the advantage that\n" "one can write code like" msgstr "" -"O exemplo pega e retorna o construtor por valor. Muitas vezes é mais " -"ergonômico\n" -"(e mais eficiente) para obter e retornar o construtor como uma referência " -"mutável. O\n" -"o verificador de empréstimo faz isso funcionar naturalmente. Esta abordagem " -"tem a vantagem de\n" +"O exemplo pega e retorna o construtor por valor. Muitas vezes é mais ergonômico\n" +"(e mais eficiente) para obter e retornar o construtor como uma referência mutável. O\n" +"o verificador de empréstimo faz isso funcionar naturalmente. Esta abordagem tem a vantagem de\n" "pode-se escrever código como" #: src\patterns/creational/builder.md:99 @@ -5570,29 +4795,23 @@ msgstr "assim como o estilo `FooBuilder::new().a().b().build()`." #: src\patterns/creational/builder.md:110 #, fuzzy msgid "" -"- [Description in the style " -"guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" -"- [derive_builder](https://crates.io/crates/derive_builder), a crate for " -"automatically\n" +"- [Description in the style guide](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/" +"builders.html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), a crate for automatically\n" " implementing this pattern while avoiding the boilerplate.\n" -"- [Constructor pattern](../../idioms/ctor.md) for when construction is " -"simpler.\n" -"- [Builder pattern " -"(wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" -"- [Construction of complex " -"values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder)" -msgstr "" -"- [Descrição no guia de " -"estilo](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders.html)\n" -"- [derive_builder](https://crates.io/crates/derive_builder), uma caixa para " -"automaticamente\n" +"- [Constructor pattern](../../idioms/ctor.md) for when construction is simpler.\n" +"- [Builder pattern (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Construction of complex values](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety." +"html#c-builder)" +msgstr "" +"- [Descrição no guia de estilo](https://web.archive.org/web/20210104103100/https://doc.rust-lang.org/1.12.0/style/ownership/builders." +"html)\n" +"- [derive_builder](https://crates.io/crates/derive_builder), uma caixa para automaticamente\n" " implementando esse padrão enquanto evita o clichê.\n" -"- [Padrão construtor](../../idioms/ctor.md) para quando a construção é mais " -"simples.\n" -"- [Padrão do construtor " -"(wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" -"- [Construção de valores " -"complexos](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety.html#c-builder)" +"- [Padrão construtor](../../idioms/ctor.md) para quando a construção é mais simples.\n" +"- [Padrão do construtor (wikipedia)](https://en.wikipedia.org/wiki/Builder_pattern)\n" +"- [Construção de valores complexos](https://web.archive.org/web/20210104103000/https://rust-lang.github.io/api-guidelines/type-safety." +"html#c-builder)" #: src\patterns/creational/fold.md:1 #, fuzzy @@ -5602,24 +4821,20 @@ msgstr "# Dobrar" #: src\patterns/creational/fold.md:5 #, fuzzy msgid "" -"Run an algorithm over each item in a collection of data to create a new " -"item,\n" +"Run an algorithm over each item in a collection of data to create a new item,\n" "thus creating a whole new collection." msgstr "" -"Execute um algoritmo sobre cada item em uma coleção de dados para criar um " -"novo item,\n" +"Execute um algoritmo sobre cada item em uma coleção de dados para criar um novo item,\n" "criando assim uma coleção totalmente nova." #: src\patterns/creational/fold.md:8 #, fuzzy msgid "" "The etymology here is unclear to me. The terms 'fold' and 'folder' are used\n" -"in the Rust compiler, although it appears to me to be more like a map than " -"a\n" +"in the Rust compiler, although it appears to me to be more like a map than a\n" "fold in the usual sense. See the discussion below for more details." msgstr "" -"A etimologia aqui não é clara para mim. Os termos 'dobrar' e 'pasta' são " -"usados\n" +"A etimologia aqui não é clara para mim. Os termos 'dobrar' e 'pasta' são usados\n" "no compilador Rust, embora me pareça mais um mapa do que um\n" "dobrar no sentido usual. Veja a discussão abaixo para mais detalhes." @@ -5649,16 +4864,14 @@ msgid "" " use ast::*;\n" "\n" " pub trait Folder {\n" -" // A leaf node just returns the node itself. In some cases, we can " -"do this\n" +" // A leaf node just returns the node itself. In some cases, we can do this\n" " // to inner nodes too.\n" " fn fold_name(&mut self, n: Box) -> Box { n }\n" " // Create a new inner node by folding its children.\n" " fn fold_stmt(&mut self, s: Box) -> Box {\n" " match *s {\n" " Stmt::Expr(e) => Box::new(Stmt::Expr(self.fold_expr(e))),\n" -" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), " -"self.fold_expr(e))),\n" +" Stmt::Let(n, e) => Box::new(Stmt::Let(self.fold_name(n), self.fold_expr(e))),\n" " }\n" " }\n" " fn fold_expr(&mut self, e: Box) -> Box { ... }\n" @@ -5682,118 +4895,89 @@ msgstr "" #: src\patterns/creational/fold.md:65 #, fuzzy msgid "" -"The result of running the `Renamer` on an AST is a new AST identical to the " -"old\n" -"one, but with every name changed to `foo`. A real life folder might have " -"some\n" +"The result of running the `Renamer` on an AST is a new AST identical to the old\n" +"one, but with every name changed to `foo`. A real life folder might have some\n" "state preserved between nodes in the struct itself." msgstr "" -"O resultado da execução do `Renamer` em um AST é um novo AST idêntico ao " -"antigo\n" -"um, mas com todos os nomes alterados para `foo`. Uma pasta da vida real pode " -"ter alguns\n" +"O resultado da execução do `Renamer` em um AST é um novo AST idêntico ao antigo\n" +"um, mas com todos os nomes alterados para `foo`. Uma pasta da vida real pode ter alguns\n" "estado preservado entre nós na própria estrutura." #: src\patterns/creational/fold.md:69 #, fuzzy msgid "" "A folder can also be defined to map one data structure to a different (but\n" -"usually similar) data structure. For example, we could fold an AST into a " -"HIR\n" +"usually similar) data structure. For example, we could fold an AST into a HIR\n" "tree (HIR stands for high-level intermediate representation)." msgstr "" -"Uma pasta também pode ser definida para mapear uma estrutura de dados para " -"outra (mas\n" -"geralmente semelhante) estrutura de dados. Por exemplo, poderíamos dobrar um " -"AST em um HIR\n" +"Uma pasta também pode ser definida para mapear uma estrutura de dados para outra (mas\n" +"geralmente semelhante) estrutura de dados. Por exemplo, poderíamos dobrar um AST em um HIR\n" "árvore (HIR significa representação intermediária de alto nível)." #: src\patterns/creational/fold.md:75 #, fuzzy msgid "" -"It is common to want to map a data structure by performing some operation " -"on\n" -"each node in the structure. For simple operations on simple data " -"structures,\n" -"this can be done using `Iterator::map`. For more complex operations, " -"perhaps\n" -"where earlier nodes can affect the operation on later nodes, or where " -"iteration\n" +"It is common to want to map a data structure by performing some operation on\n" +"each node in the structure. For simple operations on simple data structures,\n" +"this can be done using `Iterator::map`. For more complex operations, perhaps\n" +"where earlier nodes can affect the operation on later nodes, or where iteration\n" "over the data structure is non-trivial, using the fold pattern is more\n" "appropriate." msgstr "" "É comum querer mapear uma estrutura de dados realizando alguma operação em\n" -"cada nó da estrutura. Para operações simples em estruturas de dados " -"simples,\n" -"isso pode ser feito usando `Iterator::map`. Para operações mais complexas, " -"talvez\n" -"onde nós anteriores podem afetar a operação em nós posteriores, ou onde a " -"iteração\n" +"cada nó da estrutura. Para operações simples em estruturas de dados simples,\n" +"isso pode ser feito usando `Iterator::map`. Para operações mais complexas, talvez\n" +"onde nós anteriores podem afetar a operação em nós posteriores, ou onde a iteração\n" "sobre a estrutura de dados não é trivial, usar o padrão de dobra é mais\n" "apropriado." #: src\patterns/creational/fold.md:82 #, fuzzy msgid "" -"Like the visitor pattern, the fold pattern allows us to separate traversal " -"of a\n" +"Like the visitor pattern, the fold pattern allows us to separate traversal of a\n" "data structure from the operations performed to each node." msgstr "" -"Assim como o padrão Visitor, o padrão Fold nos permite separar a travessia " -"de um\n" +"Assim como o padrão Visitor, o padrão Fold nos permite separar a travessia de um\n" "estrutura de dados das operações realizadas para cada nó." #: src\patterns/creational/fold.md:87 #, fuzzy msgid "" -"Mapping data structures in this fashion is common in functional languages. " -"In OO\n" -"languages, it would be more common to mutate the data structure in place. " -"The\n" +"Mapping data structures in this fashion is common in functional languages. In OO\n" +"languages, it would be more common to mutate the data structure in place. The\n" "'functional' approach is common in Rust, mostly due to the preference for\n" -"immutability. Using fresh data structures, rather than mutating old ones, " -"makes\n" +"immutability. Using fresh data structures, rather than mutating old ones, makes\n" "reasoning about the code easier in most circumstances." msgstr "" -"Mapear estruturas de dados dessa maneira é comum em linguagens funcionais. " -"Eu não\n" +"Mapear estruturas de dados dessa maneira é comum em linguagens funcionais. Eu não\n" "idiomas, seria mais comum alterar a estrutura de dados no local. O\n" -"abordagem 'funcional' é comum em Rust, principalmente devido à preferência " -"por\n" -"imutabilidade. Usar novas estruturas de dados, em vez de modificar " -"estruturas antigas, torna\n" +"abordagem 'funcional' é comum em Rust, principalmente devido à preferência por\n" +"imutabilidade. Usar novas estruturas de dados, em vez de modificar estruturas antigas, torna\n" "Raciocinar sobre o código é mais fácil na maioria das circunstâncias." #: src\patterns/creational/fold.md:93 #, fuzzy msgid "" -"The trade-off between efficiency and reusability can be tweaked by changing " -"how\n" +"The trade-off between efficiency and reusability can be tweaked by changing how\n" "nodes are accepted by the `fold_*` methods." msgstr "" -"A compensação entre eficiência e reutilização pode ser ajustada alterando a " -"forma como\n" +"A compensação entre eficiência e reutilização pode ser ajustada alterando a forma como\n" "nós são aceitos pelos métodos `fold_*`." #: src\patterns/creational/fold.md:96 #, fuzzy msgid "" -"In the above example we operate on `Box` pointers. Since these own their " -"data\n" -"exclusively, the original copy of the data structure cannot be re-used. On " -"the\n" +"In the above example we operate on `Box` pointers. Since these own their data\n" +"exclusively, the original copy of the data structure cannot be re-used. On the\n" "other hand if a node is not changed, reusing it is very efficient." msgstr "" -"No exemplo acima, operamos em ponteiros `Box`. Uma vez que estes possuem " -"seus dados\n" -"exclusivamente, a cópia original da estrutura de dados não pode ser " -"reutilizada. No\n" +"No exemplo acima, operamos em ponteiros `Box`. Uma vez que estes possuem seus dados\n" +"exclusivamente, a cópia original da estrutura de dados não pode ser reutilizada. No\n" "por outro lado, se um nó não for alterado, reutilizá-lo é muito eficiente." #: src\patterns/creational/fold.md:100 msgid "" -"If we were to operate on borrowed references, the original data structure " -"can be\n" +"If we were to operate on borrowed references, the original data structure can be\n" "reused; however, a node must be cloned even if unchanged, which can be\n" "expensive." msgstr "" @@ -5801,66 +4985,49 @@ msgstr "" #: src\patterns/creational/fold.md:104 #, fuzzy msgid "" -"Using a reference counted pointer gives the best of both worlds - we can " -"reuse\n" -"the original data structure, and we don't need to clone unchanged nodes. " -"However,\n" +"Using a reference counted pointer gives the best of both worlds - we can reuse\n" +"the original data structure, and we don't need to clone unchanged nodes. However,\n" "they are less ergonomic to use and mean that the data structures cannot be\n" "mutable." msgstr "" -"Usar um ponteiro de contagem de referência oferece o melhor dos dois mundos " -"- podemos reutilizar\n" -"a estrutura de dados original e não precisamos clonar nós inalterados. No " -"entanto,\n" -"eles são menos ergonômicos de usar e significam que as estruturas de dados " -"não podem ser\n" +"Usar um ponteiro de contagem de referência oferece o melhor dos dois mundos - podemos reutilizar\n" +"a estrutura de dados original e não precisamos clonar nós inalterados. No entanto,\n" +"eles são menos ergonômicos de usar e significam que as estruturas de dados não podem ser\n" "mutável." #: src\patterns/creational/fold.md:111 #, fuzzy msgid "" "Iterators have a `fold` method, however this folds a data structure into a\n" -"value, rather than into a new data structure. An iterator's `map` is more " -"like\n" +"value, rather than into a new data structure. An iterator's `map` is more like\n" "this fold pattern." msgstr "" -"Os iteradores têm um método `fold`, no entanto, isso dobra uma estrutura de " -"dados em um\n" -"valor, em vez de em uma nova estrutura de dados. O `map` de um iterador é " -"mais parecido com\n" +"Os iteradores têm um método `fold`, no entanto, isso dobra uma estrutura de dados em um\n" +"valor, em vez de em uma nova estrutura de dados. O `map` de um iterador é mais parecido com\n" "este padrão de dobra." #: src\patterns/creational/fold.md:115 #, fuzzy msgid "" "In other languages, fold is usually used in the sense of Rust's iterators,\n" -"rather than this pattern. Some functional languages have powerful constructs " -"for\n" +"rather than this pattern. Some functional languages have powerful constructs for\n" "performing flexible maps over data structures." msgstr "" -"Em outras linguagens, fold é geralmente usado no sentido dos iteradores do " -"Rust,\n" -"em vez deste padrão. Algumas linguagens funcionais têm construções poderosas " -"para\n" +"Em outras linguagens, fold é geralmente usado no sentido dos iteradores do Rust,\n" +"em vez deste padrão. Algumas linguagens funcionais têm construções poderosas para\n" "realizando mapas flexíveis sobre estruturas de dados." #: src\patterns/creational/fold.md:119 #, fuzzy msgid "" -"The [visitor](../behavioural/visitor.md) pattern is closely related to " -"fold.\n" -"They share the concept of walking a data structure performing an operation " -"on\n" -"each node. However, the visitor does not create a new data structure nor " -"consume\n" +"The [visitor](../behavioural/visitor.md) pattern is closely related to fold.\n" +"They share the concept of walking a data structure performing an operation on\n" +"each node. However, the visitor does not create a new data structure nor consume\n" "the old one." msgstr "" -"O padrão [visitor](../behavioural/visitor.md) está intimamente relacionado à " -"dobra.\n" -"Eles compartilham o conceito de percorrer uma estrutura de dados realizando " -"uma operação em\n" -"cada nó. No entanto, o visitante não cria uma nova estrutura de dados nem " -"consome\n" +"O padrão [visitor](../behavioural/visitor.md) está intimamente relacionado à dobra.\n" +"Eles compartilham o conceito de percorrer uma estrutura de dados realizando uma operação em\n" +"cada nó. No entanto, o visitante não cria uma nova estrutura de dados nem consome\n" "o antigo." #: src\patterns/structural/intro.md:1 @@ -5876,12 +5043,10 @@ msgstr "Da [Wikipedia](https://en.wikipedia.org/wiki/Structural_pattern):" #: src\patterns/structural/intro.md:5 #, fuzzy msgid "" -"> Design patterns that ease the design by identifying a simple way to " -"realize relationships\n" +"> Design patterns that ease the design by identifying a simple way to realize relationships\n" "> among entities." msgstr "" -"> Padrões de design que facilitam o design identificando uma maneira simples " -"de realizar relacionamentos\n" +"> Padrões de design que facilitam o design identificando uma maneira simples de realizar relacionamentos\n" "> entre entidades." #: src\patterns/structural/compose-structs.md:1 @@ -5897,25 +5062,18 @@ msgstr "TODO - este não é um nome muito rápido" #: src\patterns/structural/compose-structs.md:7 #, fuzzy msgid "" -"Sometimes a large struct will cause issues with the borrow checker - " -"although\n" -"fields can be borrowed independently, sometimes the whole struct ends up " -"being\n" -"used at once, preventing other uses. A solution might be to decompose the " -"struct\n" +"Sometimes a large struct will cause issues with the borrow checker - although\n" +"fields can be borrowed independently, sometimes the whole struct ends up being\n" +"used at once, preventing other uses. A solution might be to decompose the struct\n" "into several smaller structs. Then compose these together into the original\n" "struct. Then each struct can be borrowed separately and have more flexible\n" "behaviour." msgstr "" -"Às vezes, uma estrutura grande causará problemas com o verificador de " -"empréstimo - embora\n" -"campos podem ser emprestados de forma independente, às vezes toda a " -"estrutura acaba sendo\n" -"usados de uma só vez, impedindo outros usos. Uma solução pode ser decompor a " -"estrutura\n" +"Às vezes, uma estrutura grande causará problemas com o verificador de empréstimo - embora\n" +"campos podem ser emprestados de forma independente, às vezes toda a estrutura acaba sendo\n" +"usados de uma só vez, impedindo outros usos. Uma solução pode ser decompor a estrutura\n" "em várias estruturas menores. Em seguida, componha-os juntos no original\n" -"struct. Em seguida, cada struct pode ser emprestado separadamente e ter mais " -"flexibilidade\n" +"struct. Em seguida, cada struct pode ser emprestado separadamente e ter mais flexibilidade\n" "comportamento." #: src\patterns/structural/compose-structs.md:14 @@ -5924,19 +5082,16 @@ msgid "" "This will often lead to a better design in other ways: applying this design\n" "pattern often reveals smaller units of functionality." msgstr "" -"Isso geralmente leva a um design melhor de outras maneiras: aplicando esse " -"design\n" +"Isso geralmente leva a um design melhor de outras maneiras: aplicando esse design\n" "padrão geralmente revela unidades menores de funcionalidade." #: src\patterns/structural/compose-structs.md:19 #, fuzzy msgid "" -"Here is a contrived example of where the borrow checker foils us in our plan " -"to\n" +"Here is a contrived example of where the borrow checker foils us in our plan to\n" "use a struct:" msgstr "" -"Aqui está um exemplo forjado de onde o verificador de empréstimos nos " -"frustra em nosso plano de\n" +"Aqui está um exemplo forjado de onde o verificador de empréstimos nos frustra em nosso plano de\n" "use uma estrutura:" #: src\patterns/structural/compose-structs.md:22 @@ -5952,12 +5107,10 @@ msgid "" "fn bar(a: &mut A) -> u32 { a.f1 + a.f3 }\n" "\n" "fn baz(a: &mut A) {\n" -" // The later usage of x causes a to be borrowed for the rest of the " -"function.\n" +" // The later usage of x causes a to be borrowed for the rest of the function.\n" " let x = foo(a);\n" " // Borrow checker error:\n" -" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than " -"once\n" +" // let y = bar(a); // ~ ERROR: cannot borrow `*a` as mutable more than once\n" " // at a time\n" " println!(\"{}\", x);\n" "}\n" @@ -5967,12 +5120,10 @@ msgstr "" #: src\patterns/structural/compose-structs.md:42 #, fuzzy msgid "" -"We can apply this design pattern and refactor `A` into two smaller structs, " -"thus\n" +"We can apply this design pattern and refactor `A` into two smaller structs, thus\n" "solving the borrow checking issue:" msgstr "" -"Podemos aplicar esse padrão de design e refatorar `A` em duas estruturas " -"menores, assim\n" +"Podemos aplicar esse padrão de design e refatorar `A` em duas estruturas menores, assim\n" "resolvendo o problema de verificação de empréstimo:" #: src\patterns/structural/compose-structs.md:45 @@ -6027,52 +5178,38 @@ msgstr "Leva a um código mais detalhado." #: src\patterns/structural/compose-structs.md:85 #, fuzzy msgid "" -"Sometimes, the smaller structs are not good abstractions, and so we end up " -"with\n" -"a worse design. That is probably a 'code smell', indicating that the " -"program\n" +"Sometimes, the smaller structs are not good abstractions, and so we end up with\n" +"a worse design. That is probably a 'code smell', indicating that the program\n" "should be refactored in some way." msgstr "" -"Às vezes, as estruturas menores não são boas abstrações e, portanto, " -"acabamos com\n" -"um projeto pior. Isso é provavelmente um 'cheiro de código', indicando que o " -"programa\n" +"Às vezes, as estruturas menores não são boas abstrações e, portanto, acabamos com\n" +"um projeto pior. Isso é provavelmente um 'cheiro de código', indicando que o programa\n" "deve ser refatorado de alguma forma." #: src\patterns/structural/compose-structs.md:91 #, fuzzy msgid "" -"This pattern is not required in languages that don't have a borrow checker, " -"so\n" -"in that sense is unique to Rust. However, making smaller units of " -"functionality\n" +"This pattern is not required in languages that don't have a borrow checker, so\n" +"in that sense is unique to Rust. However, making smaller units of functionality\n" "often leads to cleaner code: a widely acknowledged principle of software\n" "engineering, independent of the language." msgstr "" -"Esse padrão não é necessário em idiomas que não possuem um verificador de " -"empréstimo, então\n" -"nesse sentido, é exclusivo do Rust. No entanto, fazer unidades menores de " -"funcionalidade\n" -"muitas vezes leva a um código mais limpo: um princípio de software " -"amplamente reconhecido\n" +"Esse padrão não é necessário em idiomas que não possuem um verificador de empréstimo, então\n" +"nesse sentido, é exclusivo do Rust. No entanto, fazer unidades menores de funcionalidade\n" +"muitas vezes leva a um código mais limpo: um princípio de software amplamente reconhecido\n" "engenharia, independente do idioma." #: src\patterns/structural/compose-structs.md:96 #, fuzzy msgid "" "This pattern relies on Rust's borrow checker to be able to borrow fields\n" -"independently of each other. In the example, the borrow checker knows that " -"`a.b`\n" -"and `a.c` are distinct and can be borrowed independently, it does not try " -"to\n" +"independently of each other. In the example, the borrow checker knows that `a.b`\n" +"and `a.c` are distinct and can be borrowed independently, it does not try to\n" "borrow all of `a`, which would make this pattern useless." msgstr "" -"Esse padrão depende do verificador de empréstimo do Rust para poder " -"emprestar campos\n" -"independentemente um do outro. No exemplo, o verificador de empréstimo sabe " -"que `a.b`\n" -"e `a.c` são distintos e podem ser emprestados independentemente, ele não " -"tenta\n" +"Esse padrão depende do verificador de empréstimo do Rust para poder emprestar campos\n" +"independentemente um do outro. No exemplo, o verificador de empréstimo sabe que `a.b`\n" +"e `a.c` são distintos e podem ser emprestados independentemente, ele não tenta\n" "pegue emprestado todo `a`, o que tornaria esse padrão inútil." #: src\patterns/structural/small-crates.md:1 @@ -6088,42 +5225,30 @@ msgstr "Prefira caixas pequenas que façam uma coisa bem." #: src\patterns/structural/small-crates.md:7 #, fuzzy msgid "" -"Cargo and crates.io make it easy to add third-party libraries, much more so " -"than\n" -"in say C or C++. Moreover, since packages on crates.io cannot be edited or " -"removed\n" -"after publication, any build that works now should continue to work in the " -"future.\n" -"We should take advantage of this tooling, and use smaller, more fine-grained " -"dependencies." -msgstr "" -"Cargo e crates.io facilitam a adição de bibliotecas de terceiros, muito mais " -"do que\n" -"digamos em C ou C++. Além disso, como os pacotes no crates.io não podem ser " -"editados ou removidos\n" -"após a publicação, qualquer compilação que funcione agora deve continuar " -"funcionando no futuro.\n" -"Devemos aproveitar essas ferramentas e usar dependências menores e mais " -"refinadas." +"Cargo and crates.io make it easy to add third-party libraries, much more so than\n" +"in say C or C++. Moreover, since packages on crates.io cannot be edited or removed\n" +"after publication, any build that works now should continue to work in the future.\n" +"We should take advantage of this tooling, and use smaller, more fine-grained dependencies." +msgstr "" +"Cargo e crates.io facilitam a adição de bibliotecas de terceiros, muito mais do que\n" +"digamos em C ou C++. Além disso, como os pacotes no crates.io não podem ser editados ou removidos\n" +"após a publicação, qualquer compilação que funcione agora deve continuar funcionando no futuro.\n" +"Devemos aproveitar essas ferramentas e usar dependências menores e mais refinadas." #: src\patterns/structural/small-crates.md:14 #, fuzzy msgid "" "- Small crates are easier to understand, and encourage more modular code.\n" "- Crates allow for re-using code between projects.\n" -" For example, the `url` crate was developed as part of the Servo browser " -"engine,\n" +" For example, the `url` crate was developed as part of the Servo browser engine,\n" " but has since found wide use outside the project.\n" "- Since the compilation unit\n" -" of Rust is the crate, splitting a project into multiple crates can allow " -"more of\n" +" of Rust is the crate, splitting a project into multiple crates can allow more of\n" " the code to be built in parallel." msgstr "" -"- Caixas pequenas são mais fáceis de entender e incentivam um código mais " -"modular.\n" +"- Caixas pequenas são mais fáceis de entender e incentivam um código mais modular.\n" "- As caixas permitem a reutilização de código entre projetos.\n" -" Por exemplo, a caixa `url` foi desenvolvida como parte do mecanismo do " -"navegador Servo,\n" +" Por exemplo, a caixa `url` foi desenvolvida como parte do mecanismo do navegador Servo,\n" " mas desde então encontrou amplo uso fora do projeto.\n" "- Desde a unidade de compilação\n" " de Rust é a caixa, dividir um projeto em várias caixas pode permitir mais\n" @@ -6132,42 +5257,30 @@ msgstr "" #: src\patterns/structural/small-crates.md:24 #, fuzzy msgid "" -"- This can lead to \"dependency hell\", when a project depends on multiple " -"conflicting\n" -" versions of a crate at the same time. For example, the `url` crate has " -"both versions\n" -" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` " -"are\n" -" different types, an HTTP client that uses `url:0.5` would not accept `Url` " -"values\n" +"- This can lead to \"dependency hell\", when a project depends on multiple conflicting\n" +" versions of a crate at the same time. For example, the `url` crate has both versions\n" +" 1.0 and 0.5. Since the `Url` from `url:1.0` and the `Url` from `url:0.5` are\n" +" different types, an HTTP client that uses `url:0.5` would not accept `Url` values\n" " from a web scraper that uses `url:1.0`.\n" -"- Packages on crates.io are not curated. A crate may be poorly written, " -"have\n" +"- Packages on crates.io are not curated. A crate may be poorly written, have\n" " unhelpful documentation, or be outright malicious.\n" -"- Two small crates may be less optimized than one large one, since the " -"compiler\n" +"- Two small crates may be less optimized than one large one, since the compiler\n" " does not perform link-time optimization (LTO) by default." msgstr "" -"- Isso pode levar ao \"inferno da dependência\", quando um projeto depende " -"de vários\n" -" versões de uma caixa ao mesmo tempo. Por exemplo, a caixa `url` tem ambas " -"as versões\n" +"- Isso pode levar ao \"inferno da dependência\", quando um projeto depende de vários\n" +" versões de uma caixa ao mesmo tempo. Por exemplo, a caixa `url` tem ambas as versões\n" " 1,0 e 0,5. Como o `Url` de `url:1.0` e o `Url` de `url:0.5` são\n" -" tipos diferentes, um cliente HTTP que usa `url:0.5` não aceitaria valores " -"`Url`\n" +" tipos diferentes, um cliente HTTP que usa `url:0.5` não aceitaria valores `Url`\n" " de um web scraper que usa `url:1.0`.\n" -"- Pacotes em crates.io não são selecionados. Uma caixa pode estar mal " -"escrita, ter\n" +"- Pacotes em crates.io não são selecionados. Uma caixa pode estar mal escrita, ter\n" " documentação inútil ou totalmente malicioso.\n" -"- Duas caixas pequenas podem ser menos otimizadas do que uma grande, pois o " -"compilador\n" +"- Duas caixas pequenas podem ser menos otimizadas do que uma grande, pois o compilador\n" " não executa otimização de tempo de link (LTO) por padrão." #: src\patterns/structural/small-crates.md:36 #, fuzzy msgid "" -"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides " -"functions\n" +"The [`ref_slice`](https://crates.io/crates/ref_slice) crate provides functions\n" "for converting `&T` to `&[T]`." msgstr "" "A caixa [`ref_slice`](https://crates.io/crates/ref_slice) fornece funções\n" @@ -6176,23 +5289,19 @@ msgstr "" #: src\patterns/structural/small-crates.md:39 #, fuzzy msgid "" -"The [`url`](https://crates.io/crates/url) crate provides tools for working " -"with\n" +"The [`url`](https://crates.io/crates/url) crate provides tools for working with\n" "URLs." msgstr "" -"A caixa [`url`](https://crates.io/crates/url) fornece ferramentas para " -"trabalhar com\n" +"A caixa [`url`](https://crates.io/crates/url) fornece ferramentas para trabalhar com\n" "URLs." #: src\patterns/structural/small-crates.md:42 #, fuzzy msgid "" -"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a " -"function to\n" +"The [`num_cpus`](https://crates.io/crates/num_cpus) crate provides a function to\n" "query the number of CPUs on a machine." msgstr "" -"A caixa [`num_cpus`](https://crates.io/crates/num_cpus) fornece uma função " -"para\n" +"A caixa [`num_cpus`](https://crates.io/crates/num_cpus) fornece uma função para\n" "consultar o número de CPUs em uma máquina." #: src\patterns/structural/small-crates.md:47 @@ -6208,39 +5317,27 @@ msgstr "# Conter a insegurança em pequenos módulos" #: src\patterns/structural/unsafe-mods.md:5 #, fuzzy msgid "" -"If you have `unsafe` code, create the smallest possible module that can " -"uphold\n" -"the needed invariants to build a minimal safe interface upon the unsafety. " -"Embed\n" -"this into a larger module that contains only safe code and presents an " -"ergonomic\n" -"interface. Note that the outer module can contain unsafe functions and " -"methods\n" -"that call directly into the unsafe code. Users may use this to gain speed " -"benefits." -msgstr "" -"Se você tiver um código `inseguro`, crie o menor módulo possível que possa " -"suportar\n" -"as invariantes necessárias para construir uma interface segura mínima sobre " -"a insegurança. Embutir\n" -"isso em um módulo maior que contém apenas código seguro e apresenta um " -"design ergonômico\n" -"interface. Observe que o módulo externo pode conter funções e métodos " -"inseguros\n" -"que chamam diretamente para o código inseguro. Os usuários podem usar isso " -"para obter benefícios de velocidade." +"If you have `unsafe` code, create the smallest possible module that can uphold\n" +"the needed invariants to build a minimal safe interface upon the unsafety. Embed\n" +"this into a larger module that contains only safe code and presents an ergonomic\n" +"interface. Note that the outer module can contain unsafe functions and methods\n" +"that call directly into the unsafe code. Users may use this to gain speed benefits." +msgstr "" +"Se você tiver um código `inseguro`, crie o menor módulo possível que possa suportar\n" +"as invariantes necessárias para construir uma interface segura mínima sobre a insegurança. Embutir\n" +"isso em um módulo maior que contém apenas código seguro e apresenta um design ergonômico\n" +"interface. Observe que o módulo externo pode conter funções e métodos inseguros\n" +"que chamam diretamente para o código inseguro. Os usuários podem usar isso para obter benefícios de velocidade." #: src\patterns/structural/unsafe-mods.md:13 #, fuzzy msgid "" "- This restricts the unsafe code that must be audited\n" -"- Writing the outer module is much easier, since you can count on the " -"guarantees\n" +"- Writing the outer module is much easier, since you can count on the guarantees\n" " of the inner module" msgstr "" "- Isso restringe o código inseguro que deve ser auditado\n" -"- Escrever o módulo externo é muito mais fácil, pois você pode contar com as " -"garantias\n" +"- Escrever o módulo externo é muito mais fácil, pois você pode contar com as garantias\n" " do módulo interno" #: src\patterns/structural/unsafe-mods.md:19 @@ -6255,39 +5352,26 @@ msgstr "" #: src\patterns/structural/unsafe-mods.md:24 #, fuzzy msgid "" -"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe " -"operations\n" +"- The [`toolshed`](https://docs.rs/toolshed) crate contains its unsafe operations\n" " in submodules, presenting a safe interface to users.\n" -"- `std`'s `String` class is a wrapper over `Vec` with the added " -"invariant\n" -" that the contents must be valid UTF-8. The operations on `String` ensure " -"this\n" +"- `std`'s `String` class is a wrapper over `Vec` with the added invariant\n" +" that the contents must be valid UTF-8. The operations on `String` ensure this\n" " behavior.\n" -" However, users have the option of using an `unsafe` method to create a " -"`String`,\n" -" in which case the onus is on them to guarantee the validity of the " -"contents." +" However, users have the option of using an `unsafe` method to create a `String`,\n" +" in which case the onus is on them to guarantee the validity of the contents." msgstr "" -"- A caixa [`toolshed`](https://docs.rs/toolshed) contém suas operações " -"inseguras\n" +"- A caixa [`toolshed`](https://docs.rs/toolshed) contém suas operações inseguras\n" " em submódulos, apresentando uma interface segura aos usuários.\n" -"- A classe `String` de `std` é um wrapper sobre `Vec` com a invariante " -"adicionada\n" -" que o conteúdo deve ser UTF-8 válido. As operações em `String` garantem " -"isso\n" +"- A classe `String` de `std` é um wrapper sobre `Vec` com a invariante adicionada\n" +" que o conteúdo deve ser UTF-8 válido. As operações em `String` garantem isso\n" " comportamento.\n" -" No entanto, os usuários têm a opção de usar um método `inseguro` para " -"criar uma `String`,\n" +" No entanto, os usuários têm a opção de usar um método `inseguro` para criar uma `String`,\n" " neste caso, cabe a eles o ônus de garantir a validade do conteúdo." #: src\patterns/structural/unsafe-mods.md:34 #, fuzzy -msgid "" -"- [Ralf Jung's Blog about invariants in unsafe " -"code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" -msgstr "" -"- [Blog de Ralf Jung sobre invariantes em código " -"inseguro](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgid "- [Ralf Jung's Blog about invariants in unsafe code](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" +msgstr "- [Blog de Ralf Jung sobre invariantes em código inseguro](https://www.ralfj.de/blog/2018/08/22/two-kinds-of-invariants.html)" #: src\patterns/ffi/intro.md:1 #, fuzzy @@ -6298,13 +5382,11 @@ msgstr "# Padrões FFI" #, fuzzy msgid "" "Writing FFI code is an entire course in itself.\n" -"However, there are several idioms here that can act as pointers, and avoid " -"traps\n" +"However, there are several idioms here that can act as pointers, and avoid traps\n" "for inexperienced users of unsafe Rust." msgstr "" "Escrever código FFI é um curso completo em si.\n" -"No entanto, existem vários idiomas aqui que podem atuar como ponteiros e " -"evitar armadilhas\n" +"No entanto, existem vários idiomas aqui que podem atuar como ponteiros e evitar armadilhas\n" "para usuários inexperientes de Rust inseguro." #: src\patterns/ffi/intro.md:7 @@ -6315,20 +5397,16 @@ msgstr "Esta seção contém padrões de projeto que podem ser úteis ao fazer F #: src\patterns/ffi/intro.md:9 #, fuzzy msgid "" -"1. [Object-Based API](./export.md) design that has good memory safety " -"characteristics,\n" +"1. [Object-Based API](./export.md) design that has good memory safety characteristics,\n" " and a clean boundary of what is safe and what is unsafe\n" "\n" -"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust " -"types\n" +"2. [Type Consolidation into Wrappers](./wrappers.md) - group multiple Rust types\n" " together into an opaque \"object\"" msgstr "" -"1. Design de [API baseada em objeto](./export.md) que possui boas " -"características de segurança de memória,\n" +"1. Design de [API baseada em objeto](./export.md) que possui boas características de segurança de memória,\n" " e um limite claro do que é seguro e do que não é seguro\n" "\n" -"2. [Digite Consolidação em Wrappers](./wrappers.md) - agrupe vários tipos de " -"Rust\n" +"2. [Digite Consolidação em Wrappers](./wrappers.md) - agrupe vários tipos de Rust\n" " juntos em um \"objeto\" opaco" #: src\patterns/ffi/export.md:1 @@ -6339,146 +5417,113 @@ msgstr "# APIs baseadas em objetos" #: src\patterns/ffi/export.md:5 #, fuzzy msgid "" -"When designing APIs in Rust which are exposed to other languages, there are " -"some\n" +"When designing APIs in Rust which are exposed to other languages, there are some\n" "important design principles which are contrary to normal Rust API design:" msgstr "" "Ao projetar APIs em Rust expostas a outras linguagens, existem algumas\n" -"princípios de design importantes que são contrários ao design normal da Rust " -"API:" +"princípios de design importantes que são contrários ao design normal da Rust API:" #: src\patterns/ffi/export.md:8 #, fuzzy msgid "" "1. All Encapsulated types should be _owned_ by Rust, _managed_ by the user,\n" " and _opaque_.\n" -"2. All Transactional data types should be _owned_ by the user, and " -"_transparent_.\n" +"2. All Transactional data types should be _owned_ by the user, and _transparent_.\n" "3. All library behavior should be functions acting upon Encapsulated types.\n" -"4. All library behavior should be encapsulated into types not based on " -"structure,\n" +"4. All library behavior should be encapsulated into types not based on structure,\n" " but _provenance/lifetime_." msgstr "" -"1. Todos os tipos encapsulados devem ser _propriedade_ da Rust, " -"_gerenciados_ pelo usuário,\n" +"1. Todos os tipos encapsulados devem ser _propriedade_ da Rust, _gerenciados_ pelo usuário,\n" " e _opaco_.\n" -"2. Todos os tipos de dados transacionais devem ser _propriedade_ do usuário " -"e _transparentes_.\n" -"3. Todo o comportamento da biblioteca deve ser funções agindo sobre tipos " -"encapsulados.\n" -"4. Todo o comportamento da biblioteca deve ser encapsulado em tipos não " -"baseados em estrutura,\n" +"2. Todos os tipos de dados transacionais devem ser _propriedade_ do usuário e _transparentes_.\n" +"3. Todo o comportamento da biblioteca deve ser funções agindo sobre tipos encapsulados.\n" +"4. Todo o comportamento da biblioteca deve ser encapsulado em tipos não baseados em estrutura,\n" " mas _proveniência/tempo de vida_." #: src\patterns/ffi/export.md:17 #, fuzzy msgid "" "Rust has built-in FFI support to other languages.\n" -"It does this by providing a way for crate authors to provide C-compatible " -"APIs\n" +"It does this by providing a way for crate authors to provide C-compatible APIs\n" "through different ABIs (though that is unimportant to this practice)." msgstr "" "Rust possui suporte FFI integrado para outros idiomas.\n" -"Ele faz isso fornecendo uma maneira para os autores de caixas fornecerem " -"APIs compatíveis com C\n" -"através de diferentes ABIs (embora isso não seja importante para esta " -"prática)." +"Ele faz isso fornecendo uma maneira para os autores de caixas fornecerem APIs compatíveis com C\n" +"através de diferentes ABIs (embora isso não seja importante para esta prática)." #: src\patterns/ffi/export.md:21 #, fuzzy msgid "" -"Well-designed Rust FFI follows C API design principles, while compromising " -"the\n" -"design in Rust as little as possible. There are three goals with any foreign " -"API:" +"Well-designed Rust FFI follows C API design principles, while compromising the\n" +"design in Rust as little as possible. There are three goals with any foreign API:" msgstr "" -"O Rust FFI bem projetado segue os princípios de design da API C, ao mesmo " -"tempo em que compromete o\n" -"projete em Rust o mínimo possível. Existem três objetivos com qualquer API " -"estrangeira:" +"O Rust FFI bem projetado segue os princípios de design da API C, ao mesmo tempo em que compromete o\n" +"projete em Rust o mínimo possível. Existem três objetivos com qualquer API estrangeira:" #: src\patterns/ffi/export.md:24 #, fuzzy msgid "" "1. Make it easy to use in the target language.\n" -"2. Avoid the API dictating internal unsafety on the Rust side as much as " -"possible.\n" -"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as " -"small\n" +"2. Avoid the API dictating internal unsafety on the Rust side as much as possible.\n" +"3. Keep the potential for memory unsafety and Rust `undefined behaviour` as small\n" " as possible." msgstr "" "1. Facilite o uso no idioma de destino.\n" -"2. Evite o máximo possível a API ditando a insegurança interna no lado da " -"Rust.\n" -"3. Mantenha o potencial de insegurança de memória e \"comportamento " -"indefinido\" Rust como pequeno\n" +"2. Evite o máximo possível a API ditando a insegurança interna no lado da Rust.\n" +"3. Mantenha o potencial de insegurança de memória e \"comportamento indefinido\" Rust como pequeno\n" " que possível." #: src\patterns/ffi/export.md:29 #, fuzzy msgid "" -"Rust code must trust the memory safety of the foreign language beyond a " -"certain\n" -"point. However, every bit of `unsafe` code on the Rust side is an " -"opportunity for\n" +"Rust code must trust the memory safety of the foreign language beyond a certain\n" +"point. However, every bit of `unsafe` code on the Rust side is an opportunity for\n" "bugs, or to exacerbate `undefined behaviour`." msgstr "" -"O código Rust deve confiar na segurança da memória do idioma estrangeiro " -"além de um certo\n" -"apontar. No entanto, cada pedaço de código `inseguro` no lado do Rust é uma " -"oportunidade para\n" +"O código Rust deve confiar na segurança da memória do idioma estrangeiro além de um certo\n" +"apontar. No entanto, cada pedaço de código `inseguro` no lado do Rust é uma oportunidade para\n" "bugs, ou para exacerbar `comportamento indefinido`." #: src\patterns/ffi/export.md:33 #, fuzzy msgid "" -"For example, if a pointer provenance is wrong, that may be a segfault due " -"to\n" -"invalid memory access. But if it is manipulated by unsafe code, it could " -"become\n" +"For example, if a pointer provenance is wrong, that may be a segfault due to\n" +"invalid memory access. But if it is manipulated by unsafe code, it could become\n" "full-blown heap corruption." msgstr "" -"Por exemplo, se a proveniência de um ponteiro estiver errada, isso pode ser " -"uma falha de segmentação devido a\n" -"acesso inválido à memória. Mas se for manipulado por código inseguro, pode " -"tornar-se\n" +"Por exemplo, se a proveniência de um ponteiro estiver errada, isso pode ser uma falha de segmentação devido a\n" +"acesso inválido à memória. Mas se for manipulado por código inseguro, pode tornar-se\n" "corrupção total da pilha." #: src\patterns/ffi/export.md:37 #, fuzzy msgid "" -"The Object-Based API design allows for writing shims that have good memory " -"safety\n" +"The Object-Based API design allows for writing shims that have good memory safety\n" "characteristics, and a clean boundary of what is safe and what is `unsafe`." msgstr "" -"O design da API baseada em objeto permite escrever shims com boa segurança " -"de memória\n" +"O design da API baseada em objeto permite escrever shims com boa segurança de memória\n" "características e um limite claro do que é seguro e do que é 'inseguro'." #: src\patterns/ffi/export.md:42 #, fuzzy msgid "" -"The POSIX standard defines the API to access an on-file database, known as " -"[DBM](https://web.archive.org/web/20210105035602/https://www.mankier.com/0p/ndbm.h).\n" +"The POSIX standard defines the API to access an on-file database, known as [DBM](https://web.archive.org/web/20210105035602/https://" +"www.mankier.com/0p/ndbm.h).\n" "It is an excellent example of an \"object-based\" API." msgstr "" -"O padrão POSIX define a API para acessar um banco de dados on-file, " -"conhecido como " -"[DBM](https://web.archive.org/web/20210105035602/https://www.mankier.com/0p/ndbm.h) " -".\n" +"O padrão POSIX define a API para acessar um banco de dados on-file, conhecido como [DBM](https://web.archive.org/web/20210105035602/" +"https://www.mankier.com/0p/ndbm.h) .\n" "É um excelente exemplo de uma API \"baseada em objeto\"." #: src\patterns/ffi/export.md:45 #, fuzzy msgid "" -"Here is the definition in C, which hopefully should be easy to read for " -"those\n" +"Here is the definition in C, which hopefully should be easy to read for those\n" "involved in FFI. The commentary below should help explain it for those who\n" "miss the subtleties." msgstr "" "Aqui está a definição em C, que deve ser fácil de ler para aqueles\n" -"envolvidos no FFI. O comentário abaixo deve ajudar a explicá-lo para aqueles " -"que\n" +"envolvidos no FFI. O comentário abaixo deve ajudar a explicá-lo para aqueles que\n" "perca as sutilezas." #: src\patterns/ffi/export.md:49 @@ -6508,78 +5553,59 @@ msgstr "Esta API define dois tipos: `DBM` e `datum`." #, fuzzy msgid "" "The `DBM` type was called an \"encapsulated\" type above.\n" -"It is designed to contain internal state, and acts as an entry point for " -"the\n" +"It is designed to contain internal state, and acts as an entry point for the\n" "library's behavior." msgstr "" "O tipo `DBM` foi chamado de tipo \"encapsulado\" acima.\n" -"Ele é projetado para conter o estado interno e atua como um ponto de entrada " -"para o\n" +"Ele é projetado para conter o estado interno e atua como um ponto de entrada para o\n" "comportamento da biblioteca." #: src\patterns/ffi/export.md:70 #, fuzzy msgid "" -"It is completely opaque to the user, who cannot create a `DBM` themselves " -"since\n" -"they don't know its size or layout. Instead, they must call `dbm_open`, and " -"that\n" +"It is completely opaque to the user, who cannot create a `DBM` themselves since\n" +"they don't know its size or layout. Instead, they must call `dbm_open`, and that\n" "only gives them _a pointer to one_." msgstr "" -"É completamente opaco para o usuário, que não pode criar um `DBM` por conta " -"própria, pois\n" -"eles não sabem seu tamanho ou layout. Em vez disso, eles devem chamar " -"`dbm_open`, e isso\n" +"É completamente opaco para o usuário, que não pode criar um `DBM` por conta própria, pois\n" +"eles não sabem seu tamanho ou layout. Em vez disso, eles devem chamar `dbm_open`, e isso\n" "apenas dá a eles _um ponteiro para um_." #: src\patterns/ffi/export.md:74 #, fuzzy msgid "" "This means all `DBM`s are \"owned\" by the library in a Rust sense.\n" -"The internal state of unknown size is kept in memory controlled by the " -"library,\n" -"not the user. The user can only manage its life cycle with `open` and " -"`close`,\n" +"The internal state of unknown size is kept in memory controlled by the library,\n" +"not the user. The user can only manage its life cycle with `open` and `close`,\n" "and perform operations on it with the other functions." msgstr "" -"Isso significa que todos os `DBM`s são \"propriedade\" da biblioteca no " -"sentido Rust.\n" -"O estado interno de tamanho desconhecido é mantido na memória controlada " -"pela biblioteca,\n" -"não o usuário. O usuário só pode gerenciar seu ciclo de vida com 'abrir' e " -"'fechar',\n" +"Isso significa que todos os `DBM`s são \"propriedade\" da biblioteca no sentido Rust.\n" +"O estado interno de tamanho desconhecido é mantido na memória controlada pela biblioteca,\n" +"não o usuário. O usuário só pode gerenciar seu ciclo de vida com 'abrir' e 'fechar',\n" "e executar operações nele com as outras funções." #: src\patterns/ffi/export.md:79 #, fuzzy msgid "" "The `datum` type was called a \"transactional\" type above.\n" -"It is designed to facilitate the exchange of information between the library " -"and\n" +"It is designed to facilitate the exchange of information between the library and\n" "its user." msgstr "" "O tipo `datum` foi chamado de tipo \"transacional\" acima.\n" -"Ele é projetado para facilitar a troca de informações entre a biblioteca e " -"os\n" +"Ele é projetado para facilitar a troca de informações entre a biblioteca e os\n" "seu usuário." #: src\patterns/ffi/export.md:83 #, fuzzy msgid "" -"The database is designed to store \"unstructured data\", with no pre-defined " -"length\n" -"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a " -"bunch\n" -"of bytes, and a count of how many there are. The main difference is that " -"there is\n" +"The database is designed to store \"unstructured data\", with no pre-defined length\n" +"or meaning. As a result, the `datum` is the C equivalent of a Rust slice: a bunch\n" +"of bytes, and a count of how many there are. The main difference is that there is\n" "no type information, which is what `void` indicates." msgstr "" -"O banco de dados é projetado para armazenar \"dados não estruturados\", sem " -"comprimento pré-definido\n" -"ou significado. Como resultado, o `datum` é o equivalente em C de uma fatia " -"Rust: um monte\n" -"de bytes e uma contagem de quantos existem. A principal diferença é que " -"existe\n" +"O banco de dados é projetado para armazenar \"dados não estruturados\", sem comprimento pré-definido\n" +"ou significado. Como resultado, o `datum` é o equivalente em C de uma fatia Rust: um monte\n" +"de bytes e uma contagem de quantos existem. A principal diferença é que existe\n" "nenhuma informação de tipo, que é o que `void` indica." #: src\patterns/ffi/export.md:88 @@ -6587,29 +5613,23 @@ msgstr "" msgid "" "Keep in mind that this header is written from the library's point of view.\n" "The user likely has some type they are using, which has a known size.\n" -"But the library does not care, and by the rules of C casting, any type " -"behind a\n" +"But the library does not care, and by the rules of C casting, any type behind a\n" "pointer can be cast to `void`." msgstr "" -"Tenha em mente que este cabeçalho foi escrito do ponto de vista da " -"biblioteca.\n" -"O usuário provavelmente tem algum tipo que está usando, que tem um tamanho " -"conhecido.\n" -"Mas a biblioteca não se importa, e pelas regras do C casting, qualquer tipo " -"por trás de um\n" +"Tenha em mente que este cabeçalho foi escrito do ponto de vista da biblioteca.\n" +"O usuário provavelmente tem algum tipo que está usando, que tem um tamanho conhecido.\n" +"Mas a biblioteca não se importa, e pelas regras do C casting, qualquer tipo por trás de um\n" "ponteiro pode ser convertido em `void`." #: src\patterns/ffi/export.md:93 #, fuzzy msgid "" -"As noted earlier, this type is _transparent_ to the user. But also, this " -"type is\n" +"As noted earlier, this type is _transparent_ to the user. But also, this type is\n" "_owned_ by the user.\n" "This has subtle ramifications, due to that pointer inside it.\n" "The question is, who owns the memory that pointer points to?" msgstr "" -"Conforme observado anteriormente, esse tipo é _transparent_ para o usuário. " -"Mas também, este tipo é\n" +"Conforme observado anteriormente, esse tipo é _transparent_ para o usuário. Mas também, este tipo é\n" "_propriedade_ do usuário.\n" "Isso tem ramificações sutis, devido ao ponteiro dentro dele.\n" "A questão é: a quem pertence a memória para a qual o ponteiro aponta?" @@ -6618,20 +5638,15 @@ msgstr "" #, fuzzy msgid "" "The answer for best memory safety is, \"the user\".\n" -"But in cases such as retrieving a value, the user does not know how to " -"allocate\n" -"it correctly (since they don't know how long the value is). In this case, " -"the library\n" -"code is expected to use the heap that the user has access to -- such as the " -"C library\n" +"But in cases such as retrieving a value, the user does not know how to allocate\n" +"it correctly (since they don't know how long the value is). In this case, the library\n" +"code is expected to use the heap that the user has access to -- such as the C library\n" "`malloc` and `free` -- and then _transfer ownership_ in the Rust sense." msgstr "" "A resposta para a melhor segurança de memória é \"o usuário\".\n" "Mas em casos como recuperar um valor, o usuário não sabe como alocar\n" -"corretamente (já que eles não sabem quanto tempo é o valor). Neste caso, a " -"biblioteca\n" -"espera-se que o código use o heap ao qual o usuário tem acesso -- como a " -"biblioteca C\n" +"corretamente (já que eles não sabem quanto tempo é o valor). Neste caso, a biblioteca\n" +"espera-se que o código use o heap ao qual o usuário tem acesso -- como a biblioteca C\n" "`malloc` e `free` -- e então _transferir propriedade_ no sentido Rust." #: src\patterns/ffi/export.md:104 @@ -6639,77 +5654,60 @@ msgstr "" msgid "" "This may all seem speculative, but this is what a pointer means in C.\n" "It means the same thing as Rust: \"user defined lifetime.\"\n" -"The user of the library needs to read the documentation in order to use it " -"correctly.\n" -"That said, there are some decisions that have fewer or greater consequences " -"if users\n" -"do it wrong. Minimizing those are what this best practice is about, and the " -"key\n" +"The user of the library needs to read the documentation in order to use it correctly.\n" +"That said, there are some decisions that have fewer or greater consequences if users\n" +"do it wrong. Minimizing those are what this best practice is about, and the key\n" "is to _transfer ownership of everything that is transparent_." msgstr "" -"Tudo isso pode parecer especulativo, mas é isso que um ponteiro significa em " -"C.\n" +"Tudo isso pode parecer especulativo, mas é isso que um ponteiro significa em C.\n" "Significa a mesma coisa que Rust: \"tempo de vida definido pelo usuário\".\n" -"O usuário da biblioteca precisa ler a documentação para utilizá-la " -"corretamente.\n" -"Dito isso, há algumas decisões que têm menos ou mais consequências se os " -"usuários\n" +"O usuário da biblioteca precisa ler a documentação para utilizá-la corretamente.\n" +"Dito isso, há algumas decisões que têm menos ou mais consequências se os usuários\n" "faça errado. Minimizá-los é o objetivo desta melhor prática, e a chave\n" "é _transferir a propriedade de tudo que é transparente_." #: src\patterns/ffi/export.md:113 #, fuzzy msgid "" -"This minimizes the number of memory safety guarantees the user must uphold " -"to a\n" +"This minimizes the number of memory safety guarantees the user must uphold to a\n" "relatively small number:" msgstr "" -"Isso minimiza o número de garantias de segurança de memória que o usuário " -"deve manter a um\n" +"Isso minimiza o número de garantias de segurança de memória que o usuário deve manter a um\n" "número relativamente pequeno:" #: src\patterns/ffi/export.md:116 #, fuzzy msgid "" -"1. Do not call any function with a pointer not returned by `dbm_open` " -"(invalid\n" +"1. Do not call any function with a pointer not returned by `dbm_open` (invalid\n" " access or corruption).\n" "2. Do not call any function on a pointer after close (use after free).\n" -"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of " -"memory\n" +"3. The `dptr` on any `datum` must be `NULL`, or point to a valid slice of memory\n" " at the advertised length." msgstr "" -"1. Não chame nenhuma função com um ponteiro não retornado por `dbm_open` " -"(inválido\n" +"1. Não chame nenhuma função com um ponteiro não retornado por `dbm_open` (inválido\n" " acesso ou corrupção).\n" -"2. Não chame nenhuma função em um ponteiro depois de fechar (use depois de " -"liberar).\n" -"3. O `dptr` em qualquer `datum` deve ser `NULL` ou apontar para uma parte " -"válida da memória\n" +"2. Não chame nenhuma função em um ponteiro depois de fechar (use depois de liberar).\n" +"3. O `dptr` em qualquer `datum` deve ser `NULL` ou apontar para uma parte válida da memória\n" " no comprimento anunciado." #: src\patterns/ffi/export.md:122 #, fuzzy msgid "" "In addition, it avoids a lot of pointer provenance issues.\n" -"To understand why, let us consider an alternative in some depth: key " -"iteration." +"To understand why, let us consider an alternative in some depth: key iteration." msgstr "" "Além disso, evita muitos problemas de proveniência do ponteiro.\n" -"Para entender o porquê, vamos considerar uma alternativa com alguma " -"profundidade: iteração de chave." +"Para entender o porquê, vamos considerar uma alternativa com alguma profundidade: iteração de chave." #: src\patterns/ffi/export.md:125 #, fuzzy msgid "" "Rust is well known for its iterators.\n" -"When implementing one, the programmer makes a separate type with a bounded " -"lifetime\n" +"When implementing one, the programmer makes a separate type with a bounded lifetime\n" "to its owner, and implements the `Iterator` trait." msgstr "" "Rust é bem conhecido por seus iteradores.\n" -"Ao implementar um, o programador cria um tipo separado com um tempo de vida " -"limitado\n" +"Ao implementar um, o programador cria um tipo separado com um tempo de vida limitado\n" "ao seu proprietário e implementa a característica `Iterator`." #: src\patterns/ffi/export.md:129 @@ -6750,21 +5748,18 @@ msgid "" "```rust,ignore\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_new(owner: *const Dbm) -> *mut DbmKeysIter {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_next(\n" " iter: *mut DbmKeysIter,\n" " key_out: *const datum\n" ") -> libc::c_int {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "#[no_mangle]\n" "pub extern \"C\" fn dbm_iter_del(*mut DbmKeysIter) {\n" -" // THIS API IS A BAD IDEA! For real applications, use object-based " -"design instead.\n" +" // THIS API IS A BAD IDEA! For real applications, use object-based design instead.\n" "}\n" "```" msgstr "" @@ -6772,26 +5767,19 @@ msgstr "" #: src\patterns/ffi/export.md:168 #, fuzzy msgid "" -"This API loses a key piece of information: the lifetime of the iterator must " -"not\n" -"exceed the lifetime of the `Dbm` object that owns it. A user of the library " -"could\n" -"use it in a way which causes the iterator to outlive the data it is " -"iterating on,\n" +"This API loses a key piece of information: the lifetime of the iterator must not\n" +"exceed the lifetime of the `Dbm` object that owns it. A user of the library could\n" +"use it in a way which causes the iterator to outlive the data it is iterating on,\n" "resulting in reading uninitialized memory." msgstr "" -"Essa API perde uma informação importante: o tempo de vida do iterador não " -"deve\n" -"exceder o tempo de vida do objeto `Dbm` que o possui. Um usuário da " -"biblioteca pode\n" -"usá-lo de uma maneira que faça com que o iterador sobreviva aos dados em que " -"está iterando,\n" +"Essa API perde uma informação importante: o tempo de vida do iterador não deve\n" +"exceder o tempo de vida do objeto `Dbm` que o possui. Um usuário da biblioteca pode\n" +"usá-lo de uma maneira que faça com que o iterador sobreviva aos dados em que está iterando,\n" "resultando na leitura de memória não inicializada." #: src\patterns/ffi/export.md:173 #, fuzzy -msgid "" -"This example written in C contains a bug that will be explained afterwards:" +msgid "This example written in C contains a bug that will be explained afterwards:" msgstr "Este exemplo escrito em C contém um bug que será explicado a seguir:" #: src\patterns/ffi/export.md:175 @@ -6808,8 +5796,7 @@ msgid "" " }\n" "\n" " int l;\n" -" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated " -"by -1\n" +" while ((l = dbm_iter_next(owner, &key)) >= 0) { // an error is indicated by -1\n" " free(key.dptr);\n" " len += key.dsize;\n" " if (l == 0) { // end of the iterator\n" @@ -6831,82 +5818,62 @@ msgid "" "This bug is a classic. Here's what happens when the iterator returns the\n" "end-of-iteration marker:" msgstr "" -"Este erro é um clássico. Aqui está o que acontece quando o iterador retorna " -"o\n" +"Este erro é um clássico. Aqui está o que acontece quando o iterador retorna o\n" "marcador de fim de iteração:" #: src\patterns/ffi/export.md:205 #, fuzzy msgid "" -"1. The loop condition sets `l` to zero, and enters the loop because `0 >= " -"0`.\n" +"1. The loop condition sets `l` to zero, and enters the loop because `0 >= 0`.\n" "2. The length is incremented, in this case by zero.\n" -"3. The if statement is true, so the database is closed. There should be a " -"break\n" +"3. The if statement is true, so the database is closed. There should be a break\n" " statement here.\n" -"4. The loop condition executes again, causing a `next` call on the closed " -"object." +"4. The loop condition executes again, causing a `next` call on the closed object." msgstr "" "1. A condição do loop define `l` como zero e entra no loop porque `0 >= 0`.\n" "2. O comprimento é incrementado, neste caso por zero.\n" -"3. A instrução if é verdadeira, então o banco de dados está fechado. Deve " -"haver uma pausa\n" +"3. A instrução if é verdadeira, então o banco de dados está fechado. Deve haver uma pausa\n" " declaração aqui.\n" -"4. A condição do loop é executada novamente, causando uma chamada `next` no " -"objeto fechado." +"4. A condição do loop é executada novamente, causando uma chamada `next` no objeto fechado." #: src\patterns/ffi/export.md:211 #, fuzzy msgid "" "The worst part about this bug?\n" -"If the Rust implementation was careful, this code will work most of the " -"time!\n" -"If the memory for the `Dbm` object is not immediately reused, an internal " -"check\n" -"will almost certainly fail, resulting in the iterator returning a `-1` " -"indicating\n" -"an error. But occasionally, it will cause a segmentation fault, or even " -"worse,\n" +"If the Rust implementation was careful, this code will work most of the time!\n" +"If the memory for the `Dbm` object is not immediately reused, an internal check\n" +"will almost certainly fail, resulting in the iterator returning a `-1` indicating\n" +"an error. But occasionally, it will cause a segmentation fault, or even worse,\n" "nonsensical memory corruption!" msgstr "" "A pior parte desse bug?\n" -"Se a implementação do Rust for cuidadosa, esse código funcionará na maioria " -"das vezes!\n" -"Se a memória para o objeto `Dbm` não for reutilizada imediatamente, uma " -"verificação interna\n" -"quase certamente falhará, resultando no iterador retornando um `-1` " -"indicando\n" -"um erro. Mas, ocasionalmente, causará uma falha de segmentação ou, pior " -"ainda,\n" +"Se a implementação do Rust for cuidadosa, esse código funcionará na maioria das vezes!\n" +"Se a memória para o objeto `Dbm` não for reutilizada imediatamente, uma verificação interna\n" +"quase certamente falhará, resultando no iterador retornando um `-1` indicando\n" +"um erro. Mas, ocasionalmente, causará uma falha de segmentação ou, pior ainda,\n" "corrupção de memória sem sentido!" #: src\patterns/ffi/export.md:218 #, fuzzy msgid "" "None of this can be avoided by Rust.\n" -"From its perspective, it put those objects on its heap, returned pointers to " -"them,\n" +"From its perspective, it put those objects on its heap, returned pointers to them,\n" "and gave up control of their lifetimes. The C code simply must \"play nice\"." msgstr "" "Nada disso pode ser evitado por Rust.\n" -"De sua perspectiva, ele colocou esses objetos em sua pilha, retornou " -"ponteiros para eles,\n" -"e desistiram do controle de suas vidas. O código C simplesmente deve \"jogar " -"bem\"." +"De sua perspectiva, ele colocou esses objetos em sua pilha, retornou ponteiros para eles,\n" +"e desistiram do controle de suas vidas. O código C simplesmente deve \"jogar bem\"." #: src\patterns/ffi/export.md:222 #, fuzzy msgid "" "The programmer must read and understand the API documentation.\n" -"While some consider that par for the course in C, a good API design can " -"mitigate\n" -"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ " -"of\n" +"While some consider that par for the course in C, a good API design can mitigate\n" +"this risk. The POSIX API for `DBM` did this by _consolidating the ownership_ of\n" "the iterator with its parent:" msgstr "" "O programador deve ler e entender a documentação da API.\n" -"Enquanto alguns consideram esse par para o curso em C, um bom design de API " -"pode atenuar\n" +"Enquanto alguns consideram esse par para o curso em C, um bom design de API pode atenuar\n" "este risco. A API POSIX para `DBM` fez isso _consolidando a propriedade_ de\n" "o iterador com seu pai:" @@ -6920,8 +5887,7 @@ msgstr "" #: src\patterns/ffi/export.md:232 #, fuzzy -msgid "" -"Thus, all the lifetimes were bound together, and such unsafety was prevented." +msgid "Thus, all the lifetimes were bound together, and such unsafety was prevented." msgstr "Assim, todas as vidas foram unidas e tal insegurança foi evitada." #: src\patterns/ffi/export.md:236 @@ -6930,71 +5896,55 @@ msgid "" "However, this design choice also has a number of drawbacks, which should be\n" "considered as well." msgstr "" -"No entanto, esta escolha de design também tem uma série de desvantagens, que " -"devem ser\n" +"No entanto, esta escolha de design também tem uma série de desvantagens, que devem ser\n" "considerado também." #: src\patterns/ffi/export.md:239 #, fuzzy msgid "" "First, the API itself becomes less expressive.\n" -"With POSIX DBM, there is only one iterator per object, and every call " -"changes\n" -"its state. This is much more restrictive than iterators in almost any " -"language,\n" -"even though it is safe. Perhaps with other related objects, whose lifetimes " -"are\n" +"With POSIX DBM, there is only one iterator per object, and every call changes\n" +"its state. This is much more restrictive than iterators in almost any language,\n" +"even though it is safe. Perhaps with other related objects, whose lifetimes are\n" "less hierarchical, this limitation is more of a cost than the safety." msgstr "" "Primeiro, a própria API se torna menos expressiva.\n" "Com POSIX DBM, há apenas um iterador por objeto e cada chamada muda\n" -"seu estado. Isso é muito mais restritivo do que iteradores em quase qualquer " -"idioma,\n" -"mesmo que seja seguro. Talvez com outros objetos relacionados, cujas vidas " -"são\n" +"seu estado. Isso é muito mais restritivo do que iteradores em quase qualquer idioma,\n" +"mesmo que seja seguro. Talvez com outros objetos relacionados, cujas vidas são\n" "menos hierárquica, essa limitação é mais um custo do que a segurança." #: src\patterns/ffi/export.md:245 #, fuzzy msgid "" -"Second, depending on the relationships of the API's parts, significant " -"design effort\n" -"may be involved. Many of the easier design points have other patterns " -"associated\n" +"Second, depending on the relationships of the API's parts, significant design effort\n" +"may be involved. Many of the easier design points have other patterns associated\n" "with them:" msgstr "" -"Em segundo lugar, dependendo das relações das partes da API, um esforço de " -"design significativo\n" -"pode estar envolvido. Muitos dos pontos de design mais fáceis têm outros " -"padrões associados\n" +"Em segundo lugar, dependendo das relações das partes da API, um esforço de design significativo\n" +"pode estar envolvido. Muitos dos pontos de design mais fáceis têm outros padrões associados\n" "com eles:" #: src\patterns/ffi/export.md:249 #, fuzzy msgid "" -"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types " -"together\n" +"- [Wrapper Type Consolidation](./wrappers.md) groups multiple Rust types together\n" " into an opaque \"object\"\n" "\n" -"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling " -"with integer\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) explains error handling with integer\n" " codes and sentinel return values (such as `NULL` pointers)\n" "\n" -"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows " -"accepting\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) allows accepting\n" " strings with minimal unsafe code, and is easier to get right than\n" " [Passing Strings to FFI](../../idioms/ffi/passing-strings.md)" msgstr "" -"- [Consolidação de tipo de wrapper](./wrappers.md) agrupa vários tipos de " -"Rust\n" +"- [Consolidação de tipo de wrapper](./wrappers.md) agrupa vários tipos de Rust\n" " em um \"objeto\" opaco\n" "\n" -"- [FFI Error Passing](../../idioms/ffi/errors.md) explica o tratamento de " -"erros com número inteiro\n" +"- [FFI Error Passing](../../idioms/ffi/errors.md) explica o tratamento de erros com número inteiro\n" " códigos e valores de retorno do sentinela (como ponteiros `NULL`)\n" "\n" -"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) permite " -"aceitar\n" +"- [Accepting Foreign Strings](../../idioms/ffi/accepting-strings.md) permite aceitar\n" " strings com código inseguro mínimo e é mais fácil de acertar do que\n" " [Passando Strings para FFI](../../idioms/ffi/passing-strings.md)" @@ -7015,12 +5965,10 @@ msgstr "# Digite a consolidação em wrappers" #: src\patterns/ffi/wrappers.md:5 #, fuzzy msgid "" -"This pattern is designed to allow gracefully handling multiple related " -"types,\n" +"This pattern is designed to allow gracefully handling multiple related types,\n" "while minimizing the surface area for memory unsafety." msgstr "" -"Esse padrão foi projetado para permitir o manuseio elegante de vários tipos " -"relacionados,\n" +"Esse padrão foi projetado para permitir o manuseio elegante de vários tipos relacionados,\n" "enquanto minimiza a área de superfície para insegurança de memória." #: src\patterns/ffi/wrappers.md:8 @@ -7031,61 +5979,47 @@ msgid "" "data race safety included." msgstr "" "Um dos pilares das regras de aliasing de Rust são os tempos de vida.\n" -"Isso garante que muitos padrões de acesso entre os tipos possam ser seguros " -"para a memória,\n" +"Isso garante que muitos padrões de acesso entre os tipos possam ser seguros para a memória,\n" "segurança de corrida de dados incluída." #: src\patterns/ffi/wrappers.md:12 #, fuzzy msgid "" -"However, when Rust types are exported to other languages, they are usually " -"transformed\n" -"into pointers. In Rust, a pointer means \"the user manages the lifetime of " -"the pointee.\"\n" +"However, when Rust types are exported to other languages, they are usually transformed\n" +"into pointers. In Rust, a pointer means \"the user manages the lifetime of the pointee.\"\n" "It is their responsibility to avoid memory unsafety." msgstr "" -"No entanto, quando os tipos Rust são exportados para outros idiomas, eles " -"geralmente são transformados\n" -"em ponteiros. Em Rust, um ponteiro significa \"o usuário gerencia o tempo de " -"vida da ponta\".\n" +"No entanto, quando os tipos Rust são exportados para outros idiomas, eles geralmente são transformados\n" +"em ponteiros. Em Rust, um ponteiro significa \"o usuário gerencia o tempo de vida da ponta\".\n" "É sua responsabilidade evitar a insegurança da memória." #: src\patterns/ffi/wrappers.md:16 #, fuzzy msgid "" -"Some level of trust in the user code is thus required, notably around " -"use-after-free\n" -"which Rust can do nothing about. However, some API designs place higher " -"burdens\n" +"Some level of trust in the user code is thus required, notably around use-after-free\n" +"which Rust can do nothing about. However, some API designs place higher burdens\n" "than others on the code written in the other language." msgstr "" -"Algum nível de confiança no código do usuário é, portanto, necessário, " -"principalmente em torno do use-after-free\n" -"sobre o qual Rust não pode fazer nada. No entanto, alguns designs de API " -"impõem cargas maiores\n" +"Algum nível de confiança no código do usuário é, portanto, necessário, principalmente em torno do use-after-free\n" +"sobre o qual Rust não pode fazer nada. No entanto, alguns designs de API impõem cargas maiores\n" "do que outros no código escrito no outro idioma." #: src\patterns/ffi/wrappers.md:20 #, fuzzy msgid "" -"The lowest risk API is the \"consolidated wrapper\", where all possible " -"interactions\n" -"with an object are folded into a \"wrapper type\", while keeping the Rust " -"API clean." +"The lowest risk API is the \"consolidated wrapper\", where all possible interactions\n" +"with an object are folded into a \"wrapper type\", while keeping the Rust API clean." msgstr "" -"A API de menor risco é o \"wrapper consolidado\", onde todas as interações " -"possíveis\n" +"A API de menor risco é o \"wrapper consolidado\", onde todas as interações possíveis\n" "com um objeto são dobrados em um \"tipo wrapper\", mantendo a API Rust limpa." #: src\patterns/ffi/wrappers.md:25 #, fuzzy msgid "" -"To understand this, let us look at a classic example of an API to export: " -"iteration\n" +"To understand this, let us look at a classic example of an API to export: iteration\n" "through a collection." msgstr "" -"Para entender isso, vejamos um exemplo clássico de uma API para exportar: " -"iteração\n" +"Para entender isso, vejamos um exemplo clássico de uma API para exportar: iteração\n" "através de uma coleção." #: src\patterns/ffi/wrappers.md:28 @@ -7099,26 +6033,22 @@ msgid "" "1. The iterator is initialized with `first_key`.\n" "2. Each call to `next_key` will advance the iterator.\n" "3. Calls to `next_key` if the iterator is at the end will do nothing.\n" -"4. As noted above, the iterator is \"wrapped into\" the collection (unlike " -"the native\n" +"4. As noted above, the iterator is \"wrapped into\" the collection (unlike the native\n" " Rust API)." msgstr "" "1. O iterador é inicializado com `first_key`.\n" "2. Cada chamada para `next_key` avançará o iterador.\n" "3. Chamadas para `next_key` se o iterador estiver no final não farão nada.\n" -"4. Conforme observado acima, o iterador é \"envolto\" na coleção (ao " -"contrário do nativo\n" +"4. Conforme observado acima, o iterador é \"envolto\" na coleção (ao contrário do nativo\n" " API de ferrugem)." #: src\patterns/ffi/wrappers.md:36 #, fuzzy msgid "" -"If the iterator implements `nth()` efficiently, then it is possible to make " -"it\n" +"If the iterator implements `nth()` efficiently, then it is possible to make it\n" "ephemeral to each function call:" msgstr "" -"Se o iterador implementa `nth()` de forma eficiente, então é possível " -"torná-lo\n" +"Se o iterador implementa `nth()` de forma eficiente, então é possível torná-lo\n" "efêmero para cada chamada de função:" #: src\patterns/ffi/wrappers.md:39 @@ -7149,51 +6079,39 @@ msgstr "" #: src\patterns/ffi/wrappers.md:61 #, fuzzy msgid "As a result, the wrapper is simple and contains no `unsafe` code." -msgstr "" -"Como resultado, o wrapper é simples e não contém nenhum código `inseguro`." +msgstr "Como resultado, o wrapper é simples e não contém nenhum código `inseguro`." #: src\patterns/ffi/wrappers.md:65 #, fuzzy msgid "" "This makes APIs safer to use, avoiding issues with lifetimes between types.\n" -"See [Object-Based APIs](./export.md) for more on the advantages and " -"pitfalls\n" +"See [Object-Based APIs](./export.md) for more on the advantages and pitfalls\n" "this avoids." msgstr "" -"Isso torna as APIs mais seguras de usar, evitando problemas com tempos de " -"vida entre os tipos.\n" -"Consulte [APIs baseadas em objetos](./export.md) para saber mais sobre as " -"vantagens e armadilhas\n" +"Isso torna as APIs mais seguras de usar, evitando problemas com tempos de vida entre os tipos.\n" +"Consulte [APIs baseadas em objetos](./export.md) para saber mais sobre as vantagens e armadilhas\n" "isso evita." #: src\patterns/ffi/wrappers.md:71 #, fuzzy msgid "" -"Often, wrapping types is quite difficult, and sometimes a Rust API " -"compromise\n" +"Often, wrapping types is quite difficult, and sometimes a Rust API compromise\n" "would make things easier." msgstr "" -"Freqüentemente, os tipos de empacotamento são bastante difíceis e, às vezes, " -"um comprometimento da Rust API\n" +"Freqüentemente, os tipos de empacotamento são bastante difíceis e, às vezes, um comprometimento da Rust API\n" "facilitaria as coisas." #: src\patterns/ffi/wrappers.md:74 #, fuzzy msgid "" -"As an example, consider an iterator which does not efficiently implement " -"`nth()`.\n" -"It would definitely be worth putting in special logic to make the object " -"handle\n" -"iteration internally, or to support a different access pattern efficiently " -"that\n" +"As an example, consider an iterator which does not efficiently implement `nth()`.\n" +"It would definitely be worth putting in special logic to make the object handle\n" +"iteration internally, or to support a different access pattern efficiently that\n" "only the Foreign Function API will use." msgstr "" -"Como exemplo, considere um iterador que não implementa eficientemente " -"`nth()`.\n" -"Definitivamente valeria a pena colocar uma lógica especial para fazer o " -"objeto manipular\n" -"iteração internamente, ou para suportar um padrão de acesso diferente de " -"forma eficiente que\n" +"Como exemplo, considere um iterador que não implementa eficientemente `nth()`.\n" +"Definitivamente valeria a pena colocar uma lógica especial para fazer o objeto manipular\n" +"iteração internamente, ou para suportar um padrão de acesso diferente de forma eficiente que\n" "somente a API de Função Estrangeira usará." #: src\patterns/ffi/wrappers.md:79 @@ -7204,16 +6122,12 @@ msgstr "### Tentando agrupar iteradores (e falhando)" #: src\patterns/ffi/wrappers.md:81 #, fuzzy msgid "" -"To wrap any type of iterator into the API correctly, the wrapper would need " -"to\n" -"do what a C version of the code would do: erase the lifetime of the " -"iterator,\n" +"To wrap any type of iterator into the API correctly, the wrapper would need to\n" +"do what a C version of the code would do: erase the lifetime of the iterator,\n" "and manage it manually." msgstr "" -"Para agrupar qualquer tipo de iterador na API corretamente, o empacotador " -"precisaria\n" -"fazer o que uma versão C do código faria: apagar o tempo de vida do " -"iterador,\n" +"Para agrupar qualquer tipo de iterador na API corretamente, o empacotador precisaria\n" +"fazer o que uma versão C do código faria: apagar o tempo de vida do iterador,\n" "e gerenciá-lo manualmente." #: src\patterns/ffi/wrappers.md:85 @@ -7250,8 +6164,7 @@ msgid "" "it's ugly already. But it gets even worse: _any other operation can cause\n" "Rust `undefined behaviour`_." msgstr "" -"Com `transmutar` sendo usado para estender uma vida, e um ponteiro para " -"ocultá-lo,\n" +"Com `transmutar` sendo usado para estender uma vida, e um ponteiro para ocultá-lo,\n" "já está feio. Mas fica ainda pior: _qualquer outra operação pode causar\n" "Rust `comportamento indefinido`_." @@ -7287,8 +6200,7 @@ msgid "" "\n" " // DO NOT USE THIS CODE. IT IS UNSAFE TO DEMONSTRATE A PROLBEM.\n" "\n" -" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in " -"here!\n" +" let myset: &mut MySet = unsafe { // SAFETY: whoops, UB occurs in here!\n" " &mut (*myset).myset\n" " };\n" "\n" @@ -7306,102 +6218,71 @@ msgstr "" #: src\patterns/ffi/wrappers.md:137 #, fuzzy msgid "" -"If the iterator exists when this function is called, we have violated one of " -"Rust's\n" -"aliasing rules. According to Rust, the mutable reference in this block must " -"have\n" -"_exclusive_ access to the object. If the iterator simply exists, it's not " -"exclusive,\n" +"If the iterator exists when this function is called, we have violated one of Rust's\n" +"aliasing rules. According to Rust, the mutable reference in this block must have\n" +"_exclusive_ access to the object. If the iterator simply exists, it's not exclusive,\n" "so we have `undefined behaviour`! " msgstr "" -"Se o iterador existir quando esta função for chamada, violamos uma das " -"regras do Rust\n" -"regras de alias. De acordo com Rust, a referência mutável neste bloco deve " -"ter\n" -"acesso _exclusivo_ ao objeto. Se o iterador simplesmente existir, não é " -"exclusivo,\n" +"Se o iterador existir quando esta função for chamada, violamos uma das regras do Rust\n" +"regras de alias. De acordo com Rust, a referência mutável neste bloco deve ter\n" +"acesso _exclusivo_ ao objeto. Se o iterador simplesmente existir, não é exclusivo,\n" "então temos `comportamento indefinido`!" #: src\patterns/ffi/wrappers.md:142 #, fuzzy msgid "" -"To avoid this, we must have a way of ensuring that mutable reference really " -"is exclusive.\n" -"That basically means clearing out the iterator's shared reference while it " -"exists,\n" -"and then reconstructing it. In most cases, that will still be less efficient " -"than\n" +"To avoid this, we must have a way of ensuring that mutable reference really is exclusive.\n" +"That basically means clearing out the iterator's shared reference while it exists,\n" +"and then reconstructing it. In most cases, that will still be less efficient than\n" "the C version." msgstr "" -"Para evitar isso, devemos ter uma maneira de garantir que a referência " -"mutável seja realmente exclusiva.\n" -"Isso basicamente significa limpar a referência compartilhada do iterador " -"enquanto ela existe,\n" -"e depois reconstruí-lo. Na maioria dos casos, isso ainda será menos " -"eficiente do que\n" +"Para evitar isso, devemos ter uma maneira de garantir que a referência mutável seja realmente exclusiva.\n" +"Isso basicamente significa limpar a referência compartilhada do iterador enquanto ela existe,\n" +"e depois reconstruí-lo. Na maioria dos casos, isso ainda será menos eficiente do que\n" "a versão C." #: src\patterns/ffi/wrappers.md:147 #, fuzzy msgid "" "Some may ask: how can C do this more efficiently?\n" -"The answer is, it cheats. Rust's aliasing rules are the problem, and C " -"simply ignores\n" -"them for its pointers. In exchange, it is common to see code that is " -"declared\n" -"in the manual as \"not thread safe\" under some or all circumstances. In " -"fact,\n" -"the [GNU C " -"library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"The answer is, it cheats. Rust's aliasing rules are the problem, and C simply ignores\n" +"them for its pointers. In exchange, it is common to see code that is declared\n" +"in the manual as \"not thread safe\" under some or all circumstances. In fact,\n" +"the [GNU C library](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" "has an entire lexicon dedicated to concurrent behavior!" msgstr "" "Alguns podem perguntar: como C pode fazer isso de forma mais eficiente?\n" -"A resposta é: engana. As regras de aliasing do Rust são o problema, e C " -"simplesmente ignora\n" +"A resposta é: engana. As regras de aliasing do Rust são o problema, e C simplesmente ignora\n" "eles por seus ponteiros. Em troca, é comum ver código declarado\n" -"no manual como \"não thread-safe\" em algumas ou todas as circunstâncias. Na " -"verdade,\n" -"a [biblioteca GNU " -"C](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" +"no manual como \"não thread-safe\" em algumas ou todas as circunstâncias. Na verdade,\n" +"a [biblioteca GNU C](https://manpages.debian.org/buster/manpages/attributes.7.en.html)\n" "tem todo um léxico dedicado ao comportamento simultâneo!" #: src\patterns/ffi/wrappers.md:154 #, fuzzy msgid "" -"Rust would rather make everything memory safe all the time, for both safety " -"and\n" -"optimizations that C code cannot attain. Being denied access to certain " -"shortcuts\n" +"Rust would rather make everything memory safe all the time, for both safety and\n" +"optimizations that C code cannot attain. Being denied access to certain shortcuts\n" "is the price Rust programmers need to pay." msgstr "" -"Rust prefere tornar tudo seguro para a memória o tempo todo, tanto para " -"segurança quanto para\n" -"otimizações que o código C não pode atingir. Ser negado o acesso a certos " -"atalhos\n" +"Rust prefere tornar tudo seguro para a memória o tempo todo, tanto para segurança quanto para\n" +"otimizações que o código C não pode atingir. Ser negado o acesso a certos atalhos\n" "é o preço que os programadores Rust precisam pagar." #: src\patterns/ffi/wrappers.md:158 #, fuzzy msgid "" "For the C programmers out there scratching their heads, the iterator need\n" -"not be read _during_ this code cause the UB. The exclusivity rule also " -"enables\n" -"compiler optimizations which may cause inconsistent observations by the " -"iterator's\n" -"shared reference (e.g. stack spills or reordering instructions for " -"efficiency).\n" -"These observations may happen _any time after_ the mutable reference is " -"created." +"not be read _during_ this code cause the UB. The exclusivity rule also enables\n" +"compiler optimizations which may cause inconsistent observations by the iterator's\n" +"shared reference (e.g. stack spills or reordering instructions for efficiency).\n" +"These observations may happen _any time after_ the mutable reference is created." msgstr "" "Para os programadores C que estão coçando a cabeça, o iterador precisa\n" -"não ser lido _durante_ este código causa o UB. A regra de exclusividade " -"também permite\n" -"otimizações do compilador que podem causar observações inconsistentes por " -"parte do iterador\n" -"referência compartilhada (por exemplo, derramamentos de pilha ou " -"reordenamento de instruções para eficiência).\n" -"Essas observações podem acontecer _a qualquer momento após_ a referência " -"mutável ser criada." +"não ser lido _durante_ este código causa o UB. A regra de exclusividade também permite\n" +"otimizações do compilador que podem causar observações inconsistentes por parte do iterador\n" +"referência compartilhada (por exemplo, derramamentos de pilha ou reordenamento de instruções para eficiência).\n" +"Essas observações podem acontecer _a qualquer momento após_ a referência mutável ser criada." #: src\anti_patterns/index.md:1 #, fuzzy @@ -7411,25 +6292,18 @@ msgstr "# Antipadrões" #: src\anti_patterns/index.md:3 #, fuzzy msgid "" -"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution " -"to\n" +"An [anti-pattern](https://en.wikipedia.org/wiki/Anti-pattern) is a solution to\n" "a \"recurring problem that is usually ineffective and risks being highly\n" "counterproductive\". Just as valuable as knowing how to solve a problem, is\n" -"knowing how _not_ to solve it. Anti-patterns give us great counter-examples " -"to\n" -"consider relative to design patterns. Anti-patterns are not confined to " -"code.\n" +"knowing how _not_ to solve it. Anti-patterns give us great counter-examples to\n" +"consider relative to design patterns. Anti-patterns are not confined to code.\n" "For example, a process can be an anti-pattern, too." msgstr "" -"Um [anti-padrão](https://en.wikipedia.org/wiki/Anti-padrão) é uma solução " -"para\n" -"um \"problema recorrente que geralmente é ineficaz e corre o risco de ser " -"altamente\n" +"Um [anti-padrão](https://en.wikipedia.org/wiki/Anti-padrão) é uma solução para\n" +"um \"problema recorrente que geralmente é ineficaz e corre o risco de ser altamente\n" "contraproducente\". Tão valioso quanto saber resolver um problema, é\n" -"sabendo _não_ resolvê-lo. Os antipadrões nos dão ótimos contra-exemplos " -"para\n" -"considerar em relação aos padrões de projeto. Os antipadrões não estão " -"confinados ao código.\n" +"sabendo _não_ resolvê-lo. Os antipadrões nos dão ótimos contra-exemplos para\n" +"considerar em relação aos padrões de projeto. Os antipadrões não estão confinados ao código.\n" "Por exemplo, um processo também pode ser um antipadrão." #: src\anti_patterns/borrow_clone.md:1 @@ -7440,24 +6314,16 @@ msgstr "# Clone para satisfazer o verificador de empréstimo" #: src\anti_patterns/borrow_clone.md:5 #, fuzzy msgid "" -"The borrow checker prevents Rust users from developing otherwise unsafe code " -"by\n" -"ensuring that either: only one mutable reference exists, or potentially many " -"but\n" -"all immutable references exist. If the code written does not hold true to " -"these\n" -"conditions, this anti-pattern arises when the developer resolves the " -"compiler\n" +"The borrow checker prevents Rust users from developing otherwise unsafe code by\n" +"ensuring that either: only one mutable reference exists, or potentially many but\n" +"all immutable references exist. If the code written does not hold true to these\n" +"conditions, this anti-pattern arises when the developer resolves the compiler\n" "error by cloning the variable." msgstr "" -"O verificador de empréstimo impede que os usuários do Rust desenvolvam " -"códigos inseguros,\n" -"garantindo que: apenas uma referência mutável existe, ou potencialmente " -"muitas, mas\n" -"todas as referências imutáveis existem. Se o código escrito não for fiel a " -"essas\n" -"condições, esse antipadrão surge quando o desenvolvedor resolve o problema " -"do compilador\n" +"O verificador de empréstimo impede que os usuários do Rust desenvolvam códigos inseguros,\n" +"garantindo que: apenas uma referência mutável existe, ou potencialmente muitas, mas\n" +"todas as referências imutáveis existem. Se o código escrito não for fiel a essas\n" +"condições, esse antipadrão surge quando o desenvolvedor resolve o problema do compilador\n" "erro ao clonar a variável." #: src\anti_patterns/borrow_clone.md:13 @@ -7469,8 +6335,7 @@ msgid "" "// Borrow `x` -- but clone it first\n" "let y = &mut (x.clone());\n" "\n" -"// without the x.clone() two lines prior, this line would fail on compile " -"as\n" +"// without the x.clone() two lines prior, this line would fail on compile as\n" "// x has been borrowed\n" "// thanks to x.clone(), x was never borrowed, and this line will run.\n" "println!(\"{}\", x);\n" @@ -7486,32 +6351,24 @@ msgstr "" msgid "" "It is tempting, particularly for beginners, to use this pattern to resolve\n" "confusing issues with the borrow checker. However, there are serious\n" -"consequences. Using `.clone()` causes a copy of the data to be made. Any " -"changes\n" -"between the two are not synchronized -- as if two completely separate " -"variables\n" +"consequences. Using `.clone()` causes a copy of the data to be made. Any changes\n" +"between the two are not synchronized -- as if two completely separate variables\n" "exist." msgstr "" "É tentador, principalmente para iniciantes, usar esse padrão para resolver\n" -"questões confusas com o verificador de empréstimo. No entanto, existem " -"graves\n" -"consequências. O uso de `.clone()` faz com que uma cópia dos dados seja " -"feita. Qualquer alteração\n" -"entre os dois não estão sincronizados - como se duas variáveis completamente " -"separadas\n" +"questões confusas com o verificador de empréstimo. No entanto, existem graves\n" +"consequências. O uso de `.clone()` faz com que uma cópia dos dados seja feita. Qualquer alteração\n" +"entre os dois não estão sincronizados - como se duas variáveis completamente separadas\n" "existir." #: src\anti_patterns/borrow_clone.md:38 #, fuzzy msgid "" -"There are special cases -- `Rc` is designed to handle clones " -"intelligently.\n" -"It internally manages exactly one copy of the data, and cloning it will " -"only\n" +"There are special cases -- `Rc` is designed to handle clones intelligently.\n" +"It internally manages exactly one copy of the data, and cloning it will only\n" "clone the reference." msgstr "" -"Existem casos especiais -- `Rc` é projetado para lidar com clones de " -"forma inteligente.\n" +"Existem casos especiais -- `Rc` é projetado para lidar com clones de forma inteligente.\n" "Ele gerencia internamente exatamente uma cópia dos dados e a clonagem só\n" "clonar a referência." @@ -7519,14 +6376,11 @@ msgstr "" #, fuzzy msgid "" "There is also `Arc` which provides shared ownership of a value of type T\n" -"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new " -"`Arc`\n" -"instance, which points to the same allocation on the heap as the source " -"`Arc`,\n" +"that is allocated in the heap. Invoking `.clone()` on `Arc` produces a new `Arc`\n" +"instance, which points to the same allocation on the heap as the source `Arc`,\n" "while increasing a reference count." msgstr "" -"Há também `Arc` que fornece propriedade compartilhada de um valor do tipo " -"T\n" +"Há também `Arc` que fornece propriedade compartilhada de um valor do tipo T\n" "que está alocado no heap. Invocar `.clone()` em `Arc` produz um novo `Arc`\n" "instância, que aponta para a mesma alocação no heap que a origem `Arc`,\n" "enquanto aumenta uma contagem de referência." @@ -7539,8 +6393,7 @@ msgid "" "that's a good indication this anti-pattern may be in use." msgstr "" "Em geral, os clones devem ser deliberados, com total compreensão do\n" -"consequências. Se um clone for usado para fazer desaparecer um erro do " -"verificador de empréstimo,\n" +"consequências. Se um clone for usado para fazer desaparecer um erro do verificador de empréstimo,\n" "essa é uma boa indicação de que esse antipadrão pode estar em uso." #: src\anti_patterns/borrow_clone.md:51 @@ -7564,63 +6417,46 @@ msgstr "" "- o desenvolvedor ainda é novo na propriedade\n" "- o código não tem grandes restrições de velocidade ou memória\n" " (como projetos ou protótipos de hackathon)\n" -"- satisfazer o verificador de empréstimo é realmente complicado e você " -"prefere\n" +"- satisfazer o verificador de empréstimo é realmente complicado e você prefere\n" " otimizar a legibilidade sobre o desempenho" #: src\anti_patterns/borrow_clone.md:60 #, fuzzy msgid "" -"If an unnecessary clone is suspected, The [Rust Book's chapter on " -"Ownership](https://doc.rust-lang.org/book/ownership.html)\n" -"should be understood fully before assessing whether the clone is required or " -"not." +"If an unnecessary clone is suspected, The [Rust Book's chapter on Ownership](https://doc.rust-lang.org/book/ownership.html)\n" +"should be understood fully before assessing whether the clone is required or not." msgstr "" -"Se houver suspeita de um clone desnecessário, o [capítulo do Rust Book sobre " -"propriedade](https://doc.rust-lang.org/book/ownership.html)\n" -"deve ser totalmente compreendido antes de avaliar se o clone é necessário ou " -"não." +"Se houver suspeita de um clone desnecessário, o [capítulo do Rust Book sobre propriedade](https://doc.rust-lang.org/book/ownership." +"html)\n" +"deve ser totalmente compreendido antes de avaliar se o clone é necessário ou não." #: src\anti_patterns/borrow_clone.md:63 #, fuzzy msgid "" -"Also be sure to always run `cargo clippy` in your project, which will detect " -"some\n" -"cases in which `.clone()` is not necessary, like " -"[1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"Also be sure to always run `cargo clippy` in your project, which will detect some\n" +"cases in which `.clone()` is not necessary, like [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" "[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" -"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or " -"[4](https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref)." +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) or [4](https://rust-lang.github.io/rust-clippy/master/index." +"html#clone_double_ref)." msgstr "" -"Certifique-se também de sempre executar `cargo clippy` em seu projeto, o que " -"detectará alguns\n" -"casos em que `.clone()` não é necessário, como " -"[1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" +"Certifique-se também de sempre executar `cargo clippy` em seu projeto, o que detectará alguns\n" +"casos em que `.clone()` não é necessário, como [1](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone),\n" "[2](https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy),\n" -"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) ou " -"[4](https://rust-lang.github.io/rust-clippy/master " -"/index.html#clone_double_ref)." +"[3](https://rust-lang.github.io/rust-clippy/master/index.html#map_clone) ou [4](https://rust-lang.github.io/rust-clippy/master /index." +"html#clone_double_ref)." #: src\anti_patterns/borrow_clone.md:70 #, fuzzy msgid "" -"- [`mem::{take(_), replace(_)}` to keep owned values in changed " -"enums](../idioms/mem-replace.md)\n" -"- [`Rc` documentation, which handles .clone() " -"intelligently](http://doc.rust-lang.org/std/rc/)\n" -"- [`Arc` documentation, a thread-safe reference-counting " -"pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" -"- [Tricks with ownership in " -"Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" -msgstr "" -"- [`mem::{take(_), replace(_)}` para manter os valores de propriedade em " -"enums alterados](../idioms/mem-replace.md)\n" -"- [documentação `Rc`, que lida com .clone() de forma " -"inteligente](http://doc.rust-lang.org/std/rc/)\n" -"- [Documentação do `Arc`, um ponteiro de contagem de referência " -"thread-safe](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" -"- [Truques com propriedade em " -"Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +"- [`mem::{take(_), replace(_)}` to keep owned values in changed enums](../idioms/mem-replace.md)\n" +"- [`Rc` documentation, which handles .clone() intelligently](http://doc.rust-lang.org/std/rc/)\n" +"- [`Arc` documentation, a thread-safe reference-counting pointer](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" +"- [Tricks with ownership in Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" +msgstr "" +"- [`mem::{take(_), replace(_)}` para manter os valores de propriedade em enums alterados](../idioms/mem-replace.md)\n" +"- [documentação `Rc`, que lida com .clone() de forma inteligente](http://doc.rust-lang.org/std/rc/)\n" +"- [Documentação do `Arc`, um ponteiro de contagem de referência thread-safe](https://doc.rust-lang.org/std/sync/struct.Arc.html)\n" +"- [Truques com propriedade em Rust](https://web.archive.org/web/20210120233744/https://xion.io/post/code/rust-borrowchk-tricks.html)" #: src\anti_patterns/deny-warnings.md:1 #, fuzzy @@ -7633,8 +6469,7 @@ msgid "" "A well-intentioned crate author wants to ensure their code builds without\n" "warnings. So they annotate their crate root with the following:" msgstr "" -"Um criador de caixas bem-intencionado quer garantir que seu código seja " -"construído sem\n" +"Um criador de caixas bem-intencionado quer garantir que seu código seja construído sem\n" "avisos. Então, eles anotam a raiz da caixa com o seguinte:" #: src\anti_patterns/deny-warnings.md:10 @@ -7659,38 +6494,27 @@ msgstr "## Desvantagens" #: src\anti_patterns/deny-warnings.md:22 #, fuzzy msgid "" -"By disallowing the compiler to build with warnings, a crate author opts out " -"of\n" -"Rust's famed stability. Sometimes new features or old misfeatures need a " -"change\n" -"in how things are done, thus lints are written that `warn` for a certain " -"grace\n" +"By disallowing the compiler to build with warnings, a crate author opts out of\n" +"Rust's famed stability. Sometimes new features or old misfeatures need a change\n" +"in how things are done, thus lints are written that `warn` for a certain grace\n" "period before being turned to `deny`." msgstr "" -"Ao não permitir que o compilador construa com avisos, um autor de caixa opta " -"por não\n" -"A famosa estabilidade de Rust. Às vezes, novos recursos ou antigos erros " -"precisam de uma mudança\n" -"em como as coisas são feitas, assim são escritos lints que 'advertem' para " -"uma certa graça\n" +"Ao não permitir que o compilador construa com avisos, um autor de caixa opta por não\n" +"A famosa estabilidade de Rust. Às vezes, novos recursos ou antigos erros precisam de uma mudança\n" +"em como as coisas são feitas, assim são escritos lints que 'advertem' para uma certa graça\n" "período antes de ser transformado em `negar`." #: src\anti_patterns/deny-warnings.md:27 #, fuzzy msgid "" -"For example, it was discovered that a type could have two `impl`s with the " -"same\n" -"method. This was deemed a bad idea, but in order to make the transition " -"smooth,\n" -"the `overlapping-inherent-impls` lint was introduced to give a warning to " -"those\n" +"For example, it was discovered that a type could have two `impl`s with the same\n" +"method. This was deemed a bad idea, but in order to make the transition smooth,\n" +"the `overlapping-inherent-impls` lint was introduced to give a warning to those\n" "stumbling on this fact, before it becomes a hard error in a future release." msgstr "" "Por exemplo, descobriu-se que um tipo poderia ter dois `impl`s com o mesmo\n" -"método. Isso foi considerado uma má ideia, mas para tornar a transição " -"suave,\n" -"o lint `overlapping-inherent-impls` foi introduzido para dar um aviso " -"àqueles\n" +"método. Isso foi considerado uma má ideia, mas para tornar a transição suave,\n" +"o lint `overlapping-inherent-impls` foi introduzido para dar um aviso àqueles\n" "tropeçando nesse fato, antes que se torne um erro grave em uma versão futura." #: src\anti_patterns/deny-warnings.md:32 @@ -7704,32 +6528,23 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:35 #, fuzzy -msgid "" -"All this conspires to potentially break the build whenever something changes." -msgstr "" -"Tudo isso conspira para potencialmente quebrar a construção sempre que algo " -"mudar." +msgid "All this conspires to potentially break the build whenever something changes." +msgstr "Tudo isso conspira para potencialmente quebrar a construção sempre que algo mudar." #: src\anti_patterns/deny-warnings.md:37 #, fuzzy msgid "" -"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can " -"no\n" +"Furthermore, crates that supply additional lints (e.g. [rust-clippy]) can no\n" "longer be used unless the annotation is removed. This is mitigated with\n" -"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all " -"`deny`\n" +"[--cap-lints]. The `--cap-lints=warn` command line argument, turns all `deny`\n" "lint errors into warnings." msgstr "" -"Além disso, as caixas que fornecem fiapos adicionais (por exemplo, " -"[ferrugem-clippy]) não podem\n" -"não será mais usado, a menos que a anotação seja removida. Isso é mitigado " -"com\n" -"[--cap-lints]. O argumento de linha de comando `--cap-lints=warn` transforma " -"todos os `deny`\n" +"Além disso, as caixas que fornecem fiapos adicionais (por exemplo, [ferrugem-clippy]) não podem\n" +"não será mais usado, a menos que a anotação seja removida. Isso é mitigado com\n" +"[--cap-lints]. O argumento de linha de comando `--cap-lints=warn` transforma todos os `deny`\n" "erros lint em avisos." -#: src\anti_patterns/deny-warnings.md:42 -#: src\functional/generics-type-classes.md:227 +#: src\anti_patterns/deny-warnings.md:42 src\functional/generics-type-classes.md:227 #, fuzzy msgid "## Alternatives" msgstr "## Alternativas" @@ -7737,23 +6552,18 @@ msgstr "## Alternativas" #: src\anti_patterns/deny-warnings.md:44 #, fuzzy msgid "" -"There are two ways of tackling this problem: First, we can decouple the " -"build\n" +"There are two ways of tackling this problem: First, we can decouple the build\n" "setting from the code, and second, we can name the lints we want to deny\n" "explicitly." msgstr "" -"Existem duas maneiras de lidar com esse problema: primeiro, podemos " -"desacoplar a construção\n" -"configuração do código e, segundo, podemos nomear os lints que queremos " -"negar\n" +"Existem duas maneiras de lidar com esse problema: primeiro, podemos desacoplar a construção\n" +"configuração do código e, segundo, podemos nomear os lints que queremos negar\n" "explicitamente." #: src\anti_patterns/deny-warnings.md:48 #, fuzzy msgid "The following command line will build with all warnings set to `deny`:" -msgstr "" -"A linha de comando a seguir será criada com todos os avisos definidos como " -"`deny`:" +msgstr "A linha de comando a seguir será criada com todos os avisos definidos como `deny`:" #: src\anti_patterns/deny-warnings.md:50 #, fuzzy @@ -7767,8 +6577,7 @@ msgid "" "Travis, but remember that this may break the build when something changes)\n" "without requiring a change to the code." msgstr "" -"Isso pode ser feito por qualquer desenvolvedor individual (ou pode ser " -"configurado em uma ferramenta CI como\n" +"Isso pode ser feito por qualquer desenvolvedor individual (ou pode ser configurado em uma ferramenta CI como\n" "Travis, mas lembre-se que isso pode quebrar a construção quando algo mudar)\n" "sem exigir alteração no código." @@ -7776,13 +6585,10 @@ msgstr "" #, fuzzy msgid "" "Alternatively, we can specify the lints that we want to `deny` in the code.\n" -"Here is a list of warning lints that is (hopefully) safe to deny (as of " -"Rustc 1.48.0):" +"Here is a list of warning lints that is (hopefully) safe to deny (as of Rustc 1.48.0):" msgstr "" -"Como alternativa, podemos especificar os lints que queremos `negar` no " -"código.\n" -"Aqui está uma lista de lints de aviso que é (espero) seguro negar (a partir " -"de Rustc 1.48.0):" +"Como alternativa, podemos especificar os lints que queremos `negar` no código.\n" +"Aqui está uma lista de lints de aviso que é (espero) seguro negar (a partir de Rustc 1.48.0):" #: src\anti_patterns/deny-warnings.md:59 msgid "" @@ -7809,8 +6615,7 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:78 #, fuzzy msgid "In addition, the following `allow`ed lints may be a good idea to `deny`:" -msgstr "" -"Além disso, os seguintes lints permitidos podem ser uma boa ideia para negar:" +msgstr "Além disso, os seguintes lints permitidos podem ser uma boa ideia para negar:" #: src\anti_patterns/deny-warnings.md:80 msgid "" @@ -7829,9 +6634,7 @@ msgstr "" #: src\anti_patterns/deny-warnings.md:91 #, fuzzy msgid "Some may also want to add `missing-copy-implementations` to their list." -msgstr "" -"Alguns também podem querer adicionar `missing-copy-implementations` à sua " -"lista." +msgstr "Alguns também podem querer adicionar `missing-copy-implementations` à sua lista." #: src\anti_patterns/deny-warnings.md:93 #, fuzzy @@ -7839,25 +6642,21 @@ msgid "" "Note that we explicitly did not add the `deprecated` lint, as it is fairly\n" "certain that there will be more deprecated APIs in the future." msgstr "" -"Observe que não adicionamos explicitamente o lint `obsoleto`, pois é " -"bastante\n" +"Observe que não adicionamos explicitamente o lint `obsoleto`, pois é bastante\n" "certo de que haverá mais APIs obsoletas no futuro." #: src\anti_patterns/deny-warnings.md:98 #, fuzzy msgid "" -"- [A collection of all clippy " -"lints](https://rust-lang.github.io/rust-clippy/master)\n" +"- [A collection of all clippy lints](https://rust-lang.github.io/rust-clippy/master)\n" "- [deprecate attribute] documentation\n" "- Type `rustc -W help` for a list of lints on your system. Also type\n" " `rustc --help` for a general list of options\n" "- [rust-clippy] is a collection of lints for better Rust code" msgstr "" -"- [Uma coleção de todos os lints " -"clippy](https://rust-lang.github.io/rust-clippy/master)\n" +"- [Uma coleção de todos os lints clippy](https://rust-lang.github.io/rust-clippy/master)\n" "- [atributo obsoleto] documentação\n" -"- Digite `rustc -W help` para obter uma lista de lints em seu sistema. " -"Digite também\n" +"- Digite `rustc -W help` para obter uma lista de lints em seu sistema. Digite também\n" " `rustc --help` para uma lista geral de opções\n" "- [rust-clippy] é uma coleção de lints para melhorar o código Rust" @@ -7869,19 +6668,16 @@ msgstr "# Polimorfismo `Deref`" #: src\anti_patterns/deref.md:5 #, fuzzy msgid "" -"Misuse the `Deref` trait to emulate inheritance between structs, and thus " -"reuse\n" +"Misuse the `Deref` trait to emulate inheritance between structs, and thus reuse\n" "methods." msgstr "" -"Use mal o trait `Deref` para emular a herança entre structs e, assim, " -"reutilizar\n" +"Use mal o trait `Deref` para emular a herança entre structs e, assim, reutilizar\n" "métodos." #: src\anti_patterns/deref.md:10 #, fuzzy msgid "" -"Sometimes we want to emulate the following common pattern from OO languages " -"such\n" +"Sometimes we want to emulate the following common pattern from OO languages such\n" "as Java:" msgstr "" "Às vezes, queremos emular o seguinte padrão comum de linguagens OO, como\n" @@ -7942,49 +6738,33 @@ msgstr "" #: src\anti_patterns/deref.md:56 #, fuzzy msgid "" -"There is no struct inheritance in Rust. Instead we use composition and " -"include\n" -"an instance of `Foo` in `Bar` (since the field is a value, it is stored " -"inline,\n" -"so if there were fields, they would have the same layout in memory as the " -"Java\n" +"There is no struct inheritance in Rust. Instead we use composition and include\n" +"an instance of `Foo` in `Bar` (since the field is a value, it is stored inline,\n" +"so if there were fields, they would have the same layout in memory as the Java\n" "version (probably, you should use `#[repr(C)]` if you want to be sure))." msgstr "" -"Não há herança de struct no Rust. Em vez disso, usamos composição e " -"incluímos\n" -"uma instância de `Foo` em `Bar` (como o campo é um valor, ele é armazenado " -"em linha,\n" -"portanto, se houvesse campos, eles teriam o mesmo layout na memória que o " -"Java\n" +"Não há herança de struct no Rust. Em vez disso, usamos composição e incluímos\n" +"uma instância de `Foo` em `Bar` (como o campo é um valor, ele é armazenado em linha,\n" +"portanto, se houvesse campos, eles teriam o mesmo layout na memória que o Java\n" "versão (provavelmente, você deve usar `#[repr(C)]` se quiser ter certeza))." #: src\anti_patterns/deref.md:61 #, fuzzy msgid "" -"In order to make the method call work we implement `Deref` for `Bar` with " -"`Foo`\n" +"In order to make the method call work we implement `Deref` for `Bar` with `Foo`\n" "as the target (returning the embedded `Foo` field). That means that when we\n" -"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That " -"is\n" -"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, " -"here we\n" +"dereference a `Bar` (for example, using `*`) then we will get a `Foo`. That is\n" +"pretty weird. Dereferencing usually gives a `T` from a reference to `T`, here we\n" "have two unrelated types. However, since the dot operator does implicit\n" -"dereferencing, it means that the method call will search for methods on " -"`Foo` as\n" +"dereferencing, it means that the method call will search for methods on `Foo` as\n" "well as `Bar`." msgstr "" -"Para fazer a chamada do método funcionar, implementamos `Deref` para `Bar` " -"com `Foo`\n" -"como o destino (retornando o campo `Foo` incorporado). Isso significa que " -"quando nós\n" -"desreferenciar um `Bar` (por exemplo, usando `*`) então obteremos um `Foo`. " -"Aquilo é\n" -"bem estranho. Desreferenciar geralmente dá um `T` de uma referência a `T`, " -"aqui nós\n" -"têm dois tipos não relacionados. No entanto, como o operador ponto " -"implícito\n" -"desreferenciação, isso significa que a chamada do método irá procurar " -"métodos em `Foo` como\n" +"Para fazer a chamada do método funcionar, implementamos `Deref` para `Bar` com `Foo`\n" +"como o destino (retornando o campo `Foo` incorporado). Isso significa que quando nós\n" +"desreferenciar um `Bar` (por exemplo, usando `*`) então obteremos um `Foo`. Aquilo é\n" +"bem estranho. Desreferenciar geralmente dá um `T` de uma referência a `T`, aqui nós\n" +"têm dois tipos não relacionados. No entanto, como o operador ponto implícito\n" +"desreferenciação, isso significa que a chamada do método irá procurar métodos em `Foo` como\n" "bem como 'Bar'." #: src\anti_patterns/deref.md:71 @@ -8006,134 +6786,97 @@ msgstr "" #: src\anti_patterns/deref.md:83 #, fuzzy msgid "" -"Most importantly this is a surprising idiom - future programmers reading " -"this in\n" -"code will not expect this to happen. That's because we are misusing the " -"`Deref`\n" -"trait rather than using it as intended (and documented, etc.). It's also " -"because\n" +"Most importantly this is a surprising idiom - future programmers reading this in\n" +"code will not expect this to happen. That's because we are misusing the `Deref`\n" +"trait rather than using it as intended (and documented, etc.). It's also because\n" "the mechanism here is completely implicit." msgstr "" -"Mais importante, este é um idioma surpreendente - futuros programadores " -"lendo isso em\n" -"código não espera que isso aconteça. Isso porque estamos usando mal o " -"`Deref`\n" -"traço em vez de usá-lo como pretendido (e documentado, etc.). é também " -"porque\n" +"Mais importante, este é um idioma surpreendente - futuros programadores lendo isso em\n" +"código não espera que isso aconteça. Isso porque estamos usando mal o `Deref`\n" +"traço em vez de usá-lo como pretendido (e documentado, etc.). é também porque\n" "o mecanismo aqui é completamente implícito." #: src\anti_patterns/deref.md:88 #, fuzzy msgid "" "This pattern does not introduce subtyping between `Foo` and `Bar` like\n" -"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` " -"are\n" -"not automatically implemented for `Bar`, so this pattern interacts badly " -"with\n" +"inheritance in Java or C++ does. Furthermore, traits implemented by `Foo` are\n" +"not automatically implemented for `Bar`, so this pattern interacts badly with\n" "bounds checking and thus generic programming." msgstr "" "Este padrão não introduz subtipagem entre `Foo` e `Bar` como\n" -"herança em Java ou C++ faz. Além disso, as características implementadas por " -"`Foo` são\n" -"não implementado automaticamente para `Bar`, então este padrão interage mal " -"com\n" +"herança em Java ou C++ faz. Além disso, as características implementadas por `Foo` são\n" +"não implementado automaticamente para `Bar`, então este padrão interage mal com\n" "verificação de limites e, portanto, programação genérica." #: src\anti_patterns/deref.md:93 #, fuzzy msgid "" -"Using this pattern gives subtly different semantics from most OO languages " -"with\n" -"regards to `self`. Usually it remains a reference to the sub-class, with " -"this\n" +"Using this pattern gives subtly different semantics from most OO languages with\n" +"regards to `self`. Usually it remains a reference to the sub-class, with this\n" "pattern it will be the 'class' where the method is defined." msgstr "" -"O uso desse padrão fornece uma semântica sutilmente diferente da maioria das " -"linguagens OO com\n" -"diz respeito a 'eu'. Normalmente permanece uma referência à subclasse, com " -"este\n" +"O uso desse padrão fornece uma semântica sutilmente diferente da maioria das linguagens OO com\n" +"diz respeito a 'eu'. Normalmente permanece uma referência à subclasse, com este\n" "pattern será a 'classe' onde o método é definido." #: src\anti_patterns/deref.md:97 #, fuzzy msgid "" -"Finally, this pattern only supports single inheritance, and has no notion " -"of\n" -"interfaces, class-based privacy, or other inheritance-related features. So, " -"it\n" -"gives an experience that will be subtly surprising to programmers used to " -"Java\n" +"Finally, this pattern only supports single inheritance, and has no notion of\n" +"interfaces, class-based privacy, or other inheritance-related features. So, it\n" +"gives an experience that will be subtly surprising to programmers used to Java\n" "inheritance, etc." msgstr "" "Por fim, esse padrão suporta apenas herança única e não tem noção de\n" -"interfaces, privacidade baseada em classe ou outros recursos relacionados à " -"herança. Então, é\n" -"oferece uma experiência que surpreenderá sutilmente os programadores " -"acostumados com Java\n" +"interfaces, privacidade baseada em classe ou outros recursos relacionados à herança. Então, é\n" +"oferece uma experiência que surpreenderá sutilmente os programadores acostumados com Java\n" "herança, etc" #: src\anti_patterns/deref.md:104 #, fuzzy msgid "" -"There is no one good alternative. Depending on the exact circumstances it " -"might\n" -"be better to re-implement using traits or to write out the facade methods " -"to\n" +"There is no one good alternative. Depending on the exact circumstances it might\n" +"be better to re-implement using traits or to write out the facade methods to\n" "dispatch to `Foo` manually. We do intend to add a mechanism for inheritance\n" "similar to this to Rust, but it is likely to be some time before it reaches\n" -"stable Rust. See these " -"[blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"stable Rust. See these [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" "[posts](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" -"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more " -"details." +"and this [RFC issue](https://github.com/rust-lang/rfcs/issues/349) for more details." msgstr "" "Não há uma boa alternativa. Dependendo das circunstâncias exatas, pode\n" -"seria melhor reimplementar usando traits ou escrever os métodos de fachada " -"para\n" -"despachar para `Foo` manualmente. Pretendemos adicionar um mecanismo para " -"herança\n" -"semelhante a isso para Rust, mas é provável que demore algum tempo antes de " -"atingir\n" -"ferrugem estável. Veja estes " -"[blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" +"seria melhor reimplementar usando traits ou escrever os métodos de fachada para\n" +"despachar para `Foo` manualmente. Pretendemos adicionar um mecanismo para herança\n" +"semelhante a isso para Rust, mas é provável que demore algum tempo antes de atingir\n" +"ferrugem estável. Veja estes [blog](http://aturon.github.io/blog/2015/09/18/reuse/)\n" "[postagens](http://smallcultfollowing.com/babysteps/blog/2015/10/08/virtual-structs-part-4-extended-enums-and-thin-traits/)\n" -"e este [problema RFC](https://github.com/rust-lang/rfcs/issues/349) para " -"mais detalhes." +"e este [problema RFC](https://github.com/rust-lang/rfcs/issues/349) para mais detalhes." #: src\anti_patterns/deref.md:112 #, fuzzy msgid "" -"The `Deref` trait is designed for the implementation of custom pointer " -"types.\n" +"The `Deref` trait is designed for the implementation of custom pointer types.\n" "The intention is that it will take a pointer-to-`T` to a `T`, not convert\n" "between different types. It is a shame that this isn't (probably cannot be)\n" "enforced by the trait definition." msgstr "" -"O trait `Deref` é projetado para a implementação de tipos de ponteiro " -"personalizados.\n" +"O trait `Deref` é projetado para a implementação de tipos de ponteiro personalizados.\n" "A intenção é que ele leve um ponteiro para `T` para um `T`, não converta\n" -"entre diferentes tipos. É uma pena que isso não seja (provavelmente não pode " -"ser)\n" +"entre diferentes tipos. É uma pena que isso não seja (provavelmente não pode ser)\n" "imposta pela definição do traço." #: src\anti_patterns/deref.md:117 #, fuzzy msgid "" -"Rust tries to strike a careful balance between explicit and implicit " -"mechanisms,\n" -"favouring explicit conversions between types. Automatic dereferencing in the " -"dot\n" -"operator is a case where the ergonomics strongly favour an implicit " -"mechanism,\n" +"Rust tries to strike a careful balance between explicit and implicit mechanisms,\n" +"favouring explicit conversions between types. Automatic dereferencing in the dot\n" +"operator is a case where the ergonomics strongly favour an implicit mechanism,\n" "but the intention is that this is limited to degrees of indirection, not\n" "conversion between arbitrary types." msgstr "" -"Rust tenta encontrar um equilíbrio cuidadoso entre mecanismos explícitos e " -"implícitos,\n" -"favorecendo conversões explícitas entre tipos. Desreferenciamento automático " -"no ponto\n" -"operador é um caso onde a ergonomia favorece fortemente um mecanismo " -"implícito,\n" +"Rust tenta encontrar um equilíbrio cuidadoso entre mecanismos explícitos e implícitos,\n" +"favorecendo conversões explícitas entre tipos. Desreferenciamento automático no ponto\n" +"operador é um caso onde a ergonomia favorece fortemente um mecanismo implícito,\n" "mas a intenção é que isso seja limitado a graus de indireção, não\n" "conversão entre tipos arbitrários." @@ -8141,18 +6884,14 @@ msgstr "" #, fuzzy msgid "" "- [Collections are smart pointers idiom](../idioms/deref.md).\n" -"- Delegation crates for less boilerplate like " -"[delegate](https://crates.io/crates/delegate)\n" +"- Delegation crates for less boilerplate like [delegate](https://crates.io/crates/delegate)\n" " or [ambassador](https://crates.io/crates/ambassador)\n" -"- [Documentation for `Deref` " -"trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentation for `Deref` trait](https://doc.rust-lang.org/std/ops/trait.Deref.html)." msgstr "" "- [Coleções são idiomas de ponteiros inteligentes](../idioms/deref.md).\n" -"- Caixas de delegação por menos padrão como " -"[delegate](https://crates.io/crates/delegate)\n" +"- Caixas de delegação por menos padrão como [delegate](https://crates.io/crates/delegate)\n" " ou [embaixador](https://crates.io/crates/ambassador)\n" -"- [Documentação para o trait " -"`Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." +"- [Documentação para o trait `Deref`](https://doc.rust-lang.org/std/ops/trait.Deref.html)." #: src\functional/index.md:1 #, fuzzy @@ -8163,29 +6902,23 @@ msgstr "# Uso Funcional de Rust" #, fuzzy msgid "" "Rust is an imperative language, but it follows many\n" -"[functional " -"programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." +"[functional programming](https://en.wikipedia.org/wiki/Functional_programming) paradigms." msgstr "" "A ferrugem é uma linguagem imperativa, mas segue muitas\n" -"[programação " -"funcional](https://en.wikipedia.org/wiki/Functional_programming) paradigmas." +"[programação funcional](https://en.wikipedia.org/wiki/Functional_programming) paradigmas." #: src\functional/index.md:6 #, fuzzy msgid "" -"> In computer science, _functional programming_ is a programming paradigm " -"where\n" +"> In computer science, _functional programming_ is a programming paradigm where\n" "> programs are constructed by applying and composing functions.\n" -"> It is a declarative programming paradigm in which function definitions " -"are\n" +"> It is a declarative programming paradigm in which function definitions are\n" "> trees of expressions that each return a value, rather than a sequence of\n" "> imperative statements which change the state of the program." msgstr "" -"> Em ciência da computação, _programação funcional_ é um paradigma de " -"programação onde\n" +"> Em ciência da computação, _programação funcional_ é um paradigma de programação onde\n" "> os programas são construídos aplicando e compondo funções.\n" -"> É um paradigma de programação declarativa em que as definições de funções " -"são\n" +"> É um paradigma de programação declarativa em que as definições de funções são\n" "> árvores de expressões que retornam um valor, em vez de uma sequência de\n" "> declarações imperativas que mudam o estado do programa." @@ -8202,8 +6935,7 @@ msgid "" "describe **how** to do something, whereas declarative programs describe\n" "**what** to do. Let's sum the numbers from 1 to 10 to show this." msgstr "" -"Um dos maiores obstáculos para a compreensão dos programas funcionais ao " -"chegar\n" +"Um dos maiores obstáculos para a compreensão dos programas funcionais ao chegar\n" "de um fundo imperativo é a mudança no pensamento. programas imperativos\n" "descrevem **como** fazer algo, enquanto os programas declarativos descrevem\n" "**o que fazer. Vamos somar os números de 1 a 10 para mostrar isso." @@ -8227,19 +6959,16 @@ msgstr "" #: src\functional/paradigms.md:18 #, fuzzy msgid "" -"With imperative programs, we have to play compiler to see what is " -"happening.\n" +"With imperative programs, we have to play compiler to see what is happening.\n" "Here, we start with a `sum` of `0`.\n" "Next, we iterate through the range from 1 to 10.\n" "Each time through the loop, we add the corresponding value in the range.\n" "Then we print it out." msgstr "" -"Com programas imperativos, temos que jogar compilador para ver o que está " -"acontecendo.\n" +"Com programas imperativos, temos que jogar compilador para ver o que está acontecendo.\n" "Aqui, começamos com uma `soma` de `0`.\n" "Em seguida, iteramos pelo intervalo de 1 a 10.\n" -"Cada vez que passamos pelo loop, adicionamos o valor correspondente no " -"intervalo.\n" +"Cada vez que passamos pelo loop, adicionamos o valor correspondente no intervalo.\n" "Depois imprimimos." #: src\functional/paradigms.md:24 @@ -8274,12 +7003,10 @@ msgstr "" #: src\functional/paradigms.md:37 #, fuzzy msgid "" -"This is how most of us start out programming. We learn that a program is a " -"set\n" +"This is how most of us start out programming. We learn that a program is a set\n" "of steps." msgstr "" -"É assim que a maioria de nós começa a programar. Aprendemos que um programa " -"é um conjunto\n" +"É assim que a maioria de nós começa a programar. Aprendemos que um programa é um conjunto\n" "de passos." #: src\functional/paradigms.md:40 @@ -8299,15 +7026,12 @@ msgstr "" msgid "" "Whoa! This is really different! What's going on here?\n" "Remember that with declarative programs we are describing **what** to do,\n" -"rather than **how** to do it. `fold` is a function that " -"[composes](https://en.wikipedia.org/wiki/Function_composition)\n" +"rather than **how** to do it. `fold` is a function that [composes](https://en.wikipedia.org/wiki/Function_composition)\n" "functions. The name is a convention from Haskell." msgstr "" "Uau! Isso é realmente diferente! O que está acontecendo aqui?\n" -"Lembre-se que com programas declarativos estamos descrevendo **o que** " -"fazer,\n" -"em vez de **como** fazer. `fold` é uma função que " -"[compõe](https://en.wikipedia.org/wiki/Function_composition)\n" +"Lembre-se que com programas declarativos estamos descrevendo **o que** fazer,\n" +"em vez de **como** fazer. `fold` é uma função que [compõe](https://en.wikipedia.org/wiki/Function_composition)\n" "funções. O nome é uma convenção de Haskell." #: src\functional/paradigms.md:51 @@ -8315,22 +7039,16 @@ msgstr "" msgid "" "Here, we are composing functions of addition (this closure: `|a, b| a + b`)\n" "with a range from 1 to 10. The `0` is the starting point, so `a` is `0` at\n" -"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the " -"result.\n" -"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the " -"next\n" -"result. This process continues until we get to the last element in the " -"range,\n" +"first. `b` is the first element of the range, `1`. `0 + 1 = 1` is the result.\n" +"So now we `fold` again, with `a = 1`, `b = 2` and so `1 + 2 = 3` is the next\n" +"result. This process continues until we get to the last element in the range,\n" "`10`." msgstr "" "Aqui, estamos compondo funções de adição (este fechamento: `|a, b| a + b`)\n" "com um intervalo de 1 a 10. O `0` é o ponto de partida, então `a` é `0` em\n" -"primeiro. `b` é o primeiro elemento do intervalo, `1`. `0 + 1 = 1` é o " -"resultado.\n" -"Então agora nós `fold` novamente, com `a = 1`, `b = 2` e então `1 + 2 = 3` é " -"o próximo\n" -"resultado. Esse processo continua até chegarmos ao último elemento do " -"intervalo,\n" +"primeiro. `b` é o primeiro elemento do intervalo, `1`. `0 + 1 = 1` é o resultado.\n" +"Então agora nós `fold` novamente, com `a = 1`, `b = 2` e então `1 + 2 = 3` é o próximo\n" +"resultado. Esse processo continua até chegarmos ao último elemento do intervalo,\n" "`10`." #: src\functional/paradigms.md:58 @@ -8370,24 +7088,16 @@ msgstr "# Generics as Type Classes" #: src\functional/generics-type-classes.md:5 #, fuzzy msgid "" -"Rust's type system is designed more like functional languages (like " -"Haskell)\n" -"rather than imperative languages (like Java and C++). As a result, Rust can " -"turn\n" -"many kinds of programming problems into \"static typing\" problems. This is " -"one\n" -"of the biggest wins of choosing a functional language, and is critical to " -"many\n" +"Rust's type system is designed more like functional languages (like Haskell)\n" +"rather than imperative languages (like Java and C++). As a result, Rust can turn\n" +"many kinds of programming problems into \"static typing\" problems. This is one\n" +"of the biggest wins of choosing a functional language, and is critical to many\n" "of Rust's compile time guarantees." msgstr "" -"O sistema de tipos do Rust é projetado mais como linguagens funcionais (como " -"Haskell)\n" -"em vez de linguagens imperativas (como Java e C++). Como resultado, Rust " -"pode transformar\n" -"muitos tipos de problemas de programação em problemas de \"digitação " -"estática\". Isso é um\n" -"das maiores vitórias de escolher uma linguagem funcional, e é fundamental " -"para muitos\n" +"O sistema de tipos do Rust é projetado mais como linguagens funcionais (como Haskell)\n" +"em vez de linguagens imperativas (como Java e C++). Como resultado, Rust pode transformar\n" +"muitos tipos de problemas de programação em problemas de \"digitação estática\". Isso é um\n" +"das maiores vitórias de escolher uma linguagem funcional, e é fundamental para muitos\n" "das garantias de tempo de compilação do Rust." #: src\functional/generics-type-classes.md:11 @@ -8395,140 +7105,104 @@ msgstr "" msgid "" "A key part of this idea is the way generic types work. In C++ and Java, for\n" "example, generic types are a meta-programming construct for the compiler.\n" -"`vector` and `vector` in C++ are just two different copies of " -"the\n" +"`vector` and `vector` in C++ are just two different copies of the\n" "same boilerplate code for a `vector` type (known as a `template`) with two\n" "different types filled in." msgstr "" -"Uma parte fundamental dessa ideia é a maneira como os tipos genéricos " -"funcionam. Em C++ e Java, por\n" -"Por exemplo, os tipos genéricos são uma construção de metaprogramação para o " -"compilador.\n" +"Uma parte fundamental dessa ideia é a maneira como os tipos genéricos funcionam. Em C++ e Java, por\n" +"Por exemplo, os tipos genéricos são uma construção de metaprogramação para o compilador.\n" "`vector` e `vector` em C++ são apenas duas cópias diferentes do\n" -"mesmo código clichê para um tipo `vector` (conhecido como `template`) com " -"dois\n" +"mesmo código clichê para um tipo `vector` (conhecido como `template`) com dois\n" "diferentes tipos preenchidos." #: src\functional/generics-type-classes.md:17 #, fuzzy msgid "" -"In Rust, a generic type parameter creates what is known in functional " -"languages\n" -"as a \"type class constraint\", and each different parameter filled in by an " -"end\n" -"user _actually changes the type_. In other words, `Vec` and " -"`Vec`\n" -"_are two different types_, which are recognized as distinct by all parts of " -"the\n" +"In Rust, a generic type parameter creates what is known in functional languages\n" +"as a \"type class constraint\", and each different parameter filled in by an end\n" +"user _actually changes the type_. In other words, `Vec` and `Vec`\n" +"_are two different types_, which are recognized as distinct by all parts of the\n" "type system." msgstr "" -"No Rust, um parâmetro de tipo genérico cria o que é conhecido em linguagens " -"funcionais\n" -"como uma \"restrição de classe de tipo\", e cada parâmetro diferente " -"preenchido por um final\n" -"o usuário _realmente muda o tipo_. Em outras palavras, `Vec` e " -"`Vec`\n" -"_são dois tipos diferentes_, que são reconhecidos como distintos por todas " -"as partes do\n" +"No Rust, um parâmetro de tipo genérico cria o que é conhecido em linguagens funcionais\n" +"como uma \"restrição de classe de tipo\", e cada parâmetro diferente preenchido por um final\n" +"o usuário _realmente muda o tipo_. Em outras palavras, `Vec` e `Vec`\n" +"_são dois tipos diferentes_, que são reconhecidos como distintos por todas as partes do\n" "tipo de sistema." #: src\functional/generics-type-classes.md:23 #, fuzzy msgid "" "This is called **monomorphization**, where different types are created from\n" -"**polymorphic** code. This special behavior requires `impl` blocks to " -"specify\n" -"generic parameters. Different values for the generic type cause different " -"types,\n" +"**polymorphic** code. This special behavior requires `impl` blocks to specify\n" +"generic parameters. Different values for the generic type cause different types,\n" "and different types can have different `impl` blocks." msgstr "" -"Isso é chamado de **monomorfização**, onde diferentes tipos são criados a " -"partir de\n" -"Código **polimórfico**. Este comportamento especial requer blocos `impl` " -"para especificar\n" -"parâmetros genéricos. Valores diferentes para o tipo genérico causam tipos " -"diferentes,\n" +"Isso é chamado de **monomorfização**, onde diferentes tipos são criados a partir de\n" +"Código **polimórfico**. Este comportamento especial requer blocos `impl` para especificar\n" +"parâmetros genéricos. Valores diferentes para o tipo genérico causam tipos diferentes,\n" "e diferentes tipos podem ter diferentes blocos `impl`." #: src\functional/generics-type-classes.md:28 #, fuzzy msgid "" -"In object-oriented languages, classes can inherit behavior from their " -"parents.\n" +"In object-oriented languages, classes can inherit behavior from their parents.\n" "However, this allows the attachment of not only additional behavior to\n" "particular members of a type class, but extra behavior as well." msgstr "" -"Em linguagens orientadas a objetos, as classes podem herdar o comportamento " -"de seus pais.\n" +"Em linguagens orientadas a objetos, as classes podem herdar o comportamento de seus pais.\n" "No entanto, isso permite a anexação não apenas de comportamento adicional a\n" "membros particulares de uma classe de tipo, mas comportamento extra também." #: src\functional/generics-type-classes.md:32 #, fuzzy msgid "" -"The nearest equivalent is the runtime polymorphism in Javascript and " -"Python,\n" +"The nearest equivalent is the runtime polymorphism in Javascript and Python,\n" "where new members can be added to objects willy-nilly by any constructor.\n" -"However, unlike those languages, all of Rust's additional methods can be " -"type\n" -"checked when they are used, because their generics are statically defined. " -"That\n" +"However, unlike those languages, all of Rust's additional methods can be type\n" +"checked when they are used, because their generics are statically defined. That\n" "makes them more usable while remaining safe." msgstr "" -"O equivalente mais próximo é o polimorfismo de tempo de execução em " -"Javascript e Python,\n" +"O equivalente mais próximo é o polimorfismo de tempo de execução em Javascript e Python,\n" "onde novos membros podem ser adicionados a objetos por qualquer construtor.\n" -"No entanto, ao contrário dessas linguagens, todos os métodos adicionais do " -"Rust podem ser digitados\n" -"verificados quando são usados, porque seus genéricos são definidos " -"estaticamente. Que\n" +"No entanto, ao contrário dessas linguagens, todos os métodos adicionais do Rust podem ser digitados\n" +"verificados quando são usados, porque seus genéricos são definidos estaticamente. Que\n" "torna-os mais utilizáveis enquanto permanecem seguros." #: src\functional/generics-type-classes.md:40 #, fuzzy msgid "" "Suppose you are designing a storage server for a series of lab machines.\n" -"Because of the software involved, there are two different protocols you " -"need\n" +"Because of the software involved, there are two different protocols you need\n" "to support: BOOTP (for PXE network boot), and NFS (for remote mount storage)." msgstr "" -"Suponha que você esteja projetando um servidor de armazenamento para uma " -"série de máquinas de laboratório.\n" -"Devido ao software envolvido, existem dois protocolos diferentes que você " -"precisa\n" -"para suportar: BOOTP (para inicialização de rede PXE) e NFS (para " -"armazenamento de montagem remota)." +"Suponha que você esteja projetando um servidor de armazenamento para uma série de máquinas de laboratório.\n" +"Devido ao software envolvido, existem dois protocolos diferentes que você precisa\n" +"para suportar: BOOTP (para inicialização de rede PXE) e NFS (para armazenamento de montagem remota)." #: src\functional/generics-type-classes.md:44 #, fuzzy msgid "" "Your goal is to have one program, written in Rust, which can handle both of\n" -"them. It will have protocol handlers and listen for both kinds of requests. " -"The\n" -"main application logic will then allow a lab administrator to configure " -"storage\n" +"them. It will have protocol handlers and listen for both kinds of requests. The\n" +"main application logic will then allow a lab administrator to configure storage\n" "and security controls for the actual files." msgstr "" "Seu objetivo é ter um programa, escrito em Rust, que possa lidar com ambos\n" -"eles. Ele terá manipuladores de protocolo e escutará ambos os tipos de " -"solicitações. O\n" -"a lógica do aplicativo principal permitirá que um administrador de " -"laboratório configure o armazenamento\n" +"eles. Ele terá manipuladores de protocolo e escutará ambos os tipos de solicitações. O\n" +"a lógica do aplicativo principal permitirá que um administrador de laboratório configure o armazenamento\n" "e controles de segurança para os arquivos reais." #: src\functional/generics-type-classes.md:49 #, fuzzy msgid "" "The requests from machines in the lab for files contain the same basic\n" -"information, no matter what protocol they came from: an authentication " -"method,\n" +"information, no matter what protocol they came from: an authentication method,\n" "and a file name to retrieve. A straightforward implementation would look\n" "something like this:" msgstr "" -"As solicitações de máquinas no laboratório para arquivos contêm o mesmo " -"básico\n" -"informações, independentemente do protocolo de onde vieram: um método de " -"autenticação,\n" +"As solicitações de máquinas no laboratório para arquivos contêm o mesmo básico\n" +"informações, independentemente do protocolo de onde vieram: um método de autenticação,\n" "e um nome de arquivo para recuperar. Uma implementação direta pareceria\n" "algo assim:" @@ -8552,14 +7226,11 @@ msgstr "" msgid "" "This design might work well enough. But now suppose you needed to support\n" "adding metadata that was _protocol specific_. For example, with NFS, you\n" -"wanted to determine what their mount point was in order to enforce " -"additional\n" +"wanted to determine what their mount point was in order to enforce additional\n" "security rules." msgstr "" -"Este design pode funcionar bem o suficiente. Mas agora suponha que você " -"precise apoiar\n" -"adicionando metadados que eram _protocolos específicos_. Por exemplo, com o " -"NFS, você\n" +"Este design pode funcionar bem o suficiente. Mas agora suponha que você precise apoiar\n" +"adicionando metadados que eram _protocolos específicos_. Por exemplo, com o NFS, você\n" "queria determinar qual era o seu ponto de montagem para impor\n" "regras de segurança." @@ -8567,14 +7238,11 @@ msgstr "" #, fuzzy msgid "" "The way the current struct is designed leaves the protocol decision until\n" -"runtime. That means any method that applies to one protocol and not the " -"other\n" +"runtime. That means any method that applies to one protocol and not the other\n" "requires the programmer to do a runtime check." msgstr "" -"A maneira como a estrutura atual é projetada deixa a decisão do protocolo " -"até\n" -"tempo de execução. Isso significa qualquer método que se aplique a um " -"protocolo e não ao outro\n" +"A maneira como a estrutura atual é projetada deixa a decisão do protocolo até\n" +"tempo de execução. Isso significa qualquer método que se aplique a um protocolo e não ao outro\n" "requer que o programador faça uma verificação de tempo de execução." #: src\functional/generics-type-classes.md:75 @@ -8606,16 +7274,12 @@ msgstr "" #: src\functional/generics-type-classes.md:95 #, fuzzy msgid "" -"Every caller of `mount_point()` must check for `None` and write code to " -"handle\n" -"it. This is true even if they know only NFS requests are ever used in a " -"given\n" +"Every caller of `mount_point()` must check for `None` and write code to handle\n" +"it. This is true even if they know only NFS requests are ever used in a given\n" "code path!" msgstr "" -"Todo chamador de `mount_point()` deve verificar `None` e escrever o código " -"para manipular\n" -"isto. Isso é verdade mesmo que eles saibam que apenas solicitações NFS são " -"usadas em um determinado\n" +"Todo chamador de `mount_point()` deve verificar `None` e escrever o código para manipular\n" +"isto. Isso é verdade mesmo que eles saibam que apenas solicitações NFS são usadas em um determinado\n" "caminho do código!" #: src\functional/generics-type-classes.md:99 @@ -8623,26 +7287,21 @@ msgstr "" msgid "" "It would be far more optimal to cause a compile-time error if the different\n" "request types were confused. After all, the entire path of the user's code,\n" -"including what functions from the library they use, will know whether a " -"request\n" +"including what functions from the library they use, will know whether a request\n" "is an NFS request or a BOOTP request." msgstr "" -"Seria muito mais ideal causar um erro de tempo de compilação se os " -"diferentes\n" -"os tipos de solicitação eram confusos. Afinal, todo o caminho do código do " -"usuário,\n" +"Seria muito mais ideal causar um erro de tempo de compilação se os diferentes\n" +"os tipos de solicitação eram confusos. Afinal, todo o caminho do código do usuário,\n" "incluindo quais funções da biblioteca eles usam, saberão se uma solicitação\n" "é uma solicitação NFS ou uma solicitação BOOTP." #: src\functional/generics-type-classes.md:104 #, fuzzy msgid "" -"In Rust, this is actually possible! The solution is to _add a generic type_ " -"in\n" +"In Rust, this is actually possible! The solution is to _add a generic type_ in\n" "order to split the API." msgstr "" -"No Rust, isso é realmente possível! A solução é _adicionar um tipo genérico_ " -"em\n" +"No Rust, isso é realmente possível! A solução é _adicionar um tipo genérico_ em\n" "para dividir a API." #: src\functional/generics-type-classes.md:107 @@ -8759,63 +7418,47 @@ msgstr "" #: src\functional/generics-type-classes.md:206 #, fuzzy msgid "" -"They would get a syntax error. The type `FileDownloadRequest` does " -"not\n" -"implement `mount_point()`, only the type `FileDownloadRequest` does. " -"And\n" +"They would get a syntax error. The type `FileDownloadRequest` does not\n" +"implement `mount_point()`, only the type `FileDownloadRequest` does. And\n" "that is created by the NFS module, not the BOOTP module of course!" msgstr "" "Eles receberiam um erro de sintaxe. O tipo `FileDownloadRequest` não\n" -"implementar `mount_point()`, apenas o tipo `FileDownloadRequest` o faz. " -"E\n" +"implementar `mount_point()`, apenas o tipo `FileDownloadRequest` o faz. E\n" "que é criado pelo módulo NFS, não pelo módulo BOOTP, é claro!" #: src\functional/generics-type-classes.md:212 #, fuzzy msgid "" -"First, it allows fields that are common to multiple states to be " -"de-duplicated.\n" +"First, it allows fields that are common to multiple states to be de-duplicated.\n" "By making the non-shared fields generic, they are implemented once." msgstr "" -"Primeiro, permite que os campos comuns a vários estados sejam " -"desduplicados.\n" -"Ao tornar os campos não compartilhados genéricos, eles são implementados uma " -"vez." +"Primeiro, permite que os campos comuns a vários estados sejam desduplicados.\n" +"Ao tornar os campos não compartilhados genéricos, eles são implementados uma vez." #: src\functional/generics-type-classes.md:215 #, fuzzy msgid "" -"Second, it makes the `impl` blocks easier to read, because they are broken " -"down\n" -"by state. Methods common to all states are typed once in one block, and " -"methods\n" +"Second, it makes the `impl` blocks easier to read, because they are broken down\n" +"by state. Methods common to all states are typed once in one block, and methods\n" "unique to one state are in a separate block." msgstr "" -"Em segundo lugar, torna os blocos `impl` mais fáceis de ler, porque eles são " -"divididos\n" -"por estado. Os métodos comuns a todos os estados são digitados uma vez em um " -"bloco e os métodos\n" +"Em segundo lugar, torna os blocos `impl` mais fáceis de ler, porque eles são divididos\n" +"por estado. Os métodos comuns a todos os estados são digitados uma vez em um bloco e os métodos\n" "exclusivos para um estado estão em um bloco separado." #: src\functional/generics-type-classes.md:219 #, fuzzy -msgid "" -"Both of these mean there are fewer lines of code, and they are better " -"organized." -msgstr "" -"Ambos significam que há menos linhas de código e são mais bem organizados." +msgid "Both of these mean there are fewer lines of code, and they are better organized." +msgstr "Ambos significam que há menos linhas de código e são mais bem organizados." #: src\functional/generics-type-classes.md:223 #, fuzzy msgid "" -"This currently increases the size of the binary, due to the way " -"monomorphization\n" -"is implemented in the compiler. Hopefully the implementation will be able " -"to\n" +"This currently increases the size of the binary, due to the way monomorphization\n" +"is implemented in the compiler. Hopefully the implementation will be able to\n" "improve in the future." msgstr "" -"Isso atualmente aumenta o tamanho do binário, devido à forma como a " -"monomorfização\n" +"Isso atualmente aumenta o tamanho do binário, devido à forma como a monomorfização\n" "é implementado no compilador. Esperamos que a implementação seja capaz de\n" "melhorar no futuro." @@ -8826,20 +7469,16 @@ msgid "" " initialization, consider the\n" " [Builder Pattern](../patterns/creational/builder.md) instead.\n" "\n" -"- If the API between types does not change -- only the behavior does -- " -"then\n" -" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better " -"used\n" +"- If the API between types does not change -- only the behavior does -- then\n" +" the [Strategy Pattern](../patterns/behavioural/strategy.md) is better used\n" " instead." msgstr "" -"- Se um tipo parecer precisar de uma \"API dividida\" devido à construção " -"ou\n" +"- Se um tipo parecer precisar de uma \"API dividida\" devido à construção ou\n" " inicialização, considere o\n" " [Padrão do construtor](../patterns/creational/builder.md) em vez disso.\n" "\n" "- Se a API entre os tipos não mudar -- apenas o comportamento muda -- então\n" -" o [Padrão de Estratégia](../patterns/behavioural/strategy.md) é melhor " -"usado\n" +" o [Padrão de Estratégia](../patterns/behavioural/strategy.md) é melhor usado\n" " em vez de." #: src\functional/generics-type-classes.md:239 @@ -8850,107 +7489,79 @@ msgstr "Este padrão é usado em toda a biblioteca padrão:" #: src\functional/generics-type-classes.md:241 #, fuzzy msgid "" -"- `Vec` can be cast from a String, unlike every other type of " -"`Vec`.[^1]\n" +"- `Vec` can be cast from a String, unlike every other type of `Vec`.[^1]\n" "- They can also be cast into a binary heap, but only if they contain a type\n" " that implements the `Ord` trait.[^2]\n" "- The `to_string` method was specialized for `Cow` only of type `str`.[^3]" msgstr "" -"- `Vec` pode ser lançado a partir de uma String, ao contrário de " -"qualquer outro tipo de `Vec`.[^1]\n" -"- Eles também podem ser lançados em um heap binário, mas apenas se " -"contiverem um tipo\n" +"- `Vec` pode ser lançado a partir de uma String, ao contrário de qualquer outro tipo de `Vec`.[^1]\n" +"- Eles também podem ser lançados em um heap binário, mas apenas se contiverem um tipo\n" " que implementa o traço `Ord`.[^2]\n" "- O método `to_string` foi especializado para `Cow` apenas do tipo `str`.[^3]" #: src\functional/generics-type-classes.md:246 #, fuzzy msgid "It is also used by several popular crates to allow API flexibility:" -msgstr "" -"Ele também é usado por várias caixas populares para permitir a flexibilidade " -"da API:" +msgstr "Ele também é usado por várias caixas populares para permitir a flexibilidade da API:" #: src\functional/generics-type-classes.md:248 #, fuzzy msgid "" -"- The `embedded-hal` ecosystem used for embedded devices makes extensive use " -"of\n" -" this pattern. For example, it allows statically verifying the " -"configuration of\n" -" device registers used to control embedded pins. When a pin is put into a " -"mode,\n" +"- The `embedded-hal` ecosystem used for embedded devices makes extensive use of\n" +" this pattern. For example, it allows statically verifying the configuration of\n" +" device registers used to control embedded pins. When a pin is put into a mode,\n" " it returns a `Pin` struct, whose generic determines the functions\n" " usable in that mode, which are not on the `Pin` itself. [^4]\n" "\n" -"- The `hyper` HTTP client library uses this to expose rich APIs for " -"different\n" -" pluggable requests. Clients with different connectors have different " -"methods\n" +"- The `hyper` HTTP client library uses this to expose rich APIs for different\n" +" pluggable requests. Clients with different connectors have different methods\n" " on them as well as different trait implementations, while a core set of\n" " methods apply to any connector. [^5]\n" "\n" -"- The \"type state\" pattern -- where an object gains and loses API based on " -"an\n" -" internal state or invariant -- is implemented in Rust using the same " -"basic\n" +"- The \"type state\" pattern -- where an object gains and loses API based on an\n" +" internal state or invariant -- is implemented in Rust using the same basic\n" " concept, and a slightly different technique. [^6]" msgstr "" -"- O ecossistema `embedded-hal` usado para dispositivos embarcados faz uso " -"extensivo de\n" -" esse padrão. Por exemplo, permite verificar estaticamente a configuração " -"de\n" -" registradores de dispositivos usados para controlar pinos embutidos. " -"Quando um pino é colocado em um modo,\n" +"- O ecossistema `embedded-hal` usado para dispositivos embarcados faz uso extensivo de\n" +" esse padrão. Por exemplo, permite verificar estaticamente a configuração de\n" +" registradores de dispositivos usados para controlar pinos embutidos. Quando um pino é colocado em um modo,\n" " ele retorna uma estrutura `Pin`, cujo genérico determina as funções\n" " utilizáveis nesse modo, que não estão no próprio `Pin`. [^4]\n" "\n" -"- A biblioteca de cliente `hiper` HTTP usa isso para expor APIs ricas para " -"diferentes\n" -" solicitações conectáveis. Clientes com conectores diferentes têm métodos " -"diferentes\n" -" sobre eles, bem como implementações de características diferentes, " -"enquanto um conjunto básico de\n" +"- A biblioteca de cliente `hiper` HTTP usa isso para expor APIs ricas para diferentes\n" +" solicitações conectáveis. Clientes com conectores diferentes têm métodos diferentes\n" +" sobre eles, bem como implementações de características diferentes, enquanto um conjunto básico de\n" " Os métodos se aplicam a qualquer conector. [^5]\n" "\n" -"- O padrão \"tipo de estado\" -- onde um objeto ganha e perde API com base " -"em um\n" +"- O padrão \"tipo de estado\" -- onde um objeto ganha e perde API com base em um\n" " estado interno ou invariante -- é implementado em Rust usando o mesmo\n" " conceito e uma técnica ligeiramente diferente. [^6]" #: src\functional/generics-type-classes.md:263 #, fuzzy -msgid "" -"See: [impl From\\ for " -"Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" -msgstr "" -"Veja: [impl From\\ for " -"Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 " -")" +msgid "See: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811)" +msgstr "Veja: [impl From\\ for Vec\\](https://doc.rust-lang.org/1.59.0/src/std/ffi/c_str.rs.html#803-811 )" #: src\functional/generics-type-classes.md:265 #, fuzzy msgid "" -"See: [impl\\ From\\\\> for " -"BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/binary_heap.rs.html#1345-1354)" +"See: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections/" +"binary_heap.rs.html#1345-1354)" msgstr "" -"Veja: [impl\\ From\\\\> for " -"BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections " -"/binary_heap.rs.html#1345-1354)" +"Veja: [impl\\ From\\\\> for BinaryHeap\\](https://doc.rust-lang.org/stable/src/alloc/collections /" +"binary_heap.rs.html#1345-1354)" #: src\functional/generics-type-classes.md:267 #, fuzzy -msgid "" -"See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, " -"str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" -msgstr "" -"Veja: [impl\\<'\\_\\> ToString for Cow\\<'\\_, " -"str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" +msgid "See: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235-2240)" +msgstr "Veja: [impl\\<'\\_\\> ToString for Cow\\<'\\_, str>](https://doc.rust-lang.org/stable/src/alloc/string.rs.html#2235- 2240)" #: src\functional/generics-type-classes.md:269 #, fuzzy msgid "" "Example:\n" -"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html)" +"[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/" +"gpioa/struct.PA0.html)" msgstr "" "Exemplo:\n" "[https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/gpioa/struct.PA0.html](https://docs.rs/stm32f30x-hal/0.1.0/stm32f30x_hal/gpio/ " @@ -8969,20 +7580,18 @@ msgstr "" #, fuzzy msgid "" "See:\n" -"[The Case for the Type State " -"Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate-pattern-the-typestate-pattern-itself/)\n" +"[The Case for the Type State Pattern](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-" +"typestate-pattern-the-typestate-pattern-itself/)\n" "and\n" -"[Rusty Typestate Series (an extensive " -"thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-typestate-series/rust-typestate-index)" +"[Rusty Typestate Series (an extensive thesis)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index)" msgstr "" "Ver:\n" -"[O caso para o padrão de estado de " -"tipo](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-the-typestate- " -"padrão-o-tipo-estado-padrão-em-si/)\n" +"[O caso para o padrão de estado de tipo](https://web.archive.org/web/20210325065112/https://www.novatec-gmbh.de/en/blog/the-case-for-" +"the-typestate- padrão-o-tipo-estado-padrão-em-si/)\n" "e\n" -"[Série Rusty Typestate (uma tese " -"extensa)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-typestate-series/rust-typestate-index " -")" +"[Série Rusty Typestate (uma tese extensa)](https://web.archive.org/web/20210328164854/https://rustype.github.io/notes/notes/rust-" +"typestate-series/rust-typestate-index )" #: src\functional/lenses.md:1 #, fuzzy @@ -8994,8 +7603,7 @@ msgstr "# Lentes e Prismas" msgid "" "This is a pure functional concept that is not frequently used in Rust.\n" "Nevertheless, exploring the concept may be helpful to understand other\n" -"patterns in Rust APIs, such as " -"[visitors](../patterns/behavioural/visitor.md).\n" +"patterns in Rust APIs, such as [visitors](../patterns/behavioural/visitor.md).\n" "They also have niche use cases." msgstr "" "Este é um conceito funcional puro que não é usado com frequência no Rust.\n" @@ -9013,14 +7621,12 @@ msgstr "## Lentes: Acesso uniforme entre os tipos" msgid "" "A lens is a concept from functional programming languages that allows\n" "accessing parts of a data type in an abstract, unified way.[^1]\n" -"In basic concept, it is similar to the way Rust traits work with type " -"erasure,\n" +"In basic concept, it is similar to the way Rust traits work with type erasure,\n" "but it has a bit more power and flexibility." msgstr "" "Uma lente é um conceito de linguagens de programação funcional que permite\n" "acessando partes de um tipo de dados de forma abstrata e unificada.[^1]\n" -"No conceito básico, é semelhante à maneira como as características do Rust " -"funcionam com o apagamento de tipo,\n" +"No conceito básico, é semelhante à maneira como as características do Rust funcionam com o apagamento de tipo,\n" "mas tem um pouco mais de potência e flexibilidade." #: src\functional/lenses.md:15 @@ -9031,13 +7637,10 @@ msgid "" "This is because they come from different databases or legacy systems.\n" "One database contains the data needed to perform credit checks:" msgstr "" -"Por exemplo, suponha que um banco contenha vários formatos JSON para " -"clientes\n" +"Por exemplo, suponha que um banco contenha vários formatos JSON para clientes\n" "dados.\n" -"Isso ocorre porque eles vêm de diferentes bancos de dados ou sistemas " -"legados.\n" -"Um banco de dados contém os dados necessários para realizar verificações de " -"crédito:" +"Isso ocorre porque eles vêm de diferentes bancos de dados ou sistemas legados.\n" +"Um banco de dados contém os dados necessários para realizar verificações de crédito:" #: src\functional/lenses.md:20 msgid "" @@ -9078,23 +7681,19 @@ msgstr "" #: src\functional/lenses.md:47 #, fuzzy msgid "" -"Notice that both types have a customer ID number which corresponds to a " -"person.\n" +"Notice that both types have a customer ID number which corresponds to a person.\n" "How would a single function handle both records of different types?" msgstr "" -"Observe que ambos os tipos têm um número de identificação do cliente que " -"corresponde a uma pessoa.\n" +"Observe que ambos os tipos têm um número de identificação do cliente que corresponde a uma pessoa.\n" "Como uma única função lidaria com ambos os registros de tipos diferentes?" #: src\functional/lenses.md:50 #, fuzzy msgid "" -"In Rust, a `struct` could represent each of these types, and a trait would " -"have\n" +"In Rust, a `struct` could represent each of these types, and a trait would have\n" "a `get_customer_id` function they would implement:" msgstr "" -"Em Rust, uma `struct` poderia representar cada um desses tipos, e um trait " -"teria\n" +"Em Rust, uma `struct` poderia representar cada um desses tipos, e um trait teria\n" "uma função `get_customer_id` que eles implementariam:" #: src\functional/lenses.md:53 @@ -9141,8 +7740,7 @@ msgid "" " records.iter().map(|r| r.get_customer_id()).collect()\n" "}\n" "\n" -"// dynamic dispatch: iterates over any type with a customer ID, collecting " -"all\n" +"// dynamic dispatch: iterates over any type with a customer ID, collecting all\n" "// values together\n" "fn unique_ids_iter(iterator: I) -> HashSet\n" " where I: Iterator>\n" @@ -9160,26 +7758,20 @@ msgid "" "Rather than implementing a trait on each type, all matching structures can\n" "simply be accessed the same way." msgstr "" -"As lentes, no entanto, permitem que o código que suporta a ID do cliente " -"seja movido do\n" +"As lentes, no entanto, permitem que o código que suporta a ID do cliente seja movido do\n" "_type_ para a função _accessor_.\n" -"Em vez de implementar uma característica em cada tipo, todas as estruturas " -"correspondentes podem\n" +"Em vez de implementar uma característica em cada tipo, todas as estruturas correspondentes podem\n" "simplesmente ser acessado da mesma maneira." #: src\functional/lenses.md:109 #, fuzzy msgid "" "While the Rust language itself does not support this (type erasure is the\n" -"preferred solution to this problem), the [lens-rs " -"crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows " -"code\n" +"preferred solution to this problem), the [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) allows code\n" "that feels like this to be written with macros:" msgstr "" "Embora a própria linguagem Rust não suporte isso (o apagamento de tipo é o\n" -"solução preferida para este problema), o [lens-rs " -"crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) permite o " -"código\n" +"solução preferida para este problema), o [lens-rs crate](https://github.com/TOETOE55/lens-rs/blob/master/guide.md) permite o código\n" "que se sente assim para ser escrito com macros:" #: src\functional/lenses.md:113 @@ -9224,42 +7816,32 @@ msgstr "" #: src\functional/lenses.md:149 #, fuzzy msgid "" -"The version of `unique_ids_lens` shown here allows any type to be in the " -"iterator,\n" -"so long as it has an attribute called `customer_id` which can be accessed " -"by\n" +"The version of `unique_ids_lens` shown here allows any type to be in the iterator,\n" +"so long as it has an attribute called `customer_id` which can be accessed by\n" "the function.\n" "This is how most functional programming languages operate on lenses." msgstr "" -"A versão de `unique_ids_lens` mostrada aqui permite que qualquer tipo esteja " -"no iterador,\n" +"A versão de `unique_ids_lens` mostrada aqui permite que qualquer tipo esteja no iterador,\n" "desde que tenha um atributo chamado `customer_id` que pode ser acessado por\n" "a função.\n" -"É assim que a maioria das linguagens de programação funcionais operam nas " -"lentes." +"É assim que a maioria das linguagens de programação funcionais operam nas lentes." #: src\functional/lenses.md:154 #, fuzzy msgid "" -"Rather than macros, they achieve this with a technique known as " -"\"currying\".\n" +"Rather than macros, they achieve this with a technique known as \"currying\".\n" "That is, they \"partially construct\" the function, leaving the type of the\n" -"final parameter (the value being operated on) unfilled until the function " -"is\n" +"final parameter (the value being operated on) unfilled until the function is\n" "called.\n" -"Thus it can be called with different types dynamically even from one place " -"in\n" +"Thus it can be called with different types dynamically even from one place in\n" "the code.\n" "That is what the `optics!` and `view_ref` in the example above simulates." msgstr "" -"Em vez de macros, eles conseguem isso com uma técnica conhecida como " -"\"currying\".\n" +"Em vez de macros, eles conseguem isso com uma técnica conhecida como \"currying\".\n" "Ou seja, eles \"constroem parcialmente\" a função, deixando o tipo do\n" -"parâmetro final (o valor que está sendo operado) não preenchido até que a " -"função seja\n" +"parâmetro final (o valor que está sendo operado) não preenchido até que a função seja\n" "chamado.\n" -"Assim, pode ser chamado com diferentes tipos dinamicamente, mesmo de um " -"lugar em\n" +"Assim, pode ser chamado com diferentes tipos dinamicamente, mesmo de um lugar em\n" "o código.\n" "Isso é o que `optics!` e `view_ref` no exemplo acima simulam." @@ -9269,17 +7851,14 @@ msgid "" "The functional approach need not be restricted to accessing members.\n" "More powerful lenses can be created which both _set_ and _get_ data in a\n" "structure.\n" -"But the concept really becomes interesting when used as a building block " -"for\n" +"But the concept really becomes interesting when used as a building block for\n" "composition.\n" "That is where the concept appears more clearly in Rust." msgstr "" "A abordagem funcional não precisa ser restrita aos membros de acesso.\n" -"Podem ser criadas lentes mais poderosas que _configuram_ e _obtêm_ dados em " -"um\n" +"Podem ser criadas lentes mais poderosas que _configuram_ e _obtêm_ dados em um\n" "estrutura.\n" -"Mas o conceito realmente se torna interessante quando usado como bloco de " -"construção para\n" +"Mas o conceito realmente se torna interessante quando usado como bloco de construção para\n" "composição.\n" "É aí que o conceito aparece com mais clareza em Rust." @@ -9291,13 +7870,11 @@ msgstr "## Prismas: Uma forma de ordem superior de \"Óptica\"" #: src\functional/lenses.md:171 #, fuzzy msgid "" -"A simple function such as `unique_ids_lens` above operates on a single " -"lens.\n" +"A simple function such as `unique_ids_lens` above operates on a single lens.\n" "A _prism_ is a function that operates on a _family_ of lenses.\n" "It is one conceptual level higher, using lenses as a building block, and\n" "continuing the metaphor, is part of a family of \"optics\".\n" -"It is the main one that is useful in understanding Rust APIs, so will be " -"the\n" +"It is the main one that is useful in understanding Rust APIs, so will be the\n" "focus here." msgstr "" "Uma função simples como `unique_ids_lens` acima opera em uma única lente.\n" @@ -9310,17 +7887,13 @@ msgstr "" #: src\functional/lenses.md:178 #, fuzzy msgid "" -"The same way that traits allow \"lens-like\" design with static polymorphism " -"and\n" -"dynamic dispatch, prism-like designs appear in Rust APIs which split " -"problems\n" +"The same way that traits allow \"lens-like\" design with static polymorphism and\n" +"dynamic dispatch, prism-like designs appear in Rust APIs which split problems\n" "into multiple associated types to be composed.\n" "A good example of this is the traits in the parsing crate _Serde_." msgstr "" -"Da mesma forma que as características permitem um design \"semelhante a uma " -"lente\" com polimorfismo estático e\n" -"despacho dinâmico, designs semelhantes a prismas aparecem em APIs Rust que " -"dividem problemas\n" +"Da mesma forma que as características permitem um design \"semelhante a uma lente\" com polimorfismo estático e\n" +"despacho dinâmico, designs semelhantes a prismas aparecem em APIs Rust que dividem problemas\n" "em vários tipos associados a serem compostos.\n" "Um bom exemplo disso são as características na caixa de análise _Serde_." @@ -9334,8 +7907,7 @@ msgid "" msgstr "" "Tentar entender como o _Serde_ funciona apenas lendo a API é uma\n" "desafio, especialmente na primeira vez.\n" -"Considere o trait `Deserializer`, implementado por algum tipo em qualquer " -"biblioteca\n" +"Considere o trait `Deserializer`, implementado por algum tipo em qualquer biblioteca\n" "que analisa um novo formato:" #: src\functional/lenses.md:188 @@ -9344,13 +7916,11 @@ msgid "" "pub trait Deserializer<'de>: Sized {\n" " type Error: Error;\n" "\n" -" fn deserialize_any(self, visitor: V) -> Result\n" +" fn deserialize_any(self, visitor: V) -> Result\n" " where\n" " V: Visitor<'de>;\n" "\n" -" fn deserialize_bool(self, visitor: V) -> Result\n" +" fn deserialize_bool(self, visitor: V) -> Result\n" " where\n" " V: Visitor<'de>;\n" "\n" @@ -9365,8 +7935,7 @@ msgid "" "For a trait that is just supposed to parse data from a format and return a\n" "value, this looks odd." msgstr "" -"Para uma característica que deve apenas analisar dados de um formato e " -"retornar um\n" +"Para uma característica que deve apenas analisar dados de um formato e retornar um\n" "valor, isso parece estranho." #: src\functional/lenses.md:207 @@ -9380,8 +7949,7 @@ msgid "" "To understand that, we need to keep the lens concept in mind and look at\n" "the definition of the `Visitor` type that is passed in generically:" msgstr "" -"Para entender isso, precisamos manter o conceito de lente em mente e olhar " -"para\n" +"Para entender isso, precisamos manter o conceito de lente em mente e olhar para\n" "a definição do tipo `Visitor` que é passado genericamente:" #: src\functional/lenses.md:212 @@ -9410,12 +7978,10 @@ msgstr "" #: src\functional/lenses.md:232 #, fuzzy msgid "" -"The job of the `Visitor` type is to construct values in the _Serde_ data " -"model,\n" +"The job of the `Visitor` type is to construct values in the _Serde_ data model,\n" "which are represented by its associated `Value` type." msgstr "" -"O trabalho do tipo `Visitor` é construir valores no modelo de dados " -"_Serde_,\n" +"O trabalho do tipo `Visitor` é construir valores no modelo de dados _Serde_,\n" "que são representados por seu tipo `Value` associado." #: src\functional/lenses.md:235 @@ -9432,30 +7998,23 @@ msgstr "" #: src\functional/lenses.md:239 #, fuzzy msgid "" -"This highlights that `Deserializer` is similar to `CustomerId` from " -"earlier,\n" -"allowing any format parser which implements it to create `Value`s based on " -"what\n" +"This highlights that `Deserializer` is similar to `CustomerId` from earlier,\n" +"allowing any format parser which implements it to create `Value`s based on what\n" "it parsed.\n" "The `Value` trait is acting like a lens in functional programming languages." msgstr "" "Isso destaca que `Deserializer` é semelhante a `CustomerId` de antes,\n" -"permitindo que qualquer analisador de formato que o implemente crie " -"`Valores`s com base no que\n" +"permitindo que qualquer analisador de formato que o implemente crie `Valores`s com base no que\n" "ele analisou.\n" -"O traço `Valor` está agindo como uma lente em linguagens de programação " -"funcional." +"O traço `Valor` está agindo como uma lente em linguagens de programação funcional." #: src\functional/lenses.md:244 #, fuzzy msgid "" -"But unlike the `CustomerId` trait, the return types of `Visitor` methods " -"are\n" -"_generic_, and the concrete `Value` type is _determined by the Visitor " -"itself_." +"But unlike the `CustomerId` trait, the return types of `Visitor` methods are\n" +"_generic_, and the concrete `Value` type is _determined by the Visitor itself_." msgstr "" -"Mas ao contrário do trait `CustomerId`, os tipos de retorno dos métodos " -"`Visitor` são\n" +"Mas ao contrário do trait `CustomerId`, os tipos de retorno dos métodos `Visitor` são\n" "_genérico_, e o tipo `Valor` concreto é _determinado pelo próprio Visitante_." #: src\functional/lenses.md:247 @@ -9470,21 +8029,18 @@ msgstr "" #: src\functional/lenses.md:250 #, fuzzy msgid "" -"The `Deserializer` API is based on having a generic set of \"lenses\" work " -"across\n" +"The `Deserializer` API is based on having a generic set of \"lenses\" work across\n" "a set of other generic types for \"observation\".\n" "It is a _prism_." msgstr "" -"A API `Deserializer` é baseada em ter um conjunto genérico de \"lentes\" " -"trabalhando\n" +"A API `Deserializer` é baseada em ter um conjunto genérico de \"lentes\" trabalhando\n" "um conjunto de outros tipos genéricos para \"observação\".\n" "É um _prisma_." #: src\functional/lenses.md:254 #, fuzzy msgid "For example, consider the identity record from earlier but simplified:" -msgstr "" -"Por exemplo, considere o registro de identidade anterior, mas simplificado:" +msgstr "Por exemplo, considere o registro de identidade anterior, mas simplificado:" #: src\functional/lenses.md:256 msgid "" @@ -9497,36 +8053,28 @@ msgstr "" #: src\functional/lenses.md:262 #, fuzzy -msgid "" -"How would the _Serde_ library deserialize this JSON into `struct " -"CreditRecord`?" -msgstr "" -"Como a biblioteca _Serde_ desserializaria este JSON em `struct CreditRecord`?" +msgid "How would the _Serde_ library deserialize this JSON into `struct CreditRecord`?" +msgstr "Como a biblioteca _Serde_ desserializaria este JSON em `struct CreditRecord`?" #: src\functional/lenses.md:264 #, fuzzy msgid "" -"1. The user would call a library function to deserialize the data. This " -"would\n" +"1. The user would call a library function to deserialize the data. This would\n" " create a `Deserializer` based on the JSON format.\n" "1. Based on the fields in the struct, a `Visitor` would be created (more on\n" " that in a moment) which knows how to create each type in a generic data\n" " model that was needed to represent it: `u64` and `String`.\n" "1. The deserializer would make calls to the `Visitor` as it parsed items.\n" -"1. The `Visitor` would indicate if the items found were expected, and if " -"not,\n" +"1. The `Visitor` would indicate if the items found were expected, and if not,\n" " raise an error to indicate deserialization has failed." msgstr "" -"1. O usuário chamaria uma função de biblioteca para desserializar os dados. " -"Isso seria\n" +"1. O usuário chamaria uma função de biblioteca para desserializar os dados. Isso seria\n" " crie um `Deserializer` baseado no formato JSON.\n" "1. Com base nos campos da estrutura, um `Visitor` seria criado (mais sobre\n" " isso daqui a pouco) que sabe como criar cada tipo em um data genérico\n" " modelo necessário para representá-lo: `u64` e `String`.\n" -"1. O desserializador faria chamadas para o `Visitor` enquanto analisava os " -"itens.\n" -"1. O 'Visitante' indicaria se os itens encontrados eram esperados e, se " -"não,\n" +"1. O desserializador faria chamadas para o `Visitor` enquanto analisava os itens.\n" +"1. O 'Visitante' indicaria se os itens encontrados eram esperados e, se não,\n" " gera um erro para indicar que a desserialização falhou." #: src\functional/lenses.md:273 @@ -9544,8 +8092,7 @@ msgid "" "1. Visit a string value, which will go into the `customer_id` field.\n" "1. Visit the end of the map." msgstr "" -"1. Visite um mapa (equivalente de _Serde_ a `HashMap` ou dicionário de " -"JSON).\n" +"1. Visite um mapa (equivalente de _Serde_ a `HashMap` ou dicionário de JSON).\n" "1. Visite uma chave de string chamada \"nome\".\n" "1. Visite um valor de string, que irá para o campo `name`.\n" "1. Visite uma chave de string chamada \"customer_id\".\n" @@ -9565,8 +8112,7 @@ msgid "" "Rust does not support that, so every single type would need to have its own\n" "code written based on its fields and their properties." msgstr "" -"Uma linguagem de programação funcional seria capaz de usar currying para " -"criar\n" +"Uma linguagem de programação funcional seria capaz de usar currying para criar\n" "reflexão de cada tipo com base no próprio tipo.\n" "Rust não suporta isso, então cada tipo precisaria ter seu próprio\n" "código escrito com base em seus campos e suas propriedades." @@ -9595,8 +8141,7 @@ msgid "" "That macro simply generates an impl block causing the struct to implement a\n" "trait called `Deserialize`." msgstr "" -"Essa macro simplesmente gera um bloco impl fazendo com que o struct " -"implemente um\n" +"Essa macro simplesmente gera um bloco impl fazendo com que o struct implemente um\n" "traço chamado `Deserialize`." #: src\functional/lenses.md:304 @@ -9620,23 +8165,20 @@ msgstr "" msgid "" "This is the function that determines how to create the struct itself.\n" "Code is generated based on the struct's fields.\n" -"When the parsing library is called - in our example, a JSON parsing library " -"-\n" +"When the parsing library is called - in our example, a JSON parsing library -\n" "it creates a `Deserializer` and calls `Type::deserialize` with it as a\n" "parameter." msgstr "" "Esta é a função que determina como criar a própria estrutura.\n" "O código é gerado com base nos campos da estrutura.\n" -"Quando a biblioteca de análise é chamada - em nosso exemplo, uma biblioteca " -"de análise JSON -\n" +"Quando a biblioteca de análise é chamada - em nosso exemplo, uma biblioteca de análise JSON -\n" "ele cria um `Deserializer` e chama `Type::deserialize` com ele como um\n" "parâmetro." #: src\functional/lenses.md:320 #, fuzzy msgid "" -"The `deserialize` code will then create a `Visitor` which will have its " -"calls\n" +"The `deserialize` code will then create a `Visitor` which will have its calls\n" "\"refracted\" by the `Deserializer`.\n" "If everything goes well, eventually that `Visitor` will construct a value\n" "corresponding to the type being parsed and return it." @@ -9648,12 +8190,8 @@ msgstr "" #: src\functional/lenses.md:325 #, fuzzy -msgid "" -"For a complete example, see the [_Serde_ " -"documentation](https://serde.rs/deserialize-struct.html)." -msgstr "" -"Para obter um exemplo completo, consulte a [documentação do " -"_Serde_](https://serde.rs/deserialize-struct.html)." +msgid "For a complete example, see the [_Serde_ documentation](https://serde.rs/deserialize-struct.html)." +msgstr "Para obter um exemplo completo, consulte a [documentação do _Serde_](https://serde.rs/deserialize-struct.html)." #: src\functional/lenses.md:327 #, fuzzy @@ -9663,74 +8201,56 @@ msgstr "Para finalizar, este é o poder do _Serde_:" #: src\functional/lenses.md:329 #, fuzzy msgid "" -"1. The structure being parsed is represented by an `impl` block for " -"`Deserialize`\n" -"1. The input data format (e.g. JSON) is represented by a `Deserializer` " -"called\n" +"1. The structure being parsed is represented by an `impl` block for `Deserialize`\n" +"1. The input data format (e.g. JSON) is represented by a `Deserializer` called\n" " by `Deserialize`\n" -"1. The `Deserializer` acts like a prism which \"refracts\" lens-like " -"`Visitor`\n" +"1. The `Deserializer` acts like a prism which \"refracts\" lens-like `Visitor`\n" " calls which actually build the data value" msgstr "" -"1. A estrutura que está sendo analisada é representada por um bloco `impl` " -"para `Deserialize`\n" -"1. O formato de dados de entrada (por exemplo, JSON) é representado por um " -"`Deserializer` chamado\n" +"1. A estrutura que está sendo analisada é representada por um bloco `impl` para `Deserialize`\n" +"1. O formato de dados de entrada (por exemplo, JSON) é representado por um `Deserializer` chamado\n" " por `Deserialize`\n" -"1. O `Deserializer` age como um prisma que \"refrata\" o `Visitor` " -"semelhante a uma lente\n" +"1. O `Deserializer` age como um prisma que \"refrata\" o `Visitor` semelhante a uma lente\n" " chamadas que realmente constroem o valor dos dados" #: src\functional/lenses.md:335 #, fuzzy msgid "" -"The result is that types to be deserialized only implement the \"top layer\" " -"of\n" +"The result is that types to be deserialized only implement the \"top layer\" of\n" "the API, and file formats only need to implement the \"bottom layer\".\n" -"Each piece can then \"just work\" with the rest of the ecosystem, since " -"generic\n" +"Each piece can then \"just work\" with the rest of the ecosystem, since generic\n" "types will bridge them." msgstr "" -"O resultado é que os tipos a serem desserializados implementam apenas a " -"\"camada superior\" de\n" -"a API e os formatos de arquivo só precisam implementar a \"camada " -"inferior\".\n" -"Cada peça pode então \"simplesmente funcionar\" com o resto do ecossistema, " -"desde\n" +"O resultado é que os tipos a serem desserializados implementam apenas a \"camada superior\" de\n" +"a API e os formatos de arquivo só precisam implementar a \"camada inferior\".\n" +"Cada peça pode então \"simplesmente funcionar\" com o resto do ecossistema, desde\n" "os tipos os unirão." #: src\functional/lenses.md:340 #, fuzzy msgid "" -"To emphasize, the only reason this model works on any format and any type " -"is\n" +"To emphasize, the only reason this model works on any format and any type is\n" "because the `Deserializer` trait's output type **is specified by the\n" -"implementor of `Visitor` it is passed**, rather than being tied to one " -"specific\n" +"implementor of `Visitor` it is passed**, rather than being tied to one specific\n" "type.\n" "This was not true in the account example earlier." msgstr "" -"Para enfatizar, a única razão pela qual este modelo funciona em qualquer " -"formato e qualquer tipo é\n" +"Para enfatizar, a única razão pela qual este modelo funciona em qualquer formato e qualquer tipo é\n" "porque o tipo de saída do trait `Deserializer` ** é especificado pelo\n" -"implementador de `Visitor` é passado**, em vez de ser vinculado a um " -"específico\n" +"implementador de `Visitor` é passado**, em vez de ser vinculado a um específico\n" "tipo.\n" "Isso não era verdade no exemplo de conta anterior." #: src\functional/lenses.md:346 #, fuzzy msgid "" -"Rust's generic-inspired type system can bring it close to these concepts " -"and\n" +"Rust's generic-inspired type system can bring it close to these concepts and\n" "use their power, as shown in this API design.\n" "But it may also need procedural macros to create bridges for its generics." msgstr "" -"O sistema de tipo de inspiração genérica de Rust pode aproximá-lo desses " -"conceitos e\n" +"O sistema de tipo de inspiração genérica de Rust pode aproximá-lo desses conceitos e\n" "use seu poder, conforme mostrado neste design de API.\n" -"Mas também pode precisar de macros processuais para criar pontes para seus " -"genéricos." +"Mas também pode precisar de macros processuais para criar pontes para seus genéricos." #: src\functional/lenses.md:350 #, fuzzy @@ -9742,53 +8262,40 @@ msgstr "## Veja também" msgid "" "- [lens-rs crate](https://crates.io/crates/lens-rs) for a pre-built lenses\n" " implementation, with a cleaner interface than these examples\n" -"- [serde](https://serde.rs) itself, which makes these concepts intuitive " -"for\n" +"- [serde](https://serde.rs) itself, which makes these concepts intuitive for\n" " end users (i.e. defining the structs) without needing to undestand the\n" " details\n" -"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for " -"drawing\n" -" computer graphics that uses lens API design, including proceducal macros " -"to\n" -" create full prisms for buffers of different pixel types that remain " -"generic\n" -"- [An Article about Lenses in " -"Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-lens-and-other-optics-in-scala-e5f7e2fdafe)\n" +"- [luminance](https://github.com/phaazon/luminance-rs) is a crate for drawing\n" +" computer graphics that uses lens API design, including proceducal macros to\n" +" create full prisms for buffers of different pixel types that remain generic\n" +"- [An Article about Lenses in Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-" +"references-lens-and-other-optics-in-scala-e5f7e2fdafe)\n" " that is very readable even without Scala expertise.\n" "- [Paper: Profunctor Optics: Modular Data\n" -" " -"Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +" Accessors](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" msgstr "" -"- [lens-rs crate](https://crates.io/crates/lens-rs) para lentes " -"pré-construídas\n" +"- [lens-rs crate](https://crates.io/crates/lens-rs) para lentes pré-construídas\n" " implementação, com uma interface mais limpa do que esses exemplos\n" -"- [serde](https://serde.rs) em si, o que torna esses conceitos intuitivos " -"para\n" +"- [serde](https://serde.rs) em si, o que torna esses conceitos intuitivos para\n" " usuários finais (isto é, definindo as estruturas) sem precisar entender o\n" " detalhes\n" -"- [luminância](https://github.com/phaazon/luminance-rs) é uma caixa para " -"desenho\n" -" computação gráfica que usa design de API de lentes, incluindo macros " -"processuais para\n" -" criar prismas completos para buffers de diferentes tipos de pixel que " -"permanecem genéricos\n" -"- [Um artigo sobre lentes em " -"Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-references-lens-and-other-optics-in- " -"scala-e5f7e2fdafe)\n" +"- [luminância](https://github.com/phaazon/luminance-rs) é uma caixa para desenho\n" +" computação gráfica que usa design de API de lentes, incluindo macros processuais para\n" +" criar prismas completos para buffers de diferentes tipos de pixel que permanecem genéricos\n" +"- [Um artigo sobre lentes em Scala](https://web.archive.org/web/20221128185849/https://medium.com/zyseme-technology/functional-" +"references-lens-and-other-optics-in- scala-e5f7e2fdafe)\n" " que é muito legível mesmo sem experiência em Scala.\n" "- [Papel: Profunctor Optics: Modular Data\n" -" " -"Acessadores](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" +" Acessadores](https://web.archive.org/web/20220701102832/https://arxiv.org/ftp/arxiv/papers/1703/1703.10857.pdf)" #: src\functional/lenses.md:365 #, fuzzy msgid "" -"[School of Haskell: A Little Lens Starter " -"Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" +"[School of Haskell: A Little Lens Starter Tutorial](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/" +"to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)" msgstr "" -"[Escola de Haskell: um pequeno tutorial para iniciantes em " -"lentes](https://web.archive.org/web/20221128190041/https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of- " -"the-week/a-little-lens-starter-tutorial)" +"[Escola de Haskell: um pequeno tutorial para iniciantes em lentes](https://web.archive.org/web/20221128190041/https://www." +"schoolofhaskell.com/school/to-infinity-and-beyond/pick-of- the-week/a-little-lens-starter-tutorial)" #: src\additional_resources/index.md:1 #, fuzzy @@ -9810,21 +8317,16 @@ msgstr "## Palestras" msgid "" "- [Design Patterns in Rust](https://www.youtube.com/watch?v=Pm_oO0N5B9k) by\n" " Nicholas Cameron at the PDRust (2016)\n" -"- [Writing Idiomatic Libraries in " -"Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +"- [Writing Idiomatic Libraries in Rust](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" " by Pascal Hertleif at RustFest (2017)\n" -"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) " -"by\n" +"- [Rust Programming Techniques](https://www.youtube.com/watch?v=vqavdUGKeb4) by\n" " Nicholas Cameron at LinuxConfAu (2018)" msgstr "" -"- [Padrões de design em " -"ferrugem](https://www.youtube.com/watch?v=Pm_oO0N5B9k) por\n" +"- [Padrões de design em ferrugem](https://www.youtube.com/watch?v=Pm_oO0N5B9k) por\n" " Nicholas Cameron no PDRust (2016)\n" -"- [Escrevendo bibliotecas idiomáticas em " -"ferrugem](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" +"- [Escrevendo bibliotecas idiomáticas em ferrugem](https://www.youtube.com/watch?v=0zOg8_B71gE)\n" " por Pascal Hertleif no RustFest (2017)\n" -"- [Técnicas de Programação " -"Rust](https://www.youtube.com/watch?v=vqavdUGKeb4) por\n" +"- [Técnicas de Programação Rust](https://www.youtube.com/watch?v=vqavdUGKeb4) por\n" " Nicholas Cameron na LinuxConfAu (2018)" #: src\additional_resources/index.md:14 @@ -9855,62 +8357,42 @@ msgstr "## [SOLID](https://en.wikipedia.org/wiki/SOLID)" #: src\additional_resources/design-principles.md:9 #, fuzzy msgid "" -"- [Single Responsibility Principle " -"(SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" -" A class should only have a single responsibility, that is, only changes " -"to\n" +"- [Single Responsibility Principle (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" A class should only have a single responsibility, that is, only changes to\n" " one part of the software's specification should be able to affect the\n" " specification of the class.\n" -"- [Open/Closed Principle " -"(OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +"- [Open/Closed Principle (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" " \"Software entities ... should be open for extension, but closed for\n" " modification.\"\n" -"- [Liskov Substitution Principle " -"(LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" -" \"Objects in a program should be replaceable with instances of their " -"subtypes\n" +"- [Liskov Substitution Principle (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Objects in a program should be replaceable with instances of their subtypes\n" " without altering the correctness of that program.\"\n" -"- [Interface Segregation Principle " -"(ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +"- [Interface Segregation Principle (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" " \"Many client-specific interfaces are better than one general-purpose\n" " interface.\"\n" -"- [Dependency Inversion Principle " -"(DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +"- [Dependency Inversion Principle (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" " One should \"depend upon abstractions, [not] concretions.\"" msgstr "" -"- [Princípio de Responsabilidade Única " -"(SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" -" Uma classe deve ter apenas uma única responsabilidade, ou seja, apenas " -"alterações\n" +"- [Princípio de Responsabilidade Única (SRP)](https://en.wikipedia.org/wiki/Single-responsibility_principle):\n" +" Uma classe deve ter apenas uma única responsabilidade, ou seja, apenas alterações\n" " uma parte da especificação do software deve ser capaz de afetar o\n" " especificação da classe.\n" -"- [Princípio Aberto/Fechado " -"(OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" -" \"Entidades de software ... devem estar abertas para extensão, mas " -"fechadas para\n" +"- [Princípio Aberto/Fechado (OCP)](https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle):\n" +" \"Entidades de software ... devem estar abertas para extensão, mas fechadas para\n" " modificação.\"\n" -"- [Princípio de Substituição de Liskov " -"(LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" -" \"Objetos em um programa devem ser substituíveis por instâncias de seus " -"subtipos\n" +"- [Princípio de Substituição de Liskov (LSP)](https://en.wikipedia.org/wiki/Liskov_substitution_principle):\n" +" \"Objetos em um programa devem ser substituíveis por instâncias de seus subtipos\n" " sem alterar a correção desse programa.\"\n" -"- [Princípio de Segregação de Interface " -"(ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" -" \"Muitas interfaces específicas do cliente são melhores do que uma de uso " -"geral\n" +"- [Princípio de Segregação de Interface (ISP)](https://en.wikipedia.org/wiki/Interface_segregation_principle):\n" +" \"Muitas interfaces específicas do cliente são melhores do que uma de uso geral\n" " interface.\"\n" -"- [Princípio de Inversão de Dependência " -"(DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" +"- [Princípio de Inversão de Dependência (DIP)](https://en.wikipedia.org/wiki/Dependency_inversion_principle):\n" " Deve-se \"depender de abstrações, [não] concreções\"." #: src\additional_resources/design-principles.md:25 #, fuzzy -msgid "" -"## [DRY (Don’t Repeat " -"Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" -msgstr "" -"## [DRY (Don't Repeat " -"Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgid "## [DRY (Don’t Repeat Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" +msgstr "## [DRY (Don't Repeat Yourself)](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)" #: src\additional_resources/design-principles.md:27 #, fuzzy @@ -9928,8 +8410,7 @@ msgstr "## [princípio KISS](https://en.wikipedia.org/wiki/KISS_principle)" #: src\additional_resources/design-principles.md:32 msgid "" -"most systems work best if they are kept simple rather than made " -"complicated;\n" +"most systems work best if they are kept simple rather than made complicated;\n" "therefore, simplicity should be a key goal in design, and unnecessary\n" "complexity should be avoided" msgstr "" @@ -9943,72 +8424,51 @@ msgstr "## [Lei de Demeter (LoD)](https://en.wikipedia.org/wiki/Law_of_Demeter)" #, fuzzy msgid "" "a given object should assume as little as possible about the structure or\n" -"properties of anything else (including its subcomponents), in accordance " -"with\n" +"properties of anything else (including its subcomponents), in accordance with\n" "the principle of \"information hiding\"" msgstr "" "um determinado objeto deve assumir o mínimo possível sobre a estrutura ou\n" -"propriedades de qualquer outra coisa (incluindo seus subcomponentes), de " -"acordo com\n" +"propriedades de qualquer outra coisa (incluindo seus subcomponentes), de acordo com\n" "o princípio de \"ocultação de informações\"" #: src\additional_resources/design-principles.md:42 #, fuzzy -msgid "" -"## [Design by contract " -"(DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" -msgstr "" -"## [Design por contrato " -"(DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgid "## [Design by contract (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" +msgstr "## [Design por contrato (DbC)](https://en.wikipedia.org/wiki/Design_by_contract)" #: src\additional_resources/design-principles.md:44 #, fuzzy msgid "" "software designers should define formal, precise and verifiable interface\n" -"specifications for software components, which extend the ordinary definition " -"of\n" +"specifications for software components, which extend the ordinary definition of\n" "abstract data types with preconditions, postconditions and invariants" msgstr "" "designers de software devem definir interface formal, precisa e verificável\n" -"especificações para componentes de software, que estendem a definição comum " -"de\n" +"especificações para componentes de software, que estendem a definição comum de\n" "tipos de dados abstratos com pré-condições, pós-condições e invariantes" #: src\additional_resources/design-principles.md:48 #, fuzzy -msgid "" -"## " -"[Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" -msgstr "" -"## " -"[Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgid "## [Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" +msgstr "## [Encapsulation](https://en.wikipedia.org/wiki/Encapsulation_(computer_programming))" #: src\additional_resources/design-principles.md:50 #, fuzzy msgid "" -"bundling of data with the methods that operate on that data, or the " -"restricting\n" -"of direct access to some of an object's components. Encapsulation is used " -"to\n" -"hide the values or state of a structured data object inside a class, " -"preventing\n" +"bundling of data with the methods that operate on that data, or the restricting\n" +"of direct access to some of an object's components. Encapsulation is used to\n" +"hide the values or state of a structured data object inside a class, preventing\n" "unauthorized parties' direct access to them." msgstr "" "agrupamento de dados com os métodos que operam nesses dados, ou a restrição\n" -"de acesso direto a alguns dos componentes de um objeto. O encapsulamento é " -"usado para\n" -"ocultar os valores ou estado de um objeto de dados estruturados dentro de " -"uma classe, evitando\n" +"de acesso direto a alguns dos componentes de um objeto. O encapsulamento é usado para\n" +"ocultar os valores ou estado de um objeto de dados estruturados dentro de uma classe, evitando\n" "acesso direto de partes não autorizadas a eles." #: src\additional_resources/design-principles.md:55 #, fuzzy -msgid "" -"## " -"[Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" -msgstr "" -"## " -"[Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgid "## [Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" +msgstr "## [Command-Query-Separation(CQS)](https://en.wikipedia.org/wiki/Command%E2%80%93query_separation)" #: src\additional_resources/design-principles.md:57 #, fuzzy @@ -10017,30 +8477,22 @@ msgid "" "(procedures) will be permitted to produce side effects.” - Bertrand Meyer:\n" "Object-Oriented Software Construction" msgstr "" -"“As funções não devem produzir efeitos colaterais abstratos... apenas " -"comandos\n" -"(procedimentos) serão permitidos para produzir efeitos colaterais.” " -"-Bertrand Meyer:\n" +"“As funções não devem produzir efeitos colaterais abstratos... apenas comandos\n" +"(procedimentos) serão permitidos para produzir efeitos colaterais.” -Bertrand Meyer:\n" "Construção de Software Orientado a Objetos" #: src\additional_resources/design-principles.md:61 #, fuzzy -msgid "" -"## [Principle of least astonishment " -"(POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" -msgstr "" -"## [Princípio do menor espanto " -"(POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgid "## [Principle of least astonishment (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" +msgstr "## [Princípio do menor espanto (POLA)](https://en.wikipedia.org/wiki/Principle_of_least_astonishment)" #: src\additional_resources/design-principles.md:63 #, fuzzy msgid "" -"a component of a system should behave in a way that most users will expect " -"it\n" +"a component of a system should behave in a way that most users will expect it\n" "to behave. The behavior should not astonish or surprise users" msgstr "" -"um componente de um sistema deve se comportar de uma maneira que a maioria " -"dos usuários espera\n" +"um componente de um sistema deve se comportar de uma maneira que a maioria dos usuários espera\n" "comportar-se. O comportamento não deve surpreender ou surpreender os usuários" #: src\additional_resources/design-principles.md:66 @@ -10051,12 +8503,10 @@ msgstr "## Linguistic-Modular-Units" #: src\additional_resources/design-principles.md:68 #, fuzzy msgid "" -"“Modules must correspond to syntactic units in the language used.” - " -"Bertrand\n" +"“Modules must correspond to syntactic units in the language used.” - Bertrand\n" "Meyer: Object-Oriented Software Construction" msgstr "" -"“Os módulos devem corresponder às unidades sintáticas da linguagem " -"utilizada.” -Bertrand\n" +"“Os módulos devem corresponder às unidades sintáticas da linguagem utilizada.” -Bertrand\n" "Meyer: Construção de Software Orientado a Objetos" #: src\additional_resources/design-principles.md:71 @@ -10068,14 +8518,11 @@ msgstr "## Autodocumentação" #, fuzzy msgid "" "“The designer of a module should strive to make all information about the\n" -"module part of the module itself.” - Bertrand Meyer: Object-Oriented " -"Software\n" +"module part of the module itself.” - Bertrand Meyer: Object-Oriented Software\n" "Construction" msgstr "" -"“O projetista de um módulo deve se esforçar para tornar todas as informações " -"sobre o\n" -"parte do módulo do próprio módulo.” - Bertrand Meyer: Software Orientado a " -"Objetos\n" +"“O projetista de um módulo deve se esforçar para tornar todas as informações sobre o\n" +"parte do módulo do próprio módulo.” - Bertrand Meyer: Software Orientado a Objetos\n" "Construção" #: src\additional_resources/design-principles.md:77 @@ -10087,16 +8534,12 @@ msgstr "## Uniform-Access" #, fuzzy msgid "" "“All services offered by a module should be available through a uniform\n" -"notation, which does not betray whether they are implemented through storage " -"or\n" +"notation, which does not betray whether they are implemented through storage or\n" "through computation.” - Bertrand Meyer: Object-Oriented Software Construction" msgstr "" -"“Todos os serviços oferecidos por um módulo devem estar disponíveis por meio " -"de um\n" -"notação, que não revela se eles são implementados por meio de armazenamento " -"ou\n" -"através da computação”. - Bertrand Meyer: Construção de Software Orientado a " -"Objetos" +"“Todos os serviços oferecidos por um módulo devem estar disponíveis por meio de um\n" +"notação, que não revela se eles são implementados por meio de armazenamento ou\n" +"através da computação”. - Bertrand Meyer: Construção de Software Orientado a Objetos" #: src\additional_resources/design-principles.md:83 #, fuzzy @@ -10106,14 +8549,11 @@ msgstr "## Escolha única" #: src\additional_resources/design-principles.md:85 #, fuzzy msgid "" -"“Whenever a software system must support a set of alternatives, one and " -"only\n" -"one module in the system should know their exhaustive list.” - Bertrand " -"Meyer:\n" +"“Whenever a software system must support a set of alternatives, one and only\n" +"one module in the system should know their exhaustive list.” - Bertrand Meyer:\n" "Object-Oriented Software Construction" msgstr "" -"“Sempre que um sistema de software deve suportar um conjunto de " -"alternativas, uma e somente\n" +"“Sempre que um sistema de software deve suportar um conjunto de alternativas, uma e somente\n" "um módulo no sistema deve conhecer sua lista exaustiva.” -Bertrand Meyer:\n" "Construção de Software Orientado a Objetos" @@ -10127,49 +8567,12 @@ msgstr "## Persistência-Fechamento" msgid "" "“Whenever a storage mechanism stores an object, it must store with it the\n" "dependents of that object. Whenever a retrieval mechanism retrieves a\n" -"previously stored object, it must also retrieve any dependent of that " -"object\n" -"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented " -"Software\n" +"previously stored object, it must also retrieve any dependent of that object\n" +"that has not yet been retrieved.” - Bertrand Meyer: Object-Oriented Software\n" "Construction" msgstr "" -"“Sempre que um mecanismo de armazenamento armazena um objeto, ele deve " -"armazenar com ele o\n" -"dependentes desse objeto. Sempre que um mecanismo de recuperação recupera " -"um\n" -"objeto armazenado anteriormente, ele também deve recuperar qualquer " -"dependente desse objeto\n" -"que ainda não foi recuperado.” - Bertrand Meyer: Software Orientado a " -"Objetos\n" +"“Sempre que um mecanismo de armazenamento armazena um objeto, ele deve armazenar com ele o\n" +"dependentes desse objeto. Sempre que um mecanismo de recuperação recupera um\n" +"objeto armazenado anteriormente, ele também deve recuperar qualquer dependente desse objeto\n" +"que ainda não foi recuperado.” - Bertrand Meyer: Software Orientado a Objetos\n" "Construção" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - -msgid "" -msgstr "" - diff --git a/theme/index.hbs b/theme/index.hbs index dd83020..a5ab56b 100644 --- a/theme/index.hbs +++ b/theme/index.hbs @@ -1,278 +1,294 @@ - - - - {{ title }} - {{#if is_print }} - - {{/if}} - {{#if base_url}} - - {{/if}} - - - {{> head}} - - - - - - {{#if favicon_svg}} - - {{/if}} - {{#if favicon_png}} - - {{/if}} - - - - {{#if print_enable}} - - {{/if}} - - - - {{#if copy_fonts}} - - {{/if}} - - - - - - - - {{#each additional_css}} - - {{/each}} - - {{#if mathjax_support}} - - - {{/if}} - - - - - - - - - - - - - + {{/if}} + + + + + + + + -

+ if (sidebar.startsWith('"') && sidebar.endsWith('"')) { + localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1)); + } + } catch (e) { } + + + + + + + + + + +
+ +
+ {{> header}} + +