I just finished the highly recommended CIS194 course! It’s very interesting to go back to my earlier questions when I started the whole process of learning Haskell back in November or so, and compare them to my code now. I cleaned up some of the older answers, just to compare more explicitly the difference.

Old:

skips :: [a] -> [[a]]
skips [] = []
skips xs = map deIndex (map (deIndex) (flatten xs))

deIndex :: (Integral a) => [(a,b)] -> [b]
deIndex x = map snd x

flatten :: [b] -> [[(Int, (Int, b))]]
flatten xs = map dropIndex \$ buildList xs

-- Drops elements in the list if they're divisible by the number.
dropIndex :: (Int,[a]) -> [(Int,a)]
dropIndex (n,xs) = filter (\(x,_) -> x mod n == 0) (index xs)

-- Takes a list, indexes it, expands it into a list of lists, and
-- indexes the top level list.
buildList :: [a] -> [(Int, [(Int, a)])]
buildList = index . expandList . index

-- Takes a list and converts it into a list of lists, each of which
-- is the original list.
expandList :: [a] -> [[a]]
expandList xs = map (\x -> xs) xs

-- Takes a list and indexes the items.
index :: [a] -> [(Int,a)]
index = zip [1..]

And lately:

skips :: [a] -> [[a]]
skips xs = zipWith takeEvery [1..length xs] (repeat xs)

takeEvery :: Int -> [a] -> [a]
takeEvery n xs
| n > length xs = []
| otherwise     = xs !! (n-1) : takeEvery n (drop n xs)

So much cleaner! So much more elegant! It’s rather obvious that I was still thinking imperatively in November and was having a hard time grasping the functional approach.

Per Chris Allen’s learnhaskell repository, my next step is the NICTA course. I’m certainly excited to see how that progresses.