Comment trier une liste en Haskell en ligne de commande ghci

Je suis nouveau sur Haskell, et je veux faire 1 fonction qui va prendre deux listes et de fusion puis ensemble, et puis trier la liste combinée du plus petit au plus grand.
cela devrait être fait dans la ligne de commande, sans l'aide de modules.

C'est ce que j'ai actuellement, j'ai de la difficulté à obtenir le "sortList" la fonction de travail, et aussi je ne sais pas comment combiner ces 3 lignes en 1 de la fonction.

let combineList xs ys = xs++ys
let zs = combineList xs ys
let sortList (z:zs) = if (head zs) < z then (zs:z) else (z:(sortList zs))

Avez-vous besoin d'écrire votre propre algorithme de tri? Si pas, je vous suggère d'importation Data.List et à l'aide de la sort fonction. Ensuite, vous pouvez simplement écrire comme combineAndSort xs ys = sort (xs ++ ys).
Grâce bheklilr, C'était vraiment utile

OriginalL'auteur Iceandele | 2013-09-29

4

C'est un peu difficile à définir une fonction de tri à l'intérieur de la ghci. Je pense que la meilleure façon de le faire serait d'écrire la fonction de tri dans un fichier, puis de le charger dans ghci. Par exemple, vous pourriez écrire cette concise (mais pas dans sur place!) la version de quicksort dans un fichier appelé sort.hs (prises de le HaskellWiki):
```
quicksort :: Ord a => [a] -> [a]
quicksort []     = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
    where
        lesser  = filter (< p) xs
        greater = filter (>= p) xs
```
et de le charger dans ghci:
```
> :l sort.hs 
```
Si vous voulez vraiment définir la fonction dans ghci, vous pouvez faire quelque chose comme ceci (à partir de le Haskell guide de l'utilisateur):
```
> :{
> let { quicksort [] = []
>     ; quicksort (p:xs) = (quicksort (filter (< p) xs)) ++ [p] ++ (quicksort (filter (>= p) xs))
>     }
> :}
```
une fois que cela est défini, vous pouvez le faire
```
> let combineAndSort xs ys = quicksort (xs ++ ys)
```
Comme une autre réponse a déjà expliqué, il serait bien plus rapide de simplement importer sorte de Data.List, mais il est certainement un bon exercice que de le faire manuellement.

Votre question suggère que vous êtes un peu confus au sujet de la portée des variables en Haskell. Dans cette ligne
```
> let combineList xs ys = xs++ys
```
vous présenter les variables xs et ys. Les mentionnant à la gauche du signe égal signifie simplement que combineList prend deux variables, et dans le corps de cette fonction, vous allez à consulter ces variables comme xs et ys. Il n'a pas d'introduire les noms en dehors de la fonction, de sorte que la prochaine ligne
```
> let zs = combineList xs ys
```
n'a pas vraiment de sens, parce que les noms xs et ys ne sont valables que dans le cadre de combineList. Pour faire zs ont une valeur, vous avez besoin de donner combineList certains arguments en béton, par exemple.:
```
> let zs = combineList [2,4,6] [1,3,5]  --> [2,4,6,1,3,5]
```
Mais comme le corps de combineList est si simple, il serait effectivement plus facile de le faire:
```
> let zs = [2,4,6] ++ [1,3,5] --> [2,4,6,1,3,5]
```
La dernière ligne est
```
> let sortList (z:zs) = if (head zs) < z then (zs:z) else (z:(sortList zs))
```
Je pense que cette ligne a confondu beaucoup, car il ya beaucoup de différentes erreurs ici. La réponse par ДМИТРИЙ МАЛИКОВ mentionne la plupart d'entre eux, je voudrais vous encourager à essayer de comprendre les erreurs qu'il mentionne.

OriginalL'auteur Boris
17

Comment faire pour trier la liste dans ghci:
```
Prelude> :m + Data.List
Prelude Data.List> sort [1,4,2,0]
[0,1,2,4]
```
Au sujet de vos fonctions
```
let combineList xs ys = xs++ys
```
Qu'est-ce que d'un point pour créer un alias pour ajouter la fonction? Mais si vous êtes vraiment veut - il pourrait être défini comme let combineList = (++).
```
let zs = combineList xs ys
```
Il n'a pas de sens parce que xs et ys sont connus à l'extérieur de votre combineList.
```
let sortList (z:zs) = if (head zs) < z then (zs:z) else (z:(sort zs))
```
Cette définition n'est pas valide car elle ne couvre pas et la liste vide de cas et (zs:z) produit infini de type et sort n'est pas encore défini. Et vous pouvez obtenir head de zs juste par un autre pattern matching. Et peut-être que tu ne veux pas faire un autre appel récursif dans le then partie de if déclaration. Et enfin, je dois avouer que cet algorithme de tri ne fonctionne pas du tout.

OriginalL'auteur ДМИТРИЙ МАЛИКОВ

Vous devez vous connecter pour publier un commentaire.