[Haskell Aula 00] Prelude

[VictorCacciari 42]

Aula 0

Ou, falando em haskell, um "prelude" sobre a linguagem.

 

Nossas ferramentas

Vamos utilizar o GHCi.

Uma ferramenta que interpreta código escrito em haskell.

tornando muito fácil a parte de testar código.

 

Download

http://haskell.org/ghc/download_ghc_6_12_1.html

 

Para utilizar o GHCi é muito fácil!

Baixem e instalem... aprenderemos como utilizar no caminho.

 

Haskell

Haskell é uma linguagem funcional, não é muito utilizada fora do ambiente acadêmico.

Dentre as linguagens funcionais, acredito que Haskell seja a mais fácil para começar.

 

Não existem variáveis como as conhecemos em C, Python, Pascal, etc...

Portanto, se digitarem "teste = 10" no prompt do GHCi obterão o erro: <interactive>:1:6: parse error on input `='

Não se assustem, variáveis não servem para (quase) nada em Haskell.

(E por causa do 'quase' inventaram as pseudovariáveis, vamos falar delas mais tarde)

 

Tipos

Em Haskell existem alguns tipos nativos, isto é, ja estão definidos para utilizarmos.

Esses tipos são:

-> Integer : Números inteiros. O tipo Integer suporta números arbitrariamente grandes.

-> Int : Números inteiros, mas dessa vez com um limite. Depende da máquina, mas geralmente são 4 bytes.

-> Float: Números de ponto flutuante

-> Double : Números de ponto flutuante, suporta números maiores do que Float.

-> Char : Um caractere (representado com aspas simples, exemplo: 'a')

-> Bool : Um valor lógico. É True ou False.

 

Para além dos tipos nativos da linguagem, existem os tipos compostos.

Pra já, vamos apenas falar das listas.

Se quisermos representar uma lista de Integer's em Haskell, dizemos [integer]

E podemos inicializar essa lista com quantos elementos quisermos, por exemplo:

(nota: o operador '::' lê-se como "é do tipo")

	[1,2,3,4,5] :: [Integer]

A linha acima pode ser lida como: "A lista [1,2,3,4,5] é do tipo: Lista de Integer".

 

Uma String em Haskell escreve-se como [Char], mas podemos usar as aspas duplas para abreviar a escrita.

Se digitarmos

"Hello World"

o GHCi entenderá como:

['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

Se não especificarmos o tipo de alguma coisa, com o operador '::', o interpretador sempre escolhe o mais abrangente.

(nota: Para saber o tipo de algo, digite ':t <algo>' no prompt do GHCi e ele responderá o tipo.)

Isto é, se não especificarmos nada, 4 é do tipo Integer, 5.6 é do tipo Double, etc...

 

Além desses tipos todos, ainda existe um outro tipo que eu digo que é o tipo principal da linguagem.

São as funções!

E como declaramos uma função em haskell?

Muito fácil:

fatorial :: Integer -> Integer
fatorial 1 = 1
fatorian n = n * (fatorial (n-1))

Note a assinatura da função (a primeira linha)

Lá dizemos que "fatorial" "é do tipo" que recebe um "Integer" e dá-nos um "Integer" em seguida.

 

Por exemplo, a função soma:

soma :: Int -> Int -> Int

é to tipo que recebe dois "Int" e dá-nos um "Int" em seguida.

 

a função igual, que compara dois números:

eIgual :: Int -> Int -> Bool

é do tipo que recebe dois "Int" e dá-nos um "Bool" em seguida.

 

a função pi

pi :: Float

é do tipo que não recebe nada e dá-nos um "Float"

 

Passagem de parametros para funções

Em Haskell não utilizamos parenteses para passar parametros, mas sim espaços.

Por exemplo, para chamar a função soma com os argumentos 3 e 7:

soma 3 7

E a linguagem nos oferece um mecanismo muito interessante:

Qual o tipo de:

(soma 3)

?????

É "Int -> Int".

Sabemos que toda função é uma máquina, que recebe um input e produz um output.

Se essa máquina recebe dois inputs diferentes, quando fornecemos apenas um ela se transforma em outra máquina

que recebe um input e dá-nos um output.

 

Infix e Postfix

Algumas funções podem receber parametros da forma infixa e posfixa.

Vamos considerar a função mod, que recebe dois números e dá-nos o resto da divisão de um por outro.

A sua assinatura:

mod :: Int -> Int -> Int

Podemos chamar a função normalmente, da forma: mod 12 5, que é o mesmo que 12 % 5 em outras linguagens.

Mas, também podemos utilizar aspas invertidas e fazer: 12 `mod` 5.

 

O processo contrário também é possível.

Algumas funções ja são declaradas como infixas, por exemplo, a função +

(+) :: Int -> Int -> Int

Note que é declarada entre parenteses, isso diz para o Haskell que essa é uma função infixa, então não precisamos das aspas para

chamá-la.

É perfeitamente válido escrever: 50 + 40

Mas, podemos passar os parâmetros de uma forma posfixa, utilizando os parenteses: (+) 50 40

 

 

EXERCÍCIOS:

(1)

Descubra o tipo das sequintes expressões:

"abcde"
['a', 'b', 'c', 'd', 'e']
4 :: Int
4
'd'
True
true
False
false

(2)

Descubra o tipo das seguintes expressões e diga quais são constantes

e a forma padrão de passagem de parâmetros:

e :: Double
f :: Int -> Int
g :: Bool
(i) :: Int -> Float -> Bool
x :: [Int]
y :: [[Int]] -> Bool

Por enquanto é só!

Acho que isso ja é o suficiente para a primeira aula.

[Anne Bathory 0]

Olá, precisa postar as respostas?

[VictorCacciari 42]

Não, não é preciso.

Na verdade, é até bom não posta-las, dessa forma todos podem resolver os exercícios.

 

Esse tópico é exclusivamente para dúvidas.

E ficará aberto por uma semana.

[VictorCacciari 42]

Desculpem fazer o UP no tópico, porém, como editei o primeiro post muita gente não notará a mudança se eu não o fizer.