<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Marcos Benevides on Medium]]></title>
        <description><![CDATA[Stories by Marcos Benevides on Medium]]></description>
        <link>https://medium.com/@marcos.schonfinkel?source=rss-38491a775fa2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*AGnlS2rgxNTpay-PUDCiLQ.png</url>
            <title>Stories by Marcos Benevides on Medium</title>
            <link>https://medium.com/@marcos.schonfinkel?source=rss-38491a775fa2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 19:28:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marcos.schonfinkel/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Primeiros passos com Haskell: Parte 1]]></title>
            <link>https://medium.com/lambda-ma/primeiros-passos-com-haskell-parte-1-5ccabd1e6781?source=rss-38491a775fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ccabd1e6781</guid>
            <category><![CDATA[functional-programming]]></category>
            <category><![CDATA[haskell]]></category>
            <dc:creator><![CDATA[Marcos Benevides]]></dc:creator>
            <pubDate>Fri, 29 Dec 2017 10:26:02 GMT</pubDate>
            <atom:updated>2017-12-29T10:26:02.207Z</atom:updated>
            <content:encoded><![CDATA[<p>Listando os tipos básicos, usando o GHCi e entendo Currying</p><h3>Tipos básicos em Haskell</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/435/1*h715PvC_MLo-talWcrBRhQ.png" /><figcaption>“He who controls the types, controls the universe!”</figcaption></figure><h4>Bool — Valores lógicos:</h4><ul><li>True</li><li>False</li></ul><h4>Char — Caracteres</h4><p>Esse tipo contém todos os caracteres unitários no sistema Unicode. Por exemplo, os caracteres usuais como ‘a’, ‘b’, ‘A’, ‘B’, ‘_’ ou até mesmo caracteres especiais como ‘\t’ ou ‘\n’.</p><h4>String — Strings de caracteres</h4><p>O tipo string contém todas as sequências de caracteres unitários, incluindo a String vazia.</p><h4>Int — Inteiros de precisão fixa</h4><p>Contém inteiros com um tamanho fixo na memória, como os números entre -2⁶³ e 2⁶³ -1.</p><h4>Integer — Inteiros com precisão arbitrária</h4><p>Esse tipo contém todos os números inteiros, contanto que seu computador consiga armazená-los na memória.</p><p>Para notarmos a diferença entre Int e Integer podemos usar a versão iterativa do GHC, o glorioso compilador do Haskell. Dentro do diretório do seu projeto digite:</p><pre>stack exec ghci </pre><p>Este comando iniciará o GHCi. Podemos então chegar a diferença entre Ints e Integers:</p><pre>Prelude&gt; 2^63 :: Int<br>-9223372036854775808</pre><p>Gera um overflow, pois Ints possuem uma quantidade fixa de memória. Agora vamos testar o mesmo valor como Integer.</p><pre>Prelude&gt; 2^63 :: Integer<br>9223372036854775808</pre><p>Que é o valor real de 2⁶³.</p><h4>Float — Float usual</h4><p>Números com casas decimais, e uma quantidade fixa de memória para armazenamento.</p><h4>Double — Double usual</h4><p>Semelhantes aos Floats, mas com o dobro de memória e maior precisão que os Floats.</p><h4>List — Sequências de elementos de um mesmo tipo</h4><p>Sim! Listas são um tipo em Haskell, se uma lista possui elementos to tipo <strong>T</strong>, uma lista de <strong>T</strong>’s possui tipo <strong>[T]</strong>. Fazendo alguns testes no GHCi.</p><pre>Prelude&gt; :t [True, True, False]<br>[True, True, False] :: [Bool]<br>Prelude&gt; :t [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]<br>[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;] :: [Char]<br>Prelude&gt; :t [&quot;AAAAAAA&quot;, &quot;BBBBBBBBB&quot;, &quot;CCCCCCCCCCC&quot;]<br>[&quot;AAAAAAA&quot;, &quot;BBBBBBBBB&quot;, &quot;CCCCCCCCCCC&quot;] :: [[Char]]</pre><p>O comando :t no GHCi nos devolve o tipo de um valor. Note que:</p><pre>Prelude&gt; :t &quot;AAAAAAA&quot;<br>&quot;AAAAAAA&quot; :: [Char]</pre><p>Strings são listas de Chars.</p><h4>Tuplas</h4><p>Tuplas são semelhantes a listas, mas tem tamanho constante e podem conter tipos arbitrários.</p><pre>GHCi, version 8.0.2: <a href="http://www.haskell.org/ghc/">http://www.haskell.org/ghc/</a>  :? for help<br>Prelude&gt; :t (True, True, False)<br>(True, True, False) :: (Bool, Bool, Bool)<br>Prelude&gt; :t (True, &#39;A&#39;, &quot;String&quot;)<br>(True, &#39;A&#39;, &quot;String&quot;) :: (Bool, Char, [Char])<br>Prelude&gt; :t (True)<br>(True) :: Bool<br>Prelude&gt; :t (&#39;A&#39;, True, &#39;B&#39;, False, &#39;C&#39;)<br>(&#39;A&#39;, True, &#39;B&#39;, False, &#39;C&#39;) :: (Char, Bool, Char, Bool, Char)</pre><p>Note que, ao contrário das listas, os tipos de uma tupla são os tipos de cada elemento, pois estes podem ter tipos distintos.</p><h4>Tipos de funções</h4><p>Funções também possuem tipos e são denotados usando o símbolo ‘→’. Por exemplo: o tipo <strong>Bool → Bool</strong> contém todas as funções que mapeiam argumentos <strong>Bool</strong> para resultados <strong>Bool.</strong></p><ul><li>A função not(negação) possui tipo <strong>Bool → Bool</strong>. <br>Ou seja, <strong>not :: Bool → Bool.</strong></li><li>A função isDigit (que checa se um Char é um digito de 0–9) possui tipo <strong>Char → Bool</strong>. <br>Ou seja, <strong>isDigit :: Char → Bool.</strong></li></ul><pre>Prelude&gt; import Data.Char<br>Prelude Data.Char&gt; isDigit &#39;a&#39;<br>False<br>Prelude Data.Char&gt; :t isDigit<br>isDigit :: Char -&gt; Bool<br>Prelude&gt; even 2<br>True<br>Prelude&gt; even 4<br>True<br>Prelude&gt; even 3<br>False<br>Prelude&gt; :t even<br>even :: Integral a =&gt; a -&gt; Bool<br>Prelude&gt;</pre><h3>Funções parciais e Currying</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/268/1*QB8MVARp4zzkJ-UJ71Fd9Q.jpeg" /><figcaption>Haskell Curry</figcaption></figure><p>Por enquanto nós vimos apenas tipos de funções com apenas um argumento. Podemos usar tuplas para representar funções com vários argumentos, por exemplo:</p><pre>add :: (Int, Int) -&gt; Int<br>add (x,y) = x + y</pre><p>é uma função que toma dois argumentos (x,y) e retorna a soma desses argumentos (x+y), ela possui tipo (Int, Int) -&gt; Int .</p><p>Contudo, você raramente verá funções sendo definidas desta maneira, pois na verdade toda função em Haskell <strong>oficialmente </strong>toma apenas 1 parâmetro, (Int, Int) continua sendo 1 argumento, só que forma de tuplas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/1*Yi9h6-OWw5rOS2d_w2jlgA.jpeg" /><figcaption>Mas então comofas pra representar tipos de funções com mais de 1 argumento?</figcaption></figure><p>Se você não consegue aguentar a verdade então recomendamos que pare de ler este tutorial agora, entenderemos que usar parênteses e vírgulas é uma mentira propagada por grandes corporações, essas empresas malignas se beneficiam dos seus erros de sintaxe e de seu tempo perdido. Tudo isso é desnecessário quando se conhece o Currying:</p><blockquote>Currying é o processo de transformação de uma função que toma múltiplos argumentos numa função que toma um argumento e retorna outra função se mais argumentos são necessários.<a href="https://wiki.haskell.org/Currying"> [ref]</a></blockquote><p>Traduzindo, funções de vários argumentos são apenas composições de funções mais simples, todas possuindo apenas 1 argumento e aplicadas de forma parcial.</p><p>Para entender melhor o que são funções parciais vamos observar a função max:</p><pre>GHCi, version 8.0.2: <a href="http://www.haskell.org/ghc/">http://www.haskell.org/ghc/</a>  :? for help<br>Prelude&gt; max 4 5<br>5<br>Prelude&gt; (max 4) 5<br>5<br>Prelude&gt;</pre><p>No exemplo anterior podemos pensar na função (max 4)como max(4, x) , onde x é como se fosse um argumento que ainda não foi informado, (max 4) 5 é max(4,x) aplicando x=5 . Essa função, portanto retorna 5, que é o máximo entre 4 e 5. Ou seja, apesar de max possuir 2 argumentos, podemos aplicá-la em apenas 1 argumento, é por isso que max é dita ser parcial, pois não precisamos informar todos os seus argumentos (caso contrário ela seria total).</p><p>As outras funções básicas da aritmética também são parciais!!</p><pre>Prelude&gt; (+1) 2<br>3<br>Prelude&gt; (+1) 10<br>11<br>Prelude&gt; (+1) 11<br>12<br>Prelude&gt; (*2) 2<br>4<br>Prelude&gt; (/2) 1<br>0.5<br>Prelude&gt; (^2) 2<br>4<br>Prelude&gt; (^2) 3<br>9<br>Prelude&gt;</pre><p>Você também pode inverter o argumento que está sendo aplicado de forma parcial, aqui por exemplo estamos computando 3², 3³, 3⁴, 3⁵, 3⁶ de forma parcial:</p><pre>Prelude&gt; (3^) 2<br>9<br>Prelude&gt; (3^) 3<br>27<br>Prelude&gt; (3^) 4<br>81<br>Prelude&gt; (3^) 5<br>243<br>Prelude&gt; (3^) 6<br>729<br>Prelude&gt;</pre><p>Voltando para a função add definida acima e agora finalmente modificando nossa Main.hs de forma a reescrevê-la como uma função parcial.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/d0cd9914d80e398f3a903b8a4fc8f31d/href">https://medium.com/media/d0cd9914d80e398f3a903b8a4fc8f31d/href</a></iframe><p>As diferenças são:</p><ul><li>Linha 3: Tipagem diferente, agora temos uma função que recebe um Inteiro (Int) e retorna uma função que recebe um Inteiro e retorna um Inteiro (Int -&gt; Int). Toda vez que escrevemos um tipo entre parênteses estamos deixando de forma explícita que ele é uma função.</li><li>Linha 4: Não é mais necessário colocar x e y como tuplas.</li><li>Linha 9: Não é mais necessário usar parênteses ou vírgulas quando se chama a função.</li></ul><p>Compilando o programa e executando:</p><pre>stack build<br>stack exec proj1</pre><p>temos como output:</p><pre>hello world<br>20</pre><p>Para investigar melhor nossa função carregaremos nossa Main no GHCi.</p><pre>stack exec ghci</pre><pre>Prelude&gt; :l src/Main.hs <br>[1 of 1] Compiling Main             ( src/Main.hs, interpreted )<br>Ok, modules loaded: Main.<br>*Main&gt; :t add<br>add :: Int -&gt; Int -&gt; Int<br>*Main&gt;</pre><p>A primeira diferença é que nosso tipo veio sem parênteses, isso é normal pois os parênteses que colocamos antes são opcionais. Agora vamos testar se nossa função é realmente parcial:</p><pre>*Main&gt; let add_parcial = add 10<br>*Main&gt; add_parcial 1<br>11<br>*Main&gt; add_parcial 2<br>12<br>*Main&gt; add_parcial 3<br>13<br>*Main&gt; add_parcial 10<br>20<br>*Main&gt;</pre><p>Conseguimos aplicar add em apenas 1 argumento, e depois usar o resultado (uma função) nos valores 1,2,3 e 10.</p><p>Obs: Se você tentar usar add de forma diferente na versão iterativa pode acabar encontrando esse erro</p><pre>*Main&gt; add 10</pre><pre>&lt;interactive&gt;:21:1: error:<br>    • No instance for (Show (Int -&gt; Int)) arising from a use of ‘print’<br>        (maybe you haven&#39;t applied a function to enough arguments?)<br>    • In a stmt of an interactive GHCi command: print it</pre><p>Isso não significa que existe algo de errado na sua função, mas que ela ainda não é printável! Falaremos mais sobre o Show no próximo tutorial.</p><p>Fique ligado no próximo tutorial (Parte 2), que falará sobre Polimorfismo e Typeclasses.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ccabd1e6781" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lambda-ma/primeiros-passos-com-haskell-parte-1-5ccabd1e6781">Primeiros passos com Haskell: Parte 1</a> was originally published in <a href="https://medium.com/lambda-ma">lambda-MA</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Primeiros passos com Haskell: Parte 0]]></title>
            <link>https://medium.com/lambda-ma/primeiros-passos-com-haskell-parte-0-61c7f2f16892?source=rss-38491a775fa2------2</link>
            <guid isPermaLink="false">https://medium.com/p/61c7f2f16892</guid>
            <category><![CDATA[haskell]]></category>
            <category><![CDATA[functional-programming]]></category>
            <dc:creator><![CDATA[Marcos Benevides]]></dc:creator>
            <pubDate>Sat, 16 Dec 2017 02:41:46 GMT</pubDate>
            <atom:updated>2017-12-16T02:41:46.878Z</atom:updated>
            <content:encoded><![CDATA[<p>Como aprender Haskell e manter parte da sanidade. Setando um ambiente com Stack.</p><h3>Por que aprender o paradigma funcional?</h3><ul><li>Conceitos como dados imutáveis e funções puras</li><li>Justificativas pra ser preguiçoso</li><li>Paralelismo e Concorrência</li><li>Por que é legal pra caramba e vai te fazer pensar de forma diferente.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/479/1*rdZnqzIVC3r25ucm2NcKMw.jpeg" /><figcaption>Você enquanto programa de forma funcional.</figcaption></figure><h3>Setando um ambiente para programar em Haskell</h3><h4>Stack</h4><p><strong>Obs:</strong> Pros entusiastas do docker, existe uma imagem oficial no <a href="https://hub.docker.com/_/haskell/">dockerhub</a>.</p><p>O primeiro passo é instalar o <a href="https://docs.haskellstack.org/en/stable/install_and_upgrade/">stack</a>, uma ferramenta multiplataforma para desenvolver aplicações Haskell. Depois de concluir as instruções de instalação o stack já deve ter sido adicionado ao seu PATH.</p><p>Então dentro de um diretório escolhido digite no terminal.</p><pre>stack new proj1 simple</pre><p>onde:</p><ul><li><strong>proj1</strong>: é o nome do seu projeto</li><li><strong>simple</strong>: é o nome do template usado para o projeto. Você escolher ver outros templates digitando:</li></ul><pre>stack templates</pre><p>Como resultado será criado um diretório “proj1” com seguinte estrutura:</p><pre>.<br>├── proj1                   # Nome do projeto<br>│   ├── LICENSE             # Licença<br>│   ├── proj1.cabal         # Metadados e infos. pra build<br>│   ├── README.md           # README<br>│   ├── Setup.hs            # Script para build<br>│   └── src                 # Código fonte do projeto<br>│       └── Main.hs         # Arquivo Main<br>└──</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7cc3cdef5e5ec7123c0855e197445f4c/href">https://medium.com/media/7cc3cdef5e5ec7123c0855e197445f4c/href</a></iframe><p>Seu “Hello World!” já foi escrito pra você! Tem coisa mais fácil?</p><p>Só por curiosidade, que tal abrir o arquivo “proj1.cabal” e ver o que ele contém? Agora faça algumas modificações:</p><pre>name:                proj1<br>version:             0.1.0.0<br>-- synopsis:         Exemplo de projeto em Haskell<br>-- description:      Meu primeiro projeto em Haskell<br>homepage:            <a href="https://github.com/githubuser/proj1#readme">https://github.com/githubuser/proj1#readme</a><br>license:             MIT<br>license-file:        LICENSE<br>author:              Seu Nome<br>maintainer:          <a href="/service/mailto:seu.email@email.com">seu.email@email.com</a><br>copyright:           2017 Seu Nome<br>category:            Web<br>build-type:          Simple<br>cabal-version:       &gt;=1.10<br>extra-source-files:  README.md</pre><pre>executable proj1<br>  ghc-options          -Wall<br>  hs-source-dirs:      src<br>  main-is:             Main.hs<br>  default-language:    Haskell2010<br>  build-depends:       base &gt;= 4.7 &amp;&amp; &lt; 5</pre><p>Descrição de algumas opções:</p><ul><li>name será o nome do executável, no nosso caso proj1.</li><li>ghc-options são flags para o compilador GHC, utilizamos apenas o -Wall para que todos os warnings sejam mostrados.</li><li>hs-source-dirs inclui o src , dessa forma o Cabal sabe onde seus módulos estão localizados.</li><li>main-is descreve o nome do seu arquivo main, no nosso caso é Main.hs, todo projeto deve conter uma main. Note que para que um módulo funcione como main-is ele deve definir uma função main dentro dele.</li><li>default-language é o padrão da linguagem, estamos usando a versão 2010 do Haskell, que é a atual.</li><li>build-depends são as dependências do seu projeto, por enquanto estamos usando apenas a biblioteca padrão(<a href="https://hackage.haskell.org/package/base">Base</a>) do Haskell.</li></ul><h4>Instalando o GHC:</h4><ul><li>O comando setup determina qual versão do compilador deva ser usada e faz o download dessa versão se for necessário.</li></ul><p>O Stack instalará a versão correta do GHC(Glorious Haskell Compiler)⭐ para o nosso projeto. Isso é legal porque todos que trabalham no seu projeto estarão na mesma versão.</p><pre>stack setup</pre><p>Se for sua primeira vez ou se seu projeto não estiver com o GHC instalado essa parte demorará um pouco.</p><p>⭐ Também conhecido como Glasgow Haskell Compiler.</p><h4>Compilando o projeto</h4><ul><li>O comando build compila sua biblioteca.</li><li>Ele também cria os arquivos executáveis abaixo do diretório .stack-job específico do projeto.</li></ul><pre>stack build</pre><h4>Executando</h4><ul><li>Podemos usar o comando exec para rodar um executável. Como o projeto pode possuir mais de um é necessário sempre especificar qual.</li></ul><p>Se esses comandos deram certo, então você já deve possuir um arquivo executável ‘proj1’⭐.</p><pre>stack exec proj1</pre><p>Que terá como output seu “hello world!”.</p><p>⭐ Faça o você do futuro feliz e evite dar nomes genéricos como “projeto1”!</p><h4>Recompilando o projeto</h4><p>Agora vamos modificar o código e tentar recompilá-lo. Por enquanto temos apenas um arquivo .hs, que é a nossa main. Vamos primeiro analisar nosso código atual:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/13a5d2ed182ed40286982c2b7a398d11/href">https://medium.com/media/13a5d2ed182ed40286982c2b7a398d11/href</a></iframe><p>Um módulo em Haskell é uma coleção de funções relacionadas, tipos e typeclasses. Um programa em Haskell é uma coleção de módulos, onde o módulo main carrega os outros módulos e as utiliza de alguma forma.</p><p>Separar nosso código em módulos traz várias vantagens, se nossos módulos forem genéricos o suficiente podemos simplesmente reaproveitá-los em outros projetos diferentes. Nosso programa possui apenas um módulo, a própria main.</p><p>Agora que estamos com um ambiente setado podemos começar a fazer alguns programas em Haskell!!</p><p>Fique atento ao próximo tutorial!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61c7f2f16892" width="1" height="1" alt=""><hr><p><a href="https://medium.com/lambda-ma/primeiros-passos-com-haskell-parte-0-61c7f2f16892">Primeiros passos com Haskell: Parte 0</a> was originally published in <a href="https://medium.com/lambda-ma">lambda-MA</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>