¿Cómo mover un elemento en una lista en Haskell?

Question

Estoy leyendo a través de Learn You a Haskell y llegué a un punto en el que estoy tratando de mover un elemento de una lista a la cabeza. He descubierto lo que creo que es la manera ingenua y tengo curiosidad si alguien puede mostrarme lo que haría el experimentado programador Haskell en su lugar.

En este ejemplo, tengo una lista de enteros y quiero mover el elemento '4', que sería el índice '3', al encabezado de la lista.

let nums = [1, 2, 3, 4, 5] 
(nums !! 3) : delete (nums !! 3) nums 

devuelve [4, 1, 2, 3, 5].

¿Qué opinas?

Answer 1

lo haría de esta manera:

move n as = head ts : (hs ++ tail ts) 
    where (hs, ts) = splitAt n as 

splitAt divide una lista en la posición dada, devuelve las dos partes que son creados por la división (aquí hs y ts). El elemento que debe moverse al frente ahora está al comienzo de ts. head ts devuelve solo este primer elemento de ts, tail ts devuelve todo pero ese primer elemento. El resultado de la función son solo estas partes combinadas en el orden correcto: hs concatenado con tail ts y precedido por el elemento head ts.

Answer 2

¿Qué coincidencia?
Estaba leyendo lo mismo hace unos días. Lo buscó de nuevo & lo escribió como sigue.

nums !! 3 : [x | x <- nums, (x == (num !! 3)) == False] 

Answer 3

Haskellers con experiencia casi nunca utiliza la indexación de listas. Que haría uso de ruptura para evitar recorridos repetidos (suponiendo que desea hacer coincidir el elemento de '4', no index '3'):

case break (== 4) [1, 2, 3, 4, 5] of 
    (a,x:xs) -> x:a ++ xs 
    (a,xs) -> a ++ xs 

Como en:

Prelude Data.List> case break (== 4) [1, 2, 3, 4, 5] of (a,x:xs) -> x:a ++ xs; (a,xs) -> a ++ xs 
[4,1,2,3,5] 

Podemos hacer lo mismo con la indexación a través de 'splitAt':

Prelude Data.List> case splitAt 3 [1, 2, 3, 4, 5] of (a,x:xs) -> x:a ++ xs; (a,xs) -> a ++ xs 
[4,1,2,3,5] 

Answer 4

también hay

toHead n l = l !! n : take n l ++ drop (n+1) l 

que puede ser un poco más fácil de seguir que usando splitAt.

Answer 5

pequeña modificación en la solución de algo:

toHead n xs = x : pre ++ post 
    where (pre, x:post) = splitAt n xs 

usando coincidencia de patrones en lugar de head n tail