**r**, the number of columns

**c**, and a list

**vs**, the function should take

**r*c**values from the list and create a

**r**by

**c**matrix out of them. Here's the type:

toMatrix :: Int -> Int -> [a] -> [[a]]

## First solution

First I wrote a simpler function that would split a list into chunks of a given size, like this:chunksOf :: Int -> [a] -> [[a]] chunksOf _ [] = [] chunksOf c vs = h : (chunksOf c t) where (h, t) = splitAt c vsUsing the above,

**toMatrix**could be implemented this way:

toMatrix r c = chunksOf c . take (r*c)I had a feeling that a function like

**chunksOf**should be already present somewhere in the standard library, so I asked Hoogle, but to no avail. There was

**chunksOf**in

**Data.Text**, but it operated on

**Text**only (I retroactively named my function after the one in

**Data.Text**). However, Hoogle returned

**replicateM**as well…

## Second solution

… and I realized I could use it with the state monad to implement**toMatrix**. The state could contain the list of values yet to be consumed, and the action to be replicated could be chopping off

**c**values from the list:

splitOnce :: Int -> State [a] [a] splitOnce c = do s <- get let (h, t) = splitAt c s put t return hAfter a while I realized that the same function could be written in a much more concise form:

splitOnce' :: Int -> State [a] [a] splitOnce' = state . splitAtThe solution was, therefore:

toMatrix r = evalState . replicateM r . state . splitAt

## Summary

The second version is good enough for me and as a bonus it helped me understand the state monad. Note that the two implementations of**toMatrix**are

*not*equivalent, as they handle lists shorter than

**r*c**in different ways. Future work: find a concise and preferably point-free implementation of

**chunksOf**.

## Update (2013-01-08)

This answer on StackOverflow contains a very nice implementation of**chunksOf**.