Home/ Questions/Q 1091345
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-16T23:30:45+00:00

I have a list like this: (Pseudo notation) (X,…) -> (X,…) -> (X,…) ->

  • 0

I have a list like this: (Pseudo notation)

(X,...) -> (X,...) -> (X,...) -> ...
   |          |          |
   V          V          V
(Y,...)    (Y,...)    (Y,...)
   |          |          |
   V          V          V
(Z,...)    (Z,...)    (Z,...)

Type is (Enum a, Bounded a) => [[(a,x)]]. But I need something like this:

(X, ... -> ... -> ... -> ...
   |
   V
(Y, ... -> ... -> ... -> ...
   |
   V
(Z, ... -> ... -> ... -> ...

Type is like (Enum a, Bounded a) => [(a,[x])]

x has an arbitrary number of elements. It can be assumed, that each Member of x is a key in each sublist of the first list.

How is this transformation possible as a lazy haskell algorithm (List doesn’t needs to be evaluated completely to return (partitially) result)?

Test data

See above, something like this:

--Input
[[(Foo,1),(Bar,1),(Baz,1)],[(Foo,2),(Bar,2),(Baz,2)],...]

--Output
[(Foo,[1,2,3,...]),(Bar,[1,2,3,...),(Baz,[1,2,3,...])]

What I want to do with the data

I want to use it in a function like this:

myFunc :: [(MyEnum,[Int])]
myFunc x@((_,(_:[])):_) = x
myFunc x            = foldTheListRecursively

The function has to work on large amounts of data (~10’000 entries per enum), the list should be garbage collectable by the runtime system (The list is adhoc build by another part of the program)

My (uggly) implementation

This is the way, I implemented it, but obviously it doesn’t fits the requirements, as the list is traversed multiple times:

restructList :: [[(a,x)]] -> [(a,[x])]
resturctList list = (\x -> (x,listFor x)) <$> keys where
  keys = fst <$> head list
  listFor x = snd <$> any ((==x).fst) <$> list

I’m not at home so can’t test it, so there may be a mistake.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    I’m not a 100% sure, but from the sourcecode it looks like Data.List.transpose is lazy.
    http://www.haskell.org/ghc/docs/6.12.2/html/libraries/base-4.2.0.1/src/Data-List.html#transpose is my source for it.
    I think that transpose can help you to restructure the pointers:

    transpose [[1,2,3],[4,5,6],[7,8,9]]
-- results in [[1,4,7],[2,5,8],[3,6,9]]

    So I’d think of something like

    foo :: [[(a, b)]] -> [(a, [b])]
foo = map (\x -> (fst (head x), map snd x)) . transpose
    • 0