haskell optimise le code liste infini

Question

Donc mon code donne le résultat voulu mais je me demande s'il y a un meilleur moyen de le coder. Ceci est l'exemple donné:

pair [ 1 , 2 , 3 , 4 , 5 , 6 , ... ] 
[ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] , ... ] 

et le code donné:

pair::[a] -> [[a]] 
pair = 

Ma solution:

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

Answer 1

Utilisation de l'opérateur contre : sera beaucoup plus performant que les listes concaténer:

pair :: [a] -> [[a]] 
pair (x:y:xs) = [x, y] : pair xs 

Le raisonnement est que les listes dans Haskell sont des listes liées où chaque élément pointe vers le suivant jusqu'à la fin de la liste. Les pushs et les pops sont bon marché quand ils sont en tête de liste parce que vous pointez seulement la tête en tête d'une liste existante. Lorsque vous concaténez deux listes liées, vous reconstruisez essentiellement la première liste complète afin que son dernier élément pointe vers le premier élément de la deuxième liste. Le gain de performance est mineur dans votre exemple puisque vous n'avez que deux éléments dans votre liste, mais en règle générale, si vous avez des opérations en tête de liste, ça sera presque toujours plus performant utiliser contre.