# [Haskell-cafe] Rotating matrices

Thomas Sutton thsutton at gmail.com
Thu Jun 15 09:22:07 EDT 2006

```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
```

More information about the Haskell-Cafe mailing list