¿Cómo convierto una lista en una tupla en Haskell?

Question

cuál es la mejor convertir una lista a una tupla en Haskell:

[1,2,3,4,5,6] -> (1,2,3,4,5,6) 

Answer 1

De una manera general, no se puede. Cada tamaño de tupla es un tipo distinto, mientras que las listas de cualquier longitud son de un solo tipo. Por lo tanto, no hay una buena forma de escribir una función que tome una lista y devuelva una tupla de la misma longitud; no tendría un tipo de devolución bien definido.

Por ejemplo, usted podría tener funciones como:

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

tuplify3 :: [a] -> (a,a,a) 
tuplify3 [x,y,z] = (x,y,z) 

... pero no uno que hace el trabajo de ambos.

puede escribir una versión genérica utilizando varios tipos de meta-programación, pero rara vez lo desea.

Tenga en cuenta que el mismo problema se aplica a otras cosas, como escribir instancias de clase para varias tuplas: ¡eche un vistazo a the source code for Data.Tuple de las bibliotecas estándar!

Answer 2

Tuplas y listas son cosas muy diferentes. Lo mejor que puede hacer es escribir manualmente una función de conversión:

toTuple :: [a] -> (a,a,a,a,a,a) 
toTuple [a,b,c,d,e,f] = (a,b,c,d,e,f) 

Aviso cómo diferentes los tipos son: la única variable de la lista se amplía a seis variables para la tupla. Entonces necesitarás una función para cada tamaño de tupla.

Answer 3

De hecho, puede hacer algo mejor que escribir manualmente una función por tuplo si usa cuasi-quotation [1]. Sin embargo, me pregunto acerca del código en el que espera usar esto genéricamente.

[1] http://www.haskell.org/haskellwiki/Quasiquotation

Answer 4

Plantilla Haskell es lo más cerca que puede llegar debido a la comprobación de tipos si desea extraer un número variable de elementos, ya que (a, b) y (a, b, c) tener diferentes tipos

{-# LANGUAGE TemplateHaskell #-} 
import Language.Haskell.TH 
tuple :: Int -> ExpQ 
tuple n = do 
    ns <- replicateM n (newName "x") 
    lamE [foldr (\x y -> conP '(:) [varP x,y]) wildP ns] (tupE $ map varE ns) 

continuación:

$(tuple 6) [1,2,3,4,5,6] == (1,2,3,4,5,6) 
$(tuple 3) "abc" == ('a','b','c') 

Pero, en general, si necesita esta respuesta, entonces usted está haciendo la pregunta equivocada en alguna parte.

Si solo desea un acceso aleatorio plano, quizás la mejor opción sea utilizar una matriz.

Answer 5

No creo que sea posible hacerlo en Haskell, para obtener una lista de longitud arbitraria desconocida en tiempo de compilación. La plantilla Haskell no puede hacerlo porque funciona solo en tiempo de compilación. Me encontré con un caso en el que necesitaba hacer precisamente esto, y tuve que evitarlo. Una biblioteca de base de datos espera tuplas de longitud diferente para argumentos de consulta, pero tengo una lista de longitud arbitraria. Así que tengo que rodear la interfaz de la biblioteca. Sería bueno si pudiera tomar una lista.

Básicamente, el problema es que las tuplas de diferentes longitudes son tipos diferentes. Pero el compilador Haskell debe saber en el tipo de compilación qué tipos pueden existir en el tiempo de ejecución. Convertir una lista de longitud arbitraria en una tupla en tiempo de ejecución podría crear algún tipo que no conocía en tiempo de compilación.

Answer 6

Me resulta difícil hacer explicaciones convincentes de manipulaciones Plantilla Haskell, pero aquí es una demostración:

> :m +Language.Haskell.TH 
> :set -XTemplateHaskell 
> runQ [| [1,2,3,4,5,6] |] >>= putStrLn . pprint 
[1, 2, 3, 4, 5, 6] 
> runQ [| [1,2,3,4,5,6] |] >>= \ (ListE exps) -> putStrLn (pprint (TupE exps)) 
(1, 2, 3, 4, 5, 6) 

Answer 7

Si siento como si estuviera a punto de aconsejar que apuntar con un arma a su pie y no confiar en usted para disparar.

> list2Tuple lst = read $ "(" ++ (init.tail.show) lst ++ ")" 
> list2Tuple [1,2,3] :: (Int, Int, Int) 
(1,2,3) 
> list2Tuple [1,2,3,4] :: (Int, Int, Int, Int) 
(1,2,3,4) 

Esto funcionará hasta la longitud de lo que cada vez tupla Show y de lectura se define para.