diff options
Diffstat (limited to 'pt-br')
| -rw-r--r-- | pt-br/awk-pt.html.markdown | 4 | ||||
| -rw-r--r-- | pt-br/fsharp-pt.html.markdown | 639 | ||||
| -rw-r--r-- | pt-br/matlab-pt.html.markdown | 2 |
3 files changed, 642 insertions, 3 deletions
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown index 9bf770fd..70d0a01c 100644 --- a/pt-br/awk-pt.html.markdown +++ b/pt-br/awk-pt.html.markdown @@ -317,8 +317,8 @@ a > 0 { # Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK # é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois -imprimirá a média de idade de todos com esse primeiro nome. Digamos que você -forneça como argumento o nome de um arquivo com esses dados: +# imprimirá a média de idade de todos com esse primeiro nome. Digamos que você +# forneça como argumento o nome de um arquivo com esses dados: # Bob Jones 32 # Jane Doe 22 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). diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown index 5ed6b7ba..fae17bca 100644 --- a/pt-br/matlab-pt.html.markdown +++ b/pt-br/matlab-pt.html.markdown @@ -356,7 +356,7 @@ disp(a) % Imprime o valor da variável a disp('Olá Mundo') % Imprime a string fprintf % Imprime na janela de comandos com mais controle -% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática) +% Estruturas Condicionais (os parênteses são opcionais, porém uma boa prática) if (a > 15) disp('Maior que 15') elseif (a == 23) |