{"action":"created","comment":{"url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/comments/176921713","pull_request_review_id":106699852,"id":176921713,"diff_hunk":"@@ -0,0 +1,487 @@\n+## To `panic!` or Not to `panic!`\n+\n+## Entrar em `panic!` ou Não Entrar em `panic!`\n+\n+So how do you decide when you should `panic!` and when you should return\n+`Result`? When code panics, there’s no way to recover. You could call `panic!`\n+for any error situation, whether there’s a possible way to recover or not, but\n+then you’re making the decision on behalf of the code calling your code that a\n+situation is unrecoverable. When you choose to return a `Result` value, you\n+give the calling code options rather than making the decision for it. The\n+calling code could choose to attempt to recover in a way that’s appropriate for\n+its situation, or it could decide that an `Err` value in this case is\n+unrecoverable, so it can call `panic!` and turn your recoverable error into an\n+unrecoverable one. Therefore, returning `Result` is a good default choice when\n+you’re defining a function that might fail.\n+\n+Então como você decide quando entrar em `panic!` e quando você deveria retornar\n+um `Result`? Quando o código entra em pânico, não há maneira de se recuperar. Você\n+poderia chamar `panic!` para qualquer situação de erro, tendo uma maneira de se recuperar\n+ou não, mas então você estaria decidindo no lugar do código chamando seu código\n+que a situação é irrecuperável. Quando você decide retornar um valor de `Result`,\n+você dá ao código chamando opções ao invés de tomar a decisão por ele. O código\n+que chama seu código pode tentar se recuperar de uma maneira que é apropriada para\n+a situação, ou ele pode decidir que um valor de `Err` nesse caso é irrecuperável,\n+chamando `panic!` e transformando seu erro recuperável em um irrecuperável.\n+Portanto, retornar `Result` é uma boa escolha padrão quando você está definindo\n+uma função que pode falhar\n+\n+In a few situations it’s more appropriate to write code that panics instead of\n+returning a `Result`, but they are less common. Let’s explore why it’s\n+appropriate to panic in examples, prototype code, and tests; then in situations\n+where you as a human can know a method won’t fail that the compiler can’t\n+reason about; and conclude with some general guidelines on how to decide\n+whether to panic in library code.\n+\n+Em algumas situações é mais apropriado escrever código que entra em pânico ao invés\n+de retornar um `Result`, mas eles são menos comuns. Vamos explorar porque é apropriado\n+entrar em pânico em alguns exemplos, protótipos de código e testes; depois situações\n+em que você como humano pode saber que um método não vai falhar que o compilador não\n+pode raciocinar sobre; e concluir com algumas diretrizes sobre como decidir entrar ou\n+não em pânico em código de biblioteca.\n+\n+### Examples, Prototype Code, and Tests Are All Places it’s Perfectly Fine to Panic\n+\n+### Exemplos, Protótipos, e Testes São Todos Lugares em que É Perfeitamente Ok Entrar em Pânico\n+\n+When you’re writing an example to illustrate some concept, having robust error\n+handling code in the example as well can make the example less clear. In\n+examples, it’s understood that a call to a method like `unwrap` that could\n+`panic!` is meant as a placeholder for the way that you’d want your application\n+to handle errors, which can differ based on what the rest of your code is doing.\n+\n+Quando você está escrevendo um exemplo para ilustrar algum conceito, ter código\n+de tratamento de erro robusto junto do exemplo pode torná-lo menos claro. Em exemplos,\n+é entendido que uma chamada a um método como `unwrap` que poderia chamar `panic!`\n+substitui a maneira como você quereria que sua aplicação tratasse erros,\n+que pode ser diferente baseado no que o resto do seu código está fazendo.\n+\n+Similarly, the `unwrap` and `expect` methods are very handy when prototyping,\n+before you’re ready to decide how to handle errors. They leave clear markers in\n+your code for when you’re ready to make your program more robust.\n+\n+De forma semelhante, os métodos `unwrap` e `expect` são bem úteis ao fazer\n+protótipos, antes de você estar pronto para decidir como tratar erros. Eles deixam\n+marcadores claros no seu código para quando você estiver pronto para tornar\n+seu programa mais robusto.\n+\n+If a method call fails in a test, we’d want the whole test to fail, even if\n+that method isn’t the functionality under test. Because `panic!` is how a test\n+is marked as a failure, calling `unwrap` or `expect` is exactly what should\n+happen.\n+\n+Se uma chamada de método falha em um teste, queremos que o teste inteiro falhe,\n+mesmo se esse método não é a funcionalidade sendo testada. Como `panic!` é o modo\n+que um teste é marcado como falha, chamar `unwrap` ou `expect` é exatamente o que\n+deveria acontecer.\n+\n+### Cases When You Have More Information Than the Compiler\n+\n+### Casos em que Você Tem Mais Informação Que o Compilador\n+\n+It would also be appropriate to call `unwrap` when you have some other logic\n+that ensures the `Result` will have an `Ok` value, but the logic isn’t\n+something the compiler understands. You’ll still have a `Result` value that you\n+need to handle: whatever operation you’re calling still has the possibility of\n+failing in general, even though it’s logically impossible in your particular\n+situation. If you can ensure by manually inspecting the code that you’ll never\n+have an `Err` variant, it’s perfectly acceptable to call `unwrap`. Here’s an\n+example:\n+\n+Seria também apropriado chamar `unwrap` quando você tem outra lógica que\n+assegura que o `Result` vai ter um valor de `Ok`, mas essa lógica não é algo\n+que o compilador entenda. Você ainda vai ter um valor de `Result` que precisa \n+lidar: seja qual for a operação que você está chamando, ela ainda tem uma possibilidade\n+de falhar no geral, mesmo que seja logicamente impossível que isso ocorra nessa \n+situação particular. Se você consegue assegurar ao inspecionar manualmente o código que\n+você nunca tera uma variante `Err`, é perfeitamente aceitável chamar `unwrap`.\n+Aqui temos um exemplo:\n+\n+```rust\n+use std::net::IpAddr;\n+\n+let home = \"127.0.0.1\".parse::<IpAddr>().unwrap();\n+```\n+\n+We’re creating an `IpAddr` instance by parsing a hardcoded string. We can see\n+that `127.0.0.1` is a valid IP address, so it’s acceptable to use `unwrap`\n+here. However, having a hardcoded, valid string doesn’t change the return type\n+of the `parse` method: we still get a `Result` value, and the compiler will\n+still make us handle the `Result` as if the `Err` variant is still a\n+possibility because the compiler isn’t smart enough to see that this string is\n+always a valid IP address. If the IP address string came from a user rather\n+than being hardcoded into the program, and therefore *did* have a possibility\n+of failure, we’d definitely want to handle the `Result` in a more robust way\n+instead.\n+\n+Nós estamos criando uma instância `IpAddr` ao analisar uma string *hardcoded*. Nós\n+podemos ver que `127.0.0.1` é um endereço de IP válido, então é aceitável usar \n+`unwrap` aqui. No entanto, ter uma string válida *hardcoded* não muda o tipo retornado\n+pelo método `parse`: ainda teremos um valor de `Result`, e o compilador vai\n+ainda nos fazer tratar o `Result` como se a variante `Err` ainda fosse uma\n+possibilidade porque o compilador não é inteligente o bastante para ver que essa string\n+é sempre um endereço IP válido. Se a string de endereço IP viesse de um usuário ao invés\n+de ser *hardcoded* no programa, e portanto de fato tivesse uma possibilidade de falha, nós\n+definitivamente quereríamos tratar o `Result` de uma forma mais robusta ao invés.\n+\n+### Guidelines for Error Handling\n+\n+### Diretrizes para Tratamento de Erro\n+\n+It’s advisable to have your code `panic!` when it’s possible that your code\n+could end up in a bad state. In this context, bad state is when some\n+assumption, guarantee, contract, or invariant has been broken, such as when\n+invalid values, contradictory values, or missing values are passed to your\n+code—plus one or more of the following:\n+\n+É aconselhável fazer que seu código entre em `panic!` quando é possível que\n+seu código entre em um estado ruim. Nesse contexto, estado ruim é quando\n+alguma hipótese, garantia, contrato ou invariante foi quebrada, tal como\n+valores inválidos, valores contraditórios, ou valores faltando que são passados\n+a seu código - além de um ou mais dos seguintes:\n+\n+* The bad state is not something that’s *expected* to happen occasionally.\n+* Your code after this point needs to rely on not being in this bad state.\n+* There’s not a good way to encode this information in the types you use.\n+\n+* O estado ruim não é algo que é *esperado* que aconteça ocasionalmente\n+* Seu código depois de um ponto precisa confiar que ele não está nesse estado ruim\n+* Não há uma forma boa de codificar essa informação nos tipos que você usa.\n+\n+If someone calls your code and passes in values that don’t make sense, the best\n+choice might be to `panic!` and alert the person using your library to the bug\n+in their code so they can fix it during development. Similarly, `panic!` is\n+often appropriate if you’re calling external code that is out of your control,\n+and it returns an invalid state that you have no way of fixing.\n+\n+Se alguém chama seu código e passa valores que não fazem sentido, a melhor escolha\n+talvez seja entrar em `panic!` e alertar a pessoa usando sua biblioteca do bug no\n+código dela para que ela possa consertá-la durante o desenvolvimento. Similarmente,\n+`panic!` é em geral apropriado se você está chamando código externo que está fora\n+do seu controle e ele retorna um estado inválido que você não tem como concertar.\n+\n+When a bad state is reached, but it’s expected to happen no matter how well you\n+write your code, it’s still more appropriate to return a `Result` rather than\n+making a `panic!` call. Examples of this include a parser being given malformed\n+data or an HTTP request returning a status that indicates you have hit a rate\n+limit. In these cases, you should indicate that failure is an expected\n+possibility by returning a `Result` to propagate these bad states upwards so\n+the calling code can decide how to handle the problem. To `panic!` wouldn’t be\n+the best way to handle these cases.\n+\n+Quando se chega a um estado ruim, mas isso é esperado que aconteça não importa\n+quão  bem você escreva seu código, ainda é mais apropriado retornar um `Result`\n+a fazer uma chamada a `panic!`. Exemplos disso inclui um *parser* recebendo dados\n+malformados ou uma requisição HTTP retornando um status que indique que você atingiu\n+um limite de taxa. Nesses casos, você deveria indicar que falha é uma possibilidade\n+esperada ao retornar um `Result` para propagar esses estados ruins para cima,\n+de forma que o código que chamou seu código pode decidir como tratar o problema.\n+Entrar em `panic!` não seria a melhor maneira de lidar com esses casos.\n+\n+When your code performs operations on values, your code should verify the\n+values are valid first, and `panic!` if the values aren’t valid. This is mostly\n+for safety reasons: attempting to operate on invalid data can expose your code\n+to vulnerabilities. This is the main reason the standard library will `panic!`\n+if you attempt an out-of-bounds memory access: trying to access memory that\n+doesn’t belong to the current data structure is a common security problem.\n+Functions often have *contracts*: their behavior is only guaranteed if the\n+inputs meet particular requirements. Panicking when the contract is violated\n+makes sense because a contract violation always indicates a caller-side bug,\n+and it’s not a kind of error you want the calling code to have to explicitly\n+handle. In fact, there’s no reasonable way for calling code to recover: the\n+calling *programmers* need to fix the code. Contracts for a function,\n+especially when a violation will cause a panic, should be explained in the API\n+documentation for the function.\n+\n+Quando seu código realiza operações em valores, ele deveria verificar que os valores\n+são válidos primeiro, e entrar em `panic!` se os valores não são válidos. Isso é \n+em boa parte por razões de segurança: tentar operar em dados inválidos pode expor seu\n+código a vulnerabilidades. Essa é a principal razão para a biblioteca padrão entrar em\n+`panic!` se você tentar um acesso de memória fora dos limites: tentar acessar memória \n+que não pertence à estrutura de dados atual é um problema de segurança comum. Funções \n+frequentemente tem *contratos*: seu comportamento somente é garantido se os inputs cumprem\n+requerimentos específicos. Entrar em pânico quando o contrato é violado faz sentido \n+porque uma violação de contrato sempre indica um bug da parte do chamante, e não é o tipo \n+de erro que você quer que o código chamador tenha que lidar com explicitamente. De fato, \n+não há nenhuma maneira razoável para o código chamador se recuperar: os *programadores*\n+que precisam concertar o código. Contratos para uma função, especialmente quando uma\n+violação leva a pânico, devem ser explicados na documentação da API da função.\n+\n+However, having lots of error checks in all of your functions would be verbose\n+and annoying. Fortunately, you can use Rust’s type system (and thus the type\n+checking the compiler does) to do many of the checks for you. If your function\n+has a particular type as a parameter, you can proceed with your code’s logic\n+knowing that the compiler has already ensured you have a valid value. For\n+example, if you have a type rather than an `Option`, your program expects to\n+have *something* rather than *nothing*. Your code then doesn’t have to handle\n+two cases for the `Some` and `None` variants: it will only have one case for\n+definitely having a value. Code trying to pass nothing to your function won’t\n+even compile, so your function doesn’t have to check for that case at runtime.\n+Another example is using an unsigned integer type like `u32`, which ensures the\n+parameter is never negative.\n+\n+No entanto, ter várias checagens de erro em todas suas funções pode ser verboso\n+e irritante. Felizmente, você pode usar o sistema de tipos do Rust (e portanto a\n+checagem que o compilador faz) para fazer várias dessas checagens para você. Se\n+sua função têm um tipo particular como parâmetro, você pode continuar com a lógica\n+do seu código sabendo que o compilador já assegurou que você tem um valor válido.\n+Por exemplo, se você tem um tipo ao invés de uma `Option`, seu programa espera\n+ter *algo* ao invés de *nothing*. Seu código não precisa tratar dois casos para\n+as variantes `Some` e `None`: ele vai somente ter um caso para definitivamente ter\n+um valor. Um código que tente passar nada para sua função não vai nem compilar,\n+então sua função não precisa checar por esse caso em *runtime*. Outro exemplo é usar\n+um tipo de inteiro sem sinal como `u32`, que assegura que o parâmetro nunca é\n+negativo.\n+\n+### Creating Custom Types for Validation\n+\n+### Criando Tipos Customizados para Validação\n+\n+Let’s take the idea of using Rust’s type system to ensure we have a valid value\n+one step further and look at creating a custom type for validation. Recall the\n+guessing game in Chapter 2 where our code asked the user to guess a number\n+between 1 and 100. We never validated that the user’s guess was between those\n+numbers before checking it against our secret number; we only validated that\n+the guess was positive. In this case, the consequences were not very dire: our\n+output of “Too high” or “Too low” would still be correct. It would be a useful\n+enhancement to guide the user toward valid guesses and have different behavior\n+when a user guesses a number that’s out of range versus when a user types, for\n+example, letters instead.\n+\n+Vamos pegar a ideia de usar o sistema de tipos de Rust para assegurar que temos\n+um valor válido um passo adiante e ver como criar um tipo customizado para validação.\n+Lembre do jogo de adivinhação no Capítulo 2 onde nosso código pedia ao usuário \n+para adivinhar um número entre 1 e 100. Nós nunca validamos que o chute do usuário\n+fosse entre esses números antes de compará-lo com o número secreto; nós somente \n+validamos que o chute era positivo. Nesse caso, as consequências não foram tão\n+drásticas: nosso output de \"Muito alto\" ou \"Muito baixo\" ainda estariam corretos. Seria\n+uma melhoria útil guiar o usuário para chutes válidos, e ter um comportamento distinto\n+se um usuário chuta um número fora do limite versus quando um usuário ao invés digita, \n+por exemplo letras.\n+\n+One way to do this would be to parse the guess as an `i32` instead of only a\n+`u32` to allow potentially negative numbers, and then add a check for the\n+number being in range, like so:\n+\n+Uma maneira de fazer isso seria *parsear* o chute como um `i32` ao invés de\n+somente um `u32` para permitir números potenciamente negativos, e então adicionar\n+uma checagem se o número está dentro dos limites, como em:","path":"src/ch09-03-to-panic-or-not-to-panic.md","position":268,"original_position":268,"commit_id":"aef82b54532056a2186f89ec32e135e973b59199","original_commit_id":"aef82b54532056a2186f89ec32e135e973b59199","user":{"login":"Milack27","id":10947510,"avatar_url":"https://avatars2.githubusercontent.com/u/10947510?v=4","gravatar_id":"","url":"https://api.github.com/users/Milack27","html_url":"https://github.com/Milack27","followers_url":"https://api.github.com/users/Milack27/followers","following_url":"https://api.github.com/users/Milack27/following{/other_user}","gists_url":"https://api.github.com/users/Milack27/gists{/gist_id}","starred_url":"https://api.github.com/users/Milack27/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Milack27/subscriptions","organizations_url":"https://api.github.com/users/Milack27/orgs","repos_url":"https://api.github.com/users/Milack27/repos","events_url":"https://api.github.com/users/Milack27/events{/privacy}","received_events_url":"https://api.github.com/users/Milack27/received_events","type":"User","site_admin":false},"body":"- Sugestão: Uma maneira de fazer isso seria *~parsear~* **interpretar** o chute...\r\n- Sugestão: ... se o número está dentro dos limites, ~como em~ **conforme a seguir**:","created_at":"2018-03-24T22:13:59Z","updated_at":"2018-03-24T22:59:55Z","html_url":"https://github.com/rust-br/rust-book-pt-br/pull/52#discussion_r176921713","pull_request_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52","author_association":"NONE","_links":{"self":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/comments/176921713"},"html":{"href":"https://github.com/rust-br/rust-book-pt-br/pull/52#discussion_r176921713"},"pull_request":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52"}}},"pull_request":{"url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52","id":170374174,"html_url":"https://github.com/rust-br/rust-book-pt-br/pull/52","diff_url":"https://github.com/rust-br/rust-book-pt-br/pull/52.diff","patch_url":"https://github.com/rust-br/rust-book-pt-br/pull/52.patch","issue_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues/52","number":52,"state":"open","locked":false,"title":"Traduz capítulo 9","user":{"login":"Abello966","id":4400081,"avatar_url":"https://avatars2.githubusercontent.com/u/4400081?v=4","gravatar_id":"","url":"https://api.github.com/users/Abello966","html_url":"https://github.com/Abello966","followers_url":"https://api.github.com/users/Abello966/followers","following_url":"https://api.github.com/users/Abello966/following{/other_user}","gists_url":"https://api.github.com/users/Abello966/gists{/gist_id}","starred_url":"https://api.github.com/users/Abello966/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Abello966/subscriptions","organizations_url":"https://api.github.com/users/Abello966/orgs","repos_url":"https://api.github.com/users/Abello966/repos","events_url":"https://api.github.com/users/Abello966/events{/privacy}","received_events_url":"https://api.github.com/users/Abello966/received_events","type":"User","site_admin":false},"body":"Tradução do capítulo 9 da segunda edição\r\n","created_at":"2018-02-21T04:30:02Z","updated_at":"2018-03-24T22:59:56Z","closed_at":null,"merged_at":null,"merge_commit_sha":null,"assignee":null,"assignees":[],"requested_reviewers":[],"requested_teams":[],"labels":[],"milestone":null,"commits_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52/commits","review_comments_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52/comments","review_comment_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/comments{/number}","comments_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues/52/comments","statuses_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/statuses/aef82b54532056a2186f89ec32e135e973b59199","head":{"label":"Abello966:translate/chapter-09","ref":"translate/chapter-09","sha":"aef82b54532056a2186f89ec32e135e973b59199","user":{"login":"Abello966","id":4400081,"avatar_url":"https://avatars2.githubusercontent.com/u/4400081?v=4","gravatar_id":"","url":"https://api.github.com/users/Abello966","html_url":"https://github.com/Abello966","followers_url":"https://api.github.com/users/Abello966/followers","following_url":"https://api.github.com/users/Abello966/following{/other_user}","gists_url":"https://api.github.com/users/Abello966/gists{/gist_id}","starred_url":"https://api.github.com/users/Abello966/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Abello966/subscriptions","organizations_url":"https://api.github.com/users/Abello966/orgs","repos_url":"https://api.github.com/users/Abello966/repos","events_url":"https://api.github.com/users/Abello966/events{/privacy}","received_events_url":"https://api.github.com/users/Abello966/received_events","type":"User","site_admin":false},"repo":{"id":121127687,"name":"rust-book-pt-br","full_name":"Abello966/rust-book-pt-br","owner":{"login":"Abello966","id":4400081,"avatar_url":"https://avatars2.githubusercontent.com/u/4400081?v=4","gravatar_id":"","url":"https://api.github.com/users/Abello966","html_url":"https://github.com/Abello966","followers_url":"https://api.github.com/users/Abello966/followers","following_url":"https://api.github.com/users/Abello966/following{/other_user}","gists_url":"https://api.github.com/users/Abello966/gists{/gist_id}","starred_url":"https://api.github.com/users/Abello966/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Abello966/subscriptions","organizations_url":"https://api.github.com/users/Abello966/orgs","repos_url":"https://api.github.com/users/Abello966/repos","events_url":"https://api.github.com/users/Abello966/events{/privacy}","received_events_url":"https://api.github.com/users/Abello966/received_events","type":"User","site_admin":false},"private":false,"html_url":"https://github.com/Abello966/rust-book-pt-br","description":"A Linguagem de Programação Rust","fork":true,"url":"https://api.github.com/repos/Abello966/rust-book-pt-br","forks_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/forks","keys_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/keys{/key_id}","collaborators_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/teams","hooks_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/hooks","issue_events_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/issues/events{/number}","events_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/events","assignees_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/assignees{/user}","branches_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/branches{/branch}","tags_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/tags","blobs_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/git/refs{/sha}","trees_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/git/trees{/sha}","statuses_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/statuses/{sha}","languages_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/languages","stargazers_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/stargazers","contributors_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/contributors","subscribers_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/subscribers","subscription_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/subscription","commits_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/commits{/sha}","git_commits_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/git/commits{/sha}","comments_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/comments{/number}","issue_comment_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/issues/comments{/number}","contents_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/contents/{+path}","compare_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/compare/{base}...{head}","merges_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/merges","archive_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/downloads","issues_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/issues{/number}","pulls_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/pulls{/number}","milestones_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/milestones{/number}","notifications_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/labels{/name}","releases_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/releases{/id}","deployments_url":"https://api.github.com/repos/Abello966/rust-book-pt-br/deployments","created_at":"2018-02-11T13:46:00Z","updated_at":"2018-02-11T13:46:03Z","pushed_at":"2018-02-21T04:27:49Z","git_url":"git://github.com/Abello966/rust-book-pt-br.git","ssh_url":"git@github.com:Abello966/rust-book-pt-br.git","clone_url":"https://github.com/Abello966/rust-book-pt-br.git","svn_url":"https://github.com/Abello966/rust-book-pt-br","homepage":"https://rust-br.github.io/rust-book-pt-br/","size":18177,"stargazers_count":0,"watchers_count":0,"language":"Rust","has_issues":false,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"archived":false,"open_issues_count":0,"license":null,"forks":0,"open_issues":0,"watchers":0,"default_branch":"master"}},"base":{"label":"rust-br:master","ref":"master","sha":"43287b4c7799e3818b68ed4e8b1cc401fba2598a","user":{"login":"rust-br","id":30448826,"avatar_url":"https://avatars3.githubusercontent.com/u/30448826?v=4","gravatar_id":"","url":"https://api.github.com/users/rust-br","html_url":"https://github.com/rust-br","followers_url":"https://api.github.com/users/rust-br/followers","following_url":"https://api.github.com/users/rust-br/following{/other_user}","gists_url":"https://api.github.com/users/rust-br/gists{/gist_id}","starred_url":"https://api.github.com/users/rust-br/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/rust-br/subscriptions","organizations_url":"https://api.github.com/users/rust-br/orgs","repos_url":"https://api.github.com/users/rust-br/repos","events_url":"https://api.github.com/users/rust-br/events{/privacy}","received_events_url":"https://api.github.com/users/rust-br/received_events","type":"Organization","site_admin":false},"repo":{"id":99678900,"name":"rust-book-pt-br","full_name":"rust-br/rust-book-pt-br","owner":{"login":"rust-br","id":30448826,"avatar_url":"https://avatars3.githubusercontent.com/u/30448826?v=4","gravatar_id":"","url":"https://api.github.com/users/rust-br","html_url":"https://github.com/rust-br","followers_url":"https://api.github.com/users/rust-br/followers","following_url":"https://api.github.com/users/rust-br/following{/other_user}","gists_url":"https://api.github.com/users/rust-br/gists{/gist_id}","starred_url":"https://api.github.com/users/rust-br/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/rust-br/subscriptions","organizations_url":"https://api.github.com/users/rust-br/orgs","repos_url":"https://api.github.com/users/rust-br/repos","events_url":"https://api.github.com/users/rust-br/events{/privacy}","received_events_url":"https://api.github.com/users/rust-br/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/rust-br/rust-book-pt-br","description":"A Linguagem de Programação Rust","fork":true,"url":"https://api.github.com/repos/rust-br/rust-book-pt-br","forks_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/forks","keys_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/keys{/key_id}","collaborators_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/teams","hooks_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/hooks","issue_events_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues/events{/number}","events_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/events","assignees_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/assignees{/user}","branches_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/branches{/branch}","tags_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/tags","blobs_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/git/refs{/sha}","trees_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/git/trees{/sha}","statuses_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/statuses/{sha}","languages_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/languages","stargazers_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/stargazers","contributors_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/contributors","subscribers_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/subscribers","subscription_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/subscription","commits_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/commits{/sha}","git_commits_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/git/commits{/sha}","comments_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/comments{/number}","issue_comment_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues/comments{/number}","contents_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/contents/{+path}","compare_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/compare/{base}...{head}","merges_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/merges","archive_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/downloads","issues_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues{/number}","pulls_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls{/number}","milestones_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/milestones{/number}","notifications_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/labels{/name}","releases_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/releases{/id}","deployments_url":"https://api.github.com/repos/rust-br/rust-book-pt-br/deployments","created_at":"2017-08-08T10:06:37Z","updated_at":"2018-03-23T03:25:28Z","pushed_at":"2018-03-22T23:19:13Z","git_url":"git://github.com/rust-br/rust-book-pt-br.git","ssh_url":"git@github.com:rust-br/rust-book-pt-br.git","clone_url":"https://github.com/rust-br/rust-book-pt-br.git","svn_url":"https://github.com/rust-br/rust-book-pt-br","homepage":"https://rust-br.github.io/rust-book-pt-br/","size":18260,"stargazers_count":33,"watchers_count":33,"language":"Rust","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":true,"forks_count":18,"mirror_url":null,"archived":false,"open_issues_count":34,"license":null,"forks":18,"open_issues":34,"watchers":33,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52"},"html":{"href":"https://github.com/rust-br/rust-book-pt-br/pull/52"},"issue":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues/52"},"comments":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/issues/52/comments"},"review_comments":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52/comments"},"review_comment":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/pulls/52/commits"},"statuses":{"href":"https://api.github.com/repos/rust-br/rust-book-pt-br/statuses/aef82b54532056a2186f89ec32e135e973b59199"}},"author_association":"NONE"}}
{"actor":{"display_login":"Milack27"}}