[Haskell-cafe] Rotating matrices

[Thomas Sutton]

Dear list,

I'm currently engaged in an attempt to wrap my head around type  
arithmetic. To make sure that I've understood, I plan to write a few  
operations on matrices a la Oleg's Number Parameterised Types. Before  
I get down to it, I've been making sure I know how to implement the  
operations (so that all I need to think about later is the type  
arithmetic).

Today I've been looking at rotating matrices, i.e: taking a column- 
wise matrix and making it row-wise and, in the process, swapping the  
dimensions (thus a 3*2 matrix becomes a 2*3 matrix). I've been  
working with lists of lists for simplicity and have come up with:

 > rotate' :: [[a]] -> [[a]]
 > rotate' [] = []
 > rotate' xs = (map (head) xs ):(rotate' $ filter (not . null) $ map  
(tail) xs)

which seems to work just fine. While this solution is adequate (it  
seems to work for infinite structures as well, which is good), I  
originally set out to solve this problem with a fold or a mapAccum of  
some sort (I don't really care if it doesn't work with infinite  
structures). Can anyone suggest a way to write this with a fold (or  
tell me why it isn't a good idea)?

Cheers,
Thomas Sutton