Implementing Transpose I'm implementing transpose in Haskell.

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


Please give it a look. Note that I'm trying not to use any built-in functions (excluding map and ++):

transpose' :: [[a]] -&gt; [[a]]
transpose' ys
   | null $ filter (not . null) ys = []
   | otherwise = [flatten' $ map head' ys] ++ transpose' (map tail' ys)

head' :: [a] -&gt; [a]
head' []     = []
head' (x:xs) = [x]

tail' :: [a] -&gt; [a]
tail' []     = []
tail' (x:xs) = xs

flatten' :: [[a]] -&gt; [a]
flatten' as = foldl (\acc x -&gt; acc ++ x)  [] as


Side note - I know that I could look at the Haskell source, but I appreciate the comments &amp; thoughtful insights here.
I see a few problems, mostly similar to my remarks in a previous answer:


Your definition of head' is unconventional.  Its definition should be

head' :: [a] -&gt; a
head (x:_) = x


Furthermore, your problematic definition of head' is making you define flatten'.  If you fix head' as suggested above, thenflatten' becomes unnecessary.
The definition of tail' is too complicated.  It could just be

tail' :: [a] -&gt; [a]
tail (_:xs) = xs

For clarity, I would rename the parameter to transpose' from ys to rows.
The base case of transpose' is too complicated.  Also, it can be done using pattern matching.

transpose' [[]]    = []
transpose' [[], _] = []

Prefer x:xs to [x] ++ xs.
Scope your helper functions using where.


Here's what I came up with:

transpose' :: [[a]] -&gt; [[a]]
transpose' [[]]    = []
transpose' [[], _] = []
transpose' rows    = (map head' rows) : transpose' (map tail' rows)
  where
    head' (x:_) = x
    tail' (_:xs) = xs