Duvidas em 2 exercicios simples de haskell

[Utu]

Boas, tenho duvidas nestes 2 exercicios que se seguem:

1 - A função que, dada uma lista e um elemento, o coloca no fim da lista.

lista :: [a] -> a -> a

lista [] = 0

lista [] x = x

lista (h:t) x = (h:t) ++ x

2 - A função que, dadas duas listas as concatena, e, calcula uma lista com os elementos

da primeira lista seguidos dos da segunda lista.

[anolsi]

A primeira é simples:

lista :: [a] -> a -> a
lista [] _ = []
lista l x = l ++ (x : [])

A segunda não percebi o que queres.

Mas também podias explicar melhor as tuas dúvidas 😉

[Utu]

Desde de ja obrigado pela resposta  😉

E deixo aqui outra solução para a primeira

fim :: [a] -> a -> [a]

fim [] x = [ x ]

fim (h:t) x = h: (reverse (x: ( reverse t)))

Pelo que percebi, a segunda pede para darmos 2 listas de numeros a introduzir pelo utilizador, e o que nos devolve é uma lista nova que ele cria, onde contem essas duas listas, uma seguida da outra

[Betovsky]

No 1º caso penso que a forma seja mais correcta seja:

lista :: [a] -> a -> [a]
lista [] x = [x]
lista (h:t) x = h : lista t x

Na 2ª é basicamente a mesma coisa. A única diferença é o caso base. Já que em vez de trabalhares com um elemento x irás trabalhar com uma lista de elementos.

[Utu]

Obrigado pelas respostas rápidas  😉

Começei a dar haskell este ano e é uma linguagem diferente de tudo que ja dei (pascal, visual basic, c, c++ etc), e é bom ter uma comunidade participativa onde podemos expor duvidas e discutir soluções.  😉

[Utu]

lista :: [a] -> a -> [a]

lista [] x = [ x ]

lista (h:t) x = h : lista t x

Este codigo não consigo usar, eu meto "lista [1,2,3] [1,2,3]", e ele não as junta lol devo estar a fazer algo mal.

No entanto este código simples resultou

concatena :: [a] -> [a] -> [a]

concatena x y = x ++ y

[Baderous]

1 - A função que, dada uma lista e um elemento, o coloca no fim da lista.

lista :: [a] -> a -> [a]

lista [] x = [ x ]

lista (h:t) x = h : lista t x

Este codigo não consigo usar, eu meto "lista [1,2,3] [1,2,3]", e ele não as junta lol devo estar a fazer algo mal.

"Dada uma lista e um elemento" é diferente de "dadas 2 listas".

[silva.samuel]

Alteração no tipo de dados para "lista :: [a] -> a -> [a]"

A primeira é simples:

lista :: [a] -> a -> [a]
lista [] x = [x]
lista xs x = xs ++ (x : [])

Para o segundo exercício deve-se usar o primeiro.

concatena :: [a] -> [a] -> [a]
concatena as [] = as
concatena as (b:bs) = concatena (lista as b) bs

Mas apresento uma versão upgraded que dá os mesmos resultados:

lista2 :: [a] -> a -> [a]
lista2 = flip (flip (($) (++)) . ($) (:[]))

concatena2 :: [a] -> [a] -> [a]
concatena2 = ($) (++)

Utilizei esta versão Point-Free para testar as minhas habilidades em Haskell.

Já não pegava no haskell há meses, mas há coisas que não se esquecem.

[Utu]

Eu agradeço as respostas pessoal, mas podiam postar o raciocínio  😉

Mais do que ter os exercícios feitos quero perceber porque é assim.

obrigado  😉

[silva.samuel]

lista é uma função
  que dada uma lista e um elemento 
  dá como resultado uma lista 
    em que o segundo argumento é o último elemento da lista 
      dada como primeiro argumento

concatena é uma função
  que concatena os elementos das duas listas passadas como argumentos
  Esta função já existe no haskell e 
    utiliza-se do seguinte modo as ++ bs, 
    para concatenar a lista as e bs

concatena2 é uma função equivalente à função concatena
Esta função usa a função ($) para criar uma função que concatena, usa a função (++), duas listas 

lista2 foi a função mais difícil de fazer.
  Esta função usa a função flip para trocar a ordem dos argumentos das funções binárias
    criar uma função que troca os argumentos da função de concatenar ($) (++)
    composta com a função de adicionar um elemento na lista ($) (:[])
Um flip é responsável por trocar os argumentos para adicionar na cauda.
O outro flip é responsável pela ordem dos parametros estar correcta.