Haskell - Programación funcional Ayuda

Question

Intentando hacerte una idea de haskell. Soy un programador avezado con PHP, JAVA, VB y muchos otros idiomas, pero estoy encontrando que haskell es un poco más difícil de seguir. ¿Alguien puede dar una traducción Inglés para la siguiente función de Haskell, que me refiero a ...

quicksort []  = [] 
quicksort (x:xs) = quicksort [y | y <- xs, y<x ] 
        ++ [x] 
        ++ quicksort [y | y <- xs, y>=x] 

Un ejemplo de traducción Inglés está en los comentarios a continuación:

// --- FOR_LOOP -> 
// --- $abc goes from 1 to 10 -> 
// --- If $abc is even - print $abc is even -> 
// --- else if $abc is odd - print $abc is odd -> 
// --- END_FOR_LOOP 

for($abc = 1 ; $abc <= 10 ; $abc++){ 

    if($abc % 2 == 0){ 
    echo $abc . " is even"; 
    } 
    else{ 
    echo $abc . " is odd"; 
    } 
} 

La primera línea es bastante sencilla, leyendo: "La función quicksort en una lista vacía produce una lista vacía como resultado" ... Si puede traducir el resto del haskell al inglés t sería muy útil.

Answer 1

El resultado de ordenar rápidamente la lista vacía es la lista vacía.

El resultado de quicksorting una lista no vacía, donde nosotros llamamos el primer elemento de la lista x y los elementos restantes xs es: El resultado de quicksorting todos los elementos de xs que son menores que x (*), seguido por x, seguido por el resultado de ordenar rápidamente todos los elementos de xs que son mayores que x.

(*) Para elaborar un poco: [y | y <- xs, y<x ] se puede leer como "la lista de todos y donde y está en xs y y<x".

Answer 2

Esto no responde directamente a su pregunta, pero hoogle puede ayudar a su aprendizaje en general, puede usarlo para buscar en las bibliotecas api estándar por nombre de función o por firma de tipo aproximado.

Aquí hay ejemplos de los términos de búsqueda que soporta:

map 
(a -> b) -> [a] -> [b]` 
Ord a => [a] -> [a] 
Data.Map.insert 

Answer 3

no lo ha hecho desde la universidad ...

Es recursivo - la primera línea es el caso de un conjunto vacío.

quicksort []  = [] 

Las siguientes líneas operan en un conjunto no vacío. La sintaxis (x: xs) lo divide en un solo elemento (x) y los elementos restantes (xs).

quicksort (x:xs) = quicksort [y | y <- xs, y<x ] 
    ++ [x] 
    ++ quicksort [y | y <- xs, y>=x] 

La primera línea, quicksort [y | y < - xs, y < x], llama a quicksort contra el conjunto de todos los elementos de xs que son menores que x (es decir, cada y de xs que es menor que x). Si xs es el conjunto vacío, entonces quicksort [] devolverá [].

La línea media es simplemente el conjunto que contiene x.

La última línea, quicksort [y | y < - xs, y > = x], llama quicksort al conjunto de todos los elementos de xs que son mayores o iguales a x (es decir, cada y de xs que es mayor o igual a x). Si xs es el conjunto vacío, entonces quicksort [] devolverá [].

El resultado final es un conjunto ordenado.

Answer 4

Es un lenguaje declarativo, por lo que simplemente lee lo que ve. sepp2k hace un buen ejemplo arriba.

Answer 5

Comprobar http://learnyouahaskell.com/recursion#quick-sort explica exactamente lo que hace la ordenación rápida.

Answer 6

En caso de que su problema era en la familiaridad con las listas por comprensión, he aquí algunas versiones alternativas que son más o menos lo mismo:

quicksort []  = [] 
quicksort (x:xs) = 
    quicksort (filter (< x) xs) ++ 
    [x] ++ 
    quicksort (filter (>= x) xs) 

quicksort []  = [] 
quicksort (x:xs) = 
    quicksort smaller ++ [x] ++ quicksort bigger 
    where 
    (smaller, bigger) = partition (< x) xs