ler linhas de texto de entrada padrão e imprime casa linhas invertida usando a função interact

[crislanio_macedo]

ler linhas de texto de entrada padrão e imprime casa linhas invertida usando a função interact

Olá a todos, queria a ajuda de vocês para solucionar esse impasse uma vez que a ideia era para dá certo no entanto não está dando certo,

import Control.Monad

main = do {interact (unlines (map (reverse) (lines)));
}

Erro:

textoREVERSOIO.hs:7:22:
Couldn't match type `[Char]' with `String -> String'
Expected type: String -> String
Actual type: String
In the return type of a call of `unlines'
Probable cause: `unlines' is applied to too many arguments
In the first argument of `interact', namely
`(unlines (map (reverse) (lines)))'
In a stmt of a 'do' block:
interact (unlines (map (reverse) (lines)))

textoREVERSOIO.hs:7:46:
Couldn't match expected type `[[Char]]'
with actual type `String -> [string]'
In the second argument of `map', namely `(lines)'
In the first argument of `unlines', namely
`(map (reverse) (lines))'
In the first argument of `interact', namely
`(unlines (map (reverse) (lines)))'
Failed, modules loaded: none.

Att,

[pdfrod]

Sugiro estruturares o teu programa da seguinte forma:

main = interact reverseLines


reverseLines :: String -> String
reverseLines input = ...

Deverá ser mais fácil conseguires implementar a função reverseLines.

[crislanio_macedo]

main = interact reverseLines
reverseLines :: String -> String
reverseLines input = interact (show.reverse.lines)

-- reverseLines input = (unlines.map.reverse.lines)

erro

Prelude> :l textoREVERSOIO.hs
[1 of 1] Compiling Main ( textoREVERSOIO.hs, interpreted )

textoREVERSOIO.hs:8:22:
Couldn't match type `IO ()' with `[Char]'
Expected type: String
Actual type: IO ()
In the return type of a call of `interact'
In the expression: interact (show . reverse . lines)
In an equation for `reverseLines':
reverseLines input = interact (show . reverse . lines)
Failed, modules loaded: none.

Edited May 5, 2015 at 01:49 AM by crislanio_macedo

[thoga31]

Para que serve o interact e o show na função reverseLines?

O que tens em comentário está quase certo para aquilo que pretendes.

E nem sequer precisas de indicar expressamente o parâmetro da função.

[crislanio_macedo]

Para que serve o interact e o show na função reverseLines?

O que tens em comentário está quase certo para aquilo que pretendes.

E nem sequer precisas de indicar expressamente o parâmetro da função.

Mas eu não estou a saber como completar esse impasse, ao meu ver o código que está comentado estava suficiente para dá certo.Não sei como proceder.

[thoga31]

Mas eu não estou a saber como completar esse impasse, ao meu ver o código que está comentado estava suficiente para dá certo.Não sei como proceder.

Vamos analisar o que tinhas...

main = interact reverseLines
reverseLines :: String -> String
reverseLines input = interact (show.reverse.lines)

-- reverseLines input = (unlines.map.reverse.lines)

De forma bastante simplista, a função interact aplica uma função que transforma determinados tipos de dados e devolve um IO(). Desta forma, não faz sentido qualquer aplicar a função interact numa função que vai ser usada pelo interact do main.

Em segundo lugar, o show também não está a fazer nada uma vez que o interact já vai tratar de devolver um IO().

Portanto, a função reverseLines deverá ser, conforme indicado no link que forneci e pelo @Kimio, String -> String:

interact :: (String -> String) -> IO()
--          \----------------/
--                   |
--                   |
--                   V
--      Função a fornecer ao 'interact'

reverseLines :: String -> String
reverseLines xs = -- ...

Eu disse que não era preciso indicar expressamente o parâmetro de entrada desta função.

E, antes de mais, vou colocar-te a par de dois erros que estavas a cometer aqui:

reverseLines input = (unlines.map.reverse.lines)

E que eu vou "limpar" para ficar com um aspecto mais "límpido":

reverseLines input = unlines . map . reverse . lines

1) Indicaste o parâmetro de entrada da função - input - mas não o estás a usar expressamente em lado nenhum. A expressão que construíste não necessita do parâmetro. Portanto, ou o usas ou o retiras.

-- errado:
foo x = (+1)

-- certo:
foo x = x + 1  -- parâmetro explícito.
foo = (+1)     -- parâmetro implícito,
                    -- o mesmo que:
                    foo x = (+1) x

2) O operador (.), ponto, não é para ser usado entre toda e cada função/expressão no Haskell. f . g significa "f após g", ou seja, aplica o resultado da função g à função f.

A função map tem a seguinte tipagem:

map :: (a -> c) -> [a] -> [c]

Portanto, aplica uma função (a -> c) aos elementos de uma lista [a] e devolve a lista resultante [c].

Agora repara nisto que fizeste:

map . reverse . lines

Isto é o mesmo que:

map (reverse (lines ...))

Tu queres aplicar a função map ao resultado da função reverse? Ou queres que a função reverse seja a função a aplicar ao elementos recebidos pelo map?

Logicamente que reverse é a função a ser aplicada pelo map, ou seja, queres isto:

map reverse (lines ...)

Notaste a mudança de parêntesis? reverse faz parte da construção da função map.

Portanto, tens um operador (.) a mais:

    map . reverse . lines
--   \-----------/
--         ^
--         |
--         |
-- 'map' após 'reverse'?

Posto isto, consegues construir a função reverseLines corrigindo o que tens de errado aqui?

reverseLines input = unlines . map . reverse . lines

Edited May 8, 2015 at 08:50 PM by thoga31

[crislanio_macedo]

import Control.Monad
main = interact reverseLines
--reverseLines :: String -> String
reverseLines input = unlines . map . reverse . lines

Prelude> :l reverseIO.hs
[1 of 1] Compiling Main ( reverseIO.hs, interpreted )

reverseIO.hs:4:32:
Couldn't match type `[a0] -> [b0]' with `[string]'
Expected type: (a0 -> b0) -> [string]
Actual type: (a0 -> b0) -> [a0] -> [b0]
In the first argument of `(.)', namely `map'
In the second argument of `(.)', namely `map . reverse . lines'
In the expression: unlines . map . reverse . lines

