2

When I've seen concat function in Haskell book, I wonder how I can flatten the list below in Haskell. In Python, I can do that because I can check its type in function. But in Haskell I couldn't. How can I flatten the list below?

input: [[1, 2], [[2, 3], 5], [[[2, 3], [4, 5]], [2, 3]]]
output: [1, 2, 2, 3, 5, 2, 3, 4, 5, 2, 3]
Mirzhan Irkegulov
  • 17,660
  • 12
  • 105
  • 166
  • 2
    Note - in Haskell you would generally use a tree rather than a list if you have nested lists. In a strongly typed language like Haskell the structure of the nesting has to be reflected in the list type - sometimes this is good but often you really want a tree instead where the type just has to account for the element not the structure. There is the module Data.Tree in the standard libraries which is a Rose tree, or it is easy to roll your own. – stephen tetley Feb 28 '12 at 07:43
  • 4
    Your input isn't even a valid list in Haskell. – Mechanical snail Feb 28 '12 at 08:25
  • Related: http://stackoverflow.com/questions/5994051/is-there-a-function-to-flatten-a-nested-list-of-elements – Matvey Aksenov Feb 28 '12 at 10:20

2 Answers2

6

As already pointed out, you can't have arbitrary nested lists in Haskell. The closest thing (without dirty type class hacks using fancy pragmas) would be something like:

data Nested a = L a | B [Nested a]

flatten :: Nested a -> [a]
flatten (L x) = [x]
flatten (B xs) = concatMap flatten xs  

print $ flatten $ B[B[L 1,L 2],B[B[L 2,L 3],L 5],B[B[B[L 2,L 3],B[L 4, L 5]],B[L 2,L 3]]]
--[1,2,2,3,5,2,3,4,5,2,3]
Landei
  • 54,104
  • 13
  • 100
  • 195
  • 1
    Note that "Nested" is a simple tree (http://en.wikipedia.org/wiki/Tree_%28data_structure%29), where "L" is a Leaf and "B" is a Branch. – amindfv Feb 28 '12 at 13:16
5

You cant create a list with different depth in haskell. It won't t typecheck. [[a]] are not the same type as [[[a]]]. This function will solve your question but only on list with the same depth.

flat::[[a]] -> [a]
flat [] = []
flat l:ls = l ++ flat ls
nist
  • 1,706
  • 3
  • 16
  • 24
  • Actually, this function already exists and is called `concat`. – fuz Feb 28 '12 at 07:27
  • Thanks for the reminder. It has been a to long time since i programmed haskell and I wasn't sure if there was such a function so wrote my own just to be on the safe side – nist Feb 28 '12 at 07:31
  • 1
    In this question, there is one level of lists - [[a]], but if it was more than that, concat should be called more than once. concat will flatten one level only. Of course, this doesn't apply for the question above, but something to watch out for. – Gangadhar Feb 28 '12 at 08:18
  • in ghci 8.4.3, the 3th definition should be written using parenthesis like flat (l:ls) = l ++ (flat ls) – jbytecode Oct 08 '18 at 17:42