Merge pull request #4012 from adelarsq/master

[F#/pt-br] Add translation for F# to Brazilian Portuguese

1 files changed, 639 insertions, 0 deletions

diff --git a/pt-br/fsharp-pt.html.markdown b/pt-br/fsharp-pt.html.markdown
new file mode 100644
index 00000000..55966cda
--- /dev/null
+++ b/pt-br/fsharp-pt.html.markdown
@@ -0,0 +1,639 @@
+---
+language: F#
+filename: learnfsharp-pt.fs
+contributors:
+    - ["Scott Wlaschin", "http://fsharpforfunandprofit.com"]
+    - ["Adelar da Silva Queiróz", "https://adelarsq.github.io"]
+lang: pt-br
+---
+
+F# é uma linguagem de propósito geral funcional e orientada a objetos. É livre, de código aberto e executa em Linux, Mac, Windows e outros.
+
+Possui um sistema de tipagem poderoso que evita muitos erros em tempo de compilação. Para isto utilizando inferência de tipos, o que a faz se comportar como uma linguagem dinâmica.
+
+A sintaxe é diferente das linguagens do estilo C (C, C#, Java, etc):
+
+* Chaves não são usadas para delimitar blocos de código. Ao invés disso é utilizada indentação (semelhante ao Python).
+* Espaços em branco são usados para separar parâmetros, ao invés de vírgulas.
+
+Se você deseja executar o código abaixo, copie e cole em [https://try.fsharp.org](https://try.fsharp.org), que é um REPL online.
+
+```fsharp
+
+// comentários de linhas únicas usam barras duplas
+(* comentários de linhas múltiplas usam o par (* . . . *)
+
+-fim do comentário de linhas múltiplas- *)
+
+// ================================================
+// Sintaxe básica
+// ================================================
+
+// ------ "Variáveis" (mas não exatamente) ------
+// A palavra reservada "let" define um valor imutável
+let myInt = 5
+let myFloat = 3.14
+let myString = "hello"           // note que nenhum tipo é necessário
+
+// ------ Listas ------
+let twoToFive = [2; 3; 4; 5]     // Colchetes criam uma lista com
+                                 // ponto e vírgula como delimitadores
+let oneToFive = 1 :: twoToFive   // :: cria uma lista com um novo primeiro elemento
+// O resultado é [1; 2; 3; 4; 5]
+let zeroToFive = [0; 1] @ twoToFive   // @ concatena duas listas
+
+// IMPORTANTE: vírgulas nunca são usadas como delimitadores, somente ponto e vírgula!
+
+// ------ Funções ------
+// A palavra chave "let" também define nomes para funções.
+let square x = x * x          // Note que não são usados parêntesis
+square 3                      // Agora executando a função. Também sem parêntesis
+
+let add x y = x + y           // Não use add (x,y)! Isto significa algo
+                              // completamente diferente.
+add 2 3                       // Agora execute a função.
+
+// para definir uma função de múltiplas linhas apenas use indentação. Nenhum ponto e vírgula é necessário
+let evens list =
+   let isEven x = x % 2 = 0   // Define "isEven"como uma sub função. Note
+                              // que o operador de igualdade é um simples "=".
+   List.filter isEven list    // List.filter é uma função da biblioteca padrão
+                              // com dois parâmetros: uma função que retorna boolean
+                              // e uma lista para verificar
+
+evens oneToFive               // Agora executando a função
+
+// Usando parênteses é possível deixar mais clara a precedência. Neste exemplo,
+// "map" é usado primeiro, com dois argumentos, então executa "sum" no resultado.
+// Sem os parênteses, "List.map" seria passado como uma argumento para List.sum
+let sumOfSquaresTo100 =
+   List.sum ( List.map square [1..100] )
+
+// É possível redirecionar a saída de uma operação para a próxima usando pipe ("|>")
+// Redirecimento de dados é algo comum em F#, similar a pipes Unix.
+
+// Aqui é a mesma função sumOfSquares escrita com pipe
+let sumOfSquaresTo100piped =
+   [1..100] |> List.map square |> List.sum  // "square" foi definido anteriormente
+
+// você pode definir lambdas (funções anônimas) usando a palavra reservada "fun"
+let sumOfSquaresTo100withFun =
+   [1..100] |> List.map (fun x -> x * x) |> List.sum
+
+// Em F# não há a palavra chave "return". Funções sempre
+// retornam o valor da última expressão usada.
+
+// ------ Casamento de padrões (Pattern Matching) ------
+// Match..with.. é um poderoso case/switch.
+let simplePatternMatch =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x is a"
+    | "b" -> printfn "x is b"
+    | _ -> printfn "x is something else"   // sublinhado combina com qualquer coisa
+
+// F# não permite null por padrão -- deve-se usar um Option
+// e então efetuar um casamento de padrão.
+// Some(..) e None são análogos a Nullable
+let validValue = Some(99)
+let invalidValue = None
+
+// Neste exemplo, match..with casa com "Some" e "None",
+// e também desconstrói o valor em "Some" ao mesmo tempo.
+let optionPatternMatch input =
+   match input with
+    | Some i -> printfn "input is an int=%d" i
+    | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Escrevando na tela ------
+// As funções printf/printfn são similares às
+// Console.Write/WriteLine encontradas no C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
+
+// Exitem também as funções sprintf/sprintfn para formatação de dados
+// em uma string, semelhante à String.Format do C#.
+
+// ================================================
+// Mais sobre funções
+// ================================================
+
+// F# é uma liguagem verdadeiramente funcional -- funções fazem
+// parte das classes e podem ser combinadas facilmente para criar
+// poderosos construtores
+
+// Módulos podem usar um grupo de funções
+// É necessário usar indentação para defini-las.
+module FunctionExamples =
+
+    // define uma função de soma
+    let add x y = x + y
+
+    // básico uso de uma função
+    let a = add 1 2
+    printfn "1 + 2 = %i" a
+
+    // aplicação parcial de parâmetros
+    let add42 = add 42
+    let b = add42 1
+    printfn "42 + 1 = %i" b
+
+    // composição para combinar funções
+    let add1 = add 1
+    let add2 = add 2
+    let add3 = add1 >> add2
+    let c = add3 7
+    printfn "3 + 7 = %i" c
+
+    // funções de alta ordem
+    [1..10] |> List.map add3 |> printfn "new list is %A"
+
+    // listas de funções e mais
+    let add6 = [add1; add2; add3] |> List.reduce (>>)
+    let d = add6 7
+    printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Listas e coleções
+// ================================================
+
+// Existem três tipos de coleções ordenadas:
+// * Listas são o tipo mais básico de coleção imutável;
+// * Arrays são mutáveis e mais eficientes;
+// * Sequences são lazy e infinitas (semelhante a enumerator).
+//
+// Outras coleções incluem maps e conjuntos imutáveis
+// mais todas as coleções padrões do .NET
+
+module ListExamples =
+
+    // listas usam colchetes
+    let list1 = ["a"; "b"]
+    let list2 = "c" :: list1    // :: é usado para adicionar um elemento no início da lista
+    let list3 = list1 @ list2   // @ é o operador de concatenação
+
+    // list comprehensions (generators)
+    let squares = [for i in 1..10 do yield i * i]
+
+    // Um gerador de números primos
+    // - este usa a notação custa para casamento de padrões
+    // - (p::xs) significa 'primeiro :: cauda' da lista, e pode ser escrito como p :: xs
+    //   isto significa que casa 'p' (o primeiro item da lista), e xs recebe o resto da lista
+    //   que é chamdo de 'cons pattern'
+    // - usa a palavra chave 'rec', que é necessária quando se usa recursão
+    let rec sieve = function
+        | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primes = sieve [2..50]
+    printfn "%A" primes
+
+    // casamento de padrões (pattern matching) com listas
+    let listMatcher aList =
+        match aList with
+        | [] -> printfn "the list is empty"
+        | [first] -> printfn "the list has one element %A " first
+        | [first; second] -> printfn "list is %A and %A" first second
+        | first :: _ -> printfn "the list has more than two elements, first element %A" first
+
+    listMatcher [1; 2; 3; 4]
+    listMatcher [1; 2]
+    listMatcher [1]
+    listMatcher []
+
+    // recursão usando listas
+    let rec sum aList =
+        match aList with
+        | [] -> 0
+        | x::xs -> x + sum xs
+    sum [1..10]
+
+    // -----------------------------------------
+    // Funções da biblioteca padrão
+    // -----------------------------------------
+
+    // mapas
+    let add3 x = x + 3
+    [1..10] |> List.map add3
+
+    // filtros
+    let even x = x % 2 = 0
+    [1..10] |> List.filter even
+
+    // muito mais -- veja a documentação
+
+module ArrayExamples =
+
+    // arrays usam colchetes com barra vertical
+    let array1 = [| "a"; "b" |]
+    let first = array1.[0]        // acesso por índice usando ponto
+
+    // casamento de padrões (pattern matching) para arrays é feito da mesma forma que de listas
+    let arrayMatcher aList =
+        match aList with
+        | [| |] -> printfn "the array is empty"
+        | [| first |] -> printfn "the array has one element %A " first
+        | [| first; second |] -> printfn "array is %A and %A" first second
+        | _ -> printfn "the array has more than two elements"
+
+    arrayMatcher [| 1; 2; 3; 4 |]
+
+    // As funções da biblioteca padrão são as mesmas que para List
+
+    [| 1..10 |]
+    |> Array.map (fun i -> i + 3)
+    |> Array.filter (fun i -> i % 2 = 0)
+    |> Array.iter (printfn "value is %i. ")
+
+
+module SequenceExamples =
+
+    // sequências usam chaves
+    let seq1 = seq { yield "a"; yield "b" }
+
+    // sequências podem usar yield e
+    // podem conter subsequencias
+    let strange = seq {
+        // "yield" adiciona um elemento
+        yield 1; yield 2;
+
+        // "yield!" adiciona uma subsequencia
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i % 2 = 0 then yield i }}
+    // teste
+    strange |> Seq.toList
+
+    // Sequências podem ser criadas usando "unfold"
+    // Este é um exemplo da série de Fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // teste
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "first 10 fibs are %A" fib10
+
+
+// ================================================
+// Tipos de dados
+// ================================================
+
+module DataTypeExamples =
+
+    // Todos os dados são imutáveis por padrão
+
+    // Tuplas são uma forma rápida de reprentar n elementos de tipos anônimos
+    // -- Use a vírgula para criar uma tupla
+    let twoTuple = 1, 2
+    let threeTuple = "a", 2, true
+
+    // Casamento de padrões (pattern match) para desconstruir
+    let x, y = twoTuple  // atribui x = 1, y = 2
+
+    // ------------------------------------
+    // O tipo registro possui nomes nos campos
+    // ------------------------------------
+
+    // Use "type" com chaves para definir um registro
+    type Person = {First:string; Last:string}
+
+    // Use "let" com chaves para criar um registro
+    let person1 = {First="John"; Last="Doe"}
+
+    // Casamento de padrões para desconstruir
+    let {First = first} = person1    // atribui first="John"
+
+    // ------------------------------------
+    // Tipos union (variantes) possuem um conjunto de escolhas
+    // Somente um caso pode ser válido por vez.
+    // ------------------------------------
+
+    // Use "type" com barra/pipe para definir um union
+    type Temp =
+        | DegreesC of float
+        | DegreesF of float
+
+    // Use qualquer dos tipos para criar um
+    let temp1 = DegreesF 98.6
+    let temp2 = DegreesC 37.0
+
+    // Casamento de padrões deve cobrir todos os tipos de definidos para desconstruir
+    let printTemp = function
+       | DegreesC t -> printfn "%f degC" t
+       | DegreesF t -> printfn "%f degF" t
+
+    printTemp temp1
+    printTemp temp2
+
+    // ------------------------------------
+    // Tipos recursivos
+    // ------------------------------------
+
+    // Tipos podem ser combinados recursivamente de formas complexas
+    // sem ter que criar subclasses
+    type Employee =
+      | Worker of Person
+      | Manager of Employee list
+
+    let jdoe = {First="John"; Last="Doe"}
+    let worker = Worker jdoe
+
+    // ------------------------------------
+    // Modelando com tipos
+    // ------------------------------------
+
+    // Tipos union são muito bons para modelagem de estados sem usar flags
+    type EmailAddress =
+        | ValidEmailAddress of string
+        | InvalidEmailAddress of string
+
+    let trySendEmail email =
+        match email with // casamento de padrões
+        | ValidEmailAddress address -> ()   // envia
+        | InvalidEmailAddress address -> () // não envia
+
+    // A combinação de tipos union e registros juntos
+    // provê uma grande fundação para DDD (Domain Driven Design).
+    // Você pode criar centenas de pequenos tipos que refletem
+    // exatamente o seu domínio.
+
+    type CartItem = { ProductCode: string; Qty: int }
+    type Payment = Payment of float
+    type ActiveCartData = { UnpaidItems: CartItem list }
+    type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+    type ShoppingCart =
+        | EmptyCart  // nenhum dado
+        | ActiveCart of ActiveCartData
+        | PaidCart of PaidCartData
+
+    // ------------------------------------
+    // Comportamento padrão para tipos
+    // ------------------------------------
+
+    // Tipos padrões possuem um padrão já definido, não precisando de codificação nenhuma.
+    // * Imutáveis
+    // * Impressão formatada para depuração
+    // * Igualdade e comparação
+    // * Serialização
+
+    // Impressão formatada usando %A
+    printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+             twoTuple person1 temp1 worker
+
+    // Igualdade e comparação padrão.
+    // Um exemplo com cartas:
+    type Suit = Club | Diamond | Spade | Heart
+    type Rank = Two | Three | Four | Five | Six | Seven | Eight
+                | Nine | Ten | Jack | Queen | King | Ace
+
+    let hand = [ Club, Ace; Heart, Three; Heart, Ace;
+                 Spade, Jack; Diamond, Two; Diamond, Ace ]
+
+    // ordenando
+    List.sort hand |> printfn "sorted hand is (low to high) %A"
+    List.max hand |> printfn "high card is %A"
+    List.min hand |> printfn "low card is %A"
+
+
+// ================================================
+// Padrões ativos (Active patterns)
+// ================================================
+
+module ActivePatternExamples =
+
+    // F# possui um tipo especial de casamento de padrões chamado "padrões ativos" ("active patterns")
+    // onde o padrão pode ser interpretado ou detectado dinamicamente.
+
+    // parêntesis e barra são a sintaxe para "padrões ativos"
+
+    // Você pode usar "elif" ao invés de "else if" em expressões condicionais.
+    // Elas são equivalentes em F#
+
+    // por exemplo, defina um "padrão ativo" para tratar tipos de caracteres...
+    let (|Digit|Letter|Whitespace|Other|) ch =
+       if System.Char.IsDigit(ch) then Digit
+       elif System.Char.IsLetter(ch) then Letter
+       elif System.Char.IsWhiteSpace(ch) then Whitespace
+       else Other
+
+    // ... e então use ele para interpretar de forma bem mais simples
+    let printChar ch =
+      match ch with
+      | Digit -> printfn "%c is a Digit" ch
+      | Letter -> printfn "%c is a Letter" ch
+      | Whitespace -> printfn "%c is a Whitespace" ch
+      | _ -> printfn "%c is something else" ch
+
+    // imprima a lista
+    ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
+
+    // ------------------------------------------------
+    // FizzBuzz usando padrões ativos (active patterns)
+    // ------------------------------------------------
+
+    // É possível criar casamento de padrões parcial também
+    // Apenas use sublinhado para a definição, e retorne Some se casado.
+    let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+    let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+    // a função principal
+    let fizzBuzz i =
+      match i with
+      | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+      | MultOf3 -> printf "Fizz, "
+      | MultOf5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // teste
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Expressividade
+// ================================================
+
+module AlgorithmExamples =
+
+    // F# possui uma alta razão sinais/ruídos, assim o código
+    // é lido praticamento como se descreve o algoritmo
+
+    // ------ Exemplo: defina uma função que faça soma dos quadrados ------
+    let sumOfSquares n =
+       [1..n]              // 1) pega todos os números de 1 a n
+       |> List.map square  // 2) eleva ao quadrado cada um
+       |> List.sum         // 3) soma os resultados
+
+    // teste
+    sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+    // ------ Examplo: defina uma função de ordenação ------
+    let rec sort list =
+       match list with
+       // Se a lista está vazia
+       | [] ->
+            []                            // retorna a lista vazia
+       // Se a lista não está vazia
+       | firstElem::otherElements ->      // pega o primeiro elemento
+            let smallerElements =         // extrai os elementos menores
+                otherElements             // dos restantes
+                |> List.filter (fun e -> e < firstElem)
+                |> sort                   // e ordena eles
+            let largerElements =          // extrai os elementos maiores
+                otherElements             // dos restantes
+                |> List.filter (fun e -> e >= firstElem)
+                |> sort                   // e ordena eles
+            // Combine as 3 partes em uma nova lista e retorne ela
+            List.concat [smallerElements; [firstElem]; largerElements]
+
+    // teste
+    sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
+
+// ================================================
+// Código assíncrono
+// ================================================
+
+module AsyncExample =
+
+    // F# possui suporte a funcionalidades para ajudar a escrever código assíncrono
+    // sem tornar o código difícil de manter ("pyramid of doom")
+    //
+    // O seguinte exemplo efetua download de um conjunto de páginas em paralelo.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Obtém o conteúdo de cara página de forma assíncrona
+    let fetchUrlAsync url =
+        async {   // a palavra chave "async" e chaves
+                  // criam um objeto assíncrono
+            let req = WebRequest.Create(Uri(url))
+            use! resp = req.AsyncGetResponse()
+                // use! é uma atribuição assíncrona
+            use stream = resp.GetResponseStream()
+                // "use" dispara automaticamente close()
+                // no recurso no fim do escopo
+            use reader = new IO.StreamReader(stream)
+            let html = reader.ReadToEnd()
+            printfn "finished downloading %s" url
+            }
+
+    // uma lista de sites para fazer download
+    let sites = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // efetue
+    sites
+    |> List.map fetchUrlAsync  // cria uma lista de tarefas assíncronas
+    |> Async.Parallel          // coloca as tarefas para executarem em paralelo
+    |> Async.RunSynchronously  // inicia cada uma
+
+// ================================================
+// Compatibilidade com .NET
+// ================================================
+
+module NetCompatibilityExamples =
+
+    // F# pode pode fazer praticamente tudo que C# pode fazer, e integra
+    // de forma simples com bibliotecas .NET e Mono
+
+    // ------- usando uma função de uma biblioteca existente -------
+
+    let (i1success, i1) = System.Int32.TryParse("123");
+    if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+    // ------- Implementando interfaces de forma simples! -------
+
+    // cria um novo objeto que implementa IDisposable
+    let makeResource name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s disposed" name }
+
+    let useAndDisposeResources =
+        use r1 = makeResource "first resource"
+        printfn "using first resource"
+        for i in [1..3] do
+            let resourceName = sprintf "\tinner resource %d" i
+            use temp = makeResource resourceName
+            printfn "\tdo something with %s" resourceName
+        use r2 = makeResource "second resource"
+        printfn "using second resource"
+        printfn "done."
+
+    // ------- Código orientado a objetos -------
+
+    // F# também possui suporte a orientação a objetos.
+    // Possui suporte a classes, herança, métodos virtuais, etc.
+
+    // interface com tipo genérico
+    type IEnumerator<'a> =
+        abstract member Current : 'a
+        abstract MoveNext : unit -> bool
+
+    // classe base abstrata com métodos virtuais
+    [<AbstractClass>]
+    type Shape() =
+        // propriedades somente leitura
+        abstract member Width : int with get
+        abstract member Height : int with get
+        // método não virtual
+        member this.BoundingArea = this.Height * this.Width
+        // método virtual com implementação base
+        abstract member Print : unit -> unit
+        default this.Print () = printfn "I'm a shape"
+
+    // classe concreta que herda da classe base e sobrescreve
+    type Rectangle(x:int, y:int) =
+        inherit Shape()
+        override this.Width = x
+        override this.Height = y
+        override this.Print ()  = printfn "I'm a Rectangle"
+
+    // testes
+    let r = Rectangle(2, 3)
+    printfn "The width is %i" r.Width
+    printfn "The area is %i" r.BoundingArea
+    r.Print()
+
+    // ------- métodos de extensão -------
+
+    // Assim como em C#, F# pode extender classes já existentes com métodos de extensão.
+    type System.String with
+       member this.StartsWithA = this.StartsWith "A"
+
+    // testes
+    let s = "Alice"
+    printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+    // ------- eventos  -------
+
+    type MyButton() =
+        let clickEvent = new Event<_>()
+
+        [<CLIEvent>]
+        member this.OnClick = clickEvent.Publish
+
+        member this.TestEvent(arg) =
+            clickEvent.Trigger(this, arg)
+
+    // teste
+    let myButton = new MyButton()
+    myButton.OnClick.Add(fun (sender, arg) ->
+            printfn "Click event with arg=%O" arg)
+
+    myButton.TestEvent("Hello World!")
+
+```
+
+## Mais Informações
+
+Para mais demonstrações de F# acesse [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Leia mais sobre F# em [fsharp.org](http://fsharp.org/) e [dotnet's F# page](https://dotnet.microsoft.com/languages/fsharp).