reverseIO.hs:4:38:
Couldn't match type `[string]' with `a0 -> b0'
Expected type: [string] -> a0 -> b0
Actual type: [string] -> [string]
In the first argument of `(.)', namely `reverse'
In the second argument of `(.)', namely `reverse . lines'
In the second argument of `(.)', namely `map . reverse . lines'
Failed, modules loaded: none.

Edited May 9, 2015 at 05:37 PM by crislanio_macedo

[thoga31]

O código que coloquei no final do meu último post é o teu código que estava em comentário. Eu perguntei-te se o conseguias corrigir tendo em conta a explicação que te dei.

Posto isto, consegues construir a função reverseLines corrigindo o que tens de errado aqui?

reverseLines input = unlines . map . reverse . lines

[crislanio_macedo]

O código que coloquei no final do meu último post é o teu código que estava em comentário. Eu perguntei-te se o conseguias corrigir tendo em conta a explicação que te dei.

Eu não compreendi como fazer exatamente, por isso parti para tentar outras questões

[thoga31]

reverseLines input = unlines . map . reverse . lines
--           \---/                                    \---/
--             |                                        |
--             |                                        |
--             V                                        V
--   Parâmetro de entrada                         Onde é usado?

Não sei se reparaste que, para este problema, eu dei-te a resposta:

1) Indicaste o parâmetro de entrada da função - input - mas não o estás a usar expressamente em lado nenhum. A expressão que construíste não necessita do parâmetro. Portanto, ou o usas ou o retiras.

reverseLines input = unlines . map . reverse . lines
--                             \-----------/
--                                   |
--                                   |
--                                   V
--                        Significa "map após reverse"

Qual dos seguintes é correcto?

-- 1
map reverse xs

-- 2
map (reverse xs)

map . reverse é o mesmo que a opção 2. E eu disse que...

Portanto, tens um operador (.) a mais:

Logo, qual seria o (.) a retirar? Só indiquei um.

main = interact reverseLines

reverseLines :: String -> String
reverseLines = unlines . map reverse . lines

Eu aconselhava-te a apostares forte nas bases da linguagem Haskell. Trabalhar com Monads sem antes conseguir aplicar correctamente conceitos básicos como o operador (.) ou parâmetros implícitos não é muito boa ideia.

[crislanio_macedo]

Eu estava percebendo o não uso do input, estava a entender como a composição funciona, só não parei para analisar o caso e como falei, estava a tentar outras questões de monads. Não sei realmente como aplicar os operadores em Monads não, realmente, mas tenho que aprender.