How do I convert a list to a tuple in Haskell?

by

In a general way, you can’t. Each size of tuple is a distinct type, whereas lists of any length are a single type. Thus, there’s no good way to write a function that takes a list and returns a tuple of the same length–it wouldn’t have a well-defined return type.

For instance, you could have functions like:

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

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

…but not one that does the job of both.

You can write a generic version using various kinds of meta-programming, but you’d rarely want to.

Note that the same problem applies to other things, such as writing class instances for various tuples–take a look at the source code for Data.Tuple from the standard libraries!

More Related Contents:

  1. `String’ is applied to too many type arguments
  2. How do I define Lisp’s apply in Haskell?
  3. Operating on a return from a Maybe that contains “Just”
  4. Is there a Haskell idiom for updating a nested data structure?
  5. What’s so bad about Lazy I/O?
  6. Positive integer type
  7. Confused by the meaning of the ‘Alternative’ type class and its relationship to other type classes
  8. Explicitly import instances
  9. How to extract value from monadic action
  10. Large-scale design in Haskell? [closed]
  11. How to compare two functions for equivalence, as in (λx.2*x) == (λx.x+x)?
  12. Why do 3 and x (which was assigned 3) have different inferred types in Haskell? [duplicate]
  13. How do I use fix, and how does it work?
  14. List of different types?
  15. What is Levity polymorphism
  16. How to infer the type of an expression manually
  17. Ordering of parameters to make use of currying
  18. No instance for (Fractional Int) arising from a use of `/’
  19. Understanding the Haskell as-pattern
  20. Haskell: How to create most generic function possible that applies a function to tuple items
  21. Prefix form of unary operator in Haskell
  22. Concrete example showing that monads are not closed under composition (with proof)?
  23. How to use (->) instances of Monad and confusion about (->)
  24. Why can a Num act like a Fractional?
  25. Composing function composition: How does (.).(.) work?
  26. Can you overload + in haskell?
  27. Why doesn’t TypeSynonymInstances allow partially applied type synonyms to be used in instance heads?
  28. Why does OCaml sometimes require eta expansion?
  29. Explanation of “tying the knot”
  30. Return specific type within Haskell

Leave a Comment