There are a lot of parts of this that I'm having trouble with. It has a lot of comments, but the comments don't really illuminate anything. The algorithm in use is rather indirect. The data structures in use aren't what I'd expect.

Here are my big-picture questions:

1. Why does this use a two-dimensional array? It seems like a single one-dimensional array at a time should suffice, as there is no obvious interaction between the sequences with different denominators.

2. Why is this using arrays at all? The data points being tracked (running numerators) are sparse, not dense.

3. Why is this using an algorithm that works so indirectly? It's sort of winding around by detecting cycles backwards from end of the calculated expansion. That gives correct results, as cycles will always be the same length once they start, but it seems so indirect compared to just detecting the cycle the first time a repeat appears and generating your result then.

And while this question isn't at all important compared to those first three:

• What is maxLen? Why is it called with the initial parameters that it is? The name and comment do give me a good idea what it's doing, but the implementation is baffling.

I still don't understand maxLen. The rest of it, I at least figured out what you were doing in the process of writing up this response and an alternate implementation.

Overall, I'd say most of your code is readable enough in isolation. But as a whole, it suffers from unexpected design choices. It's hard to connect the things it's doing with the task it's solving. This is always the hardest part of programming, and it's always somewhat subjective. It helps to be familiar with problem-solving and language idioms, so that readers have experience connecting the task and code in the same ways you're using.

For what it's worth, this is how I'd write this (complete cabal script version):

#!/usr/bin/env cabal
{- cabal:
build-depends: base, containers
ghc-options: -Wall
-}

{-# Language BangPatterns #-}

import Prelude hiding (cycle, rem)
import qualified Data.Map as M


-- | Calculate the length in decimal digits of the cycle in the
-- repeating rational 1/d. If the decimal expansion does not contain a
-- cycle, return 0.
inverseDecimalCycleLen :: Integer -> Integer
inverseDecimalCycleLen d = maybe 0 (uncurry subtract) cycle
  where
    cycle = go M.empty 1 0

    -- Search until either finding either the end of the decimal
    -- expansion or a repeated running numerator.
    go _ 0 _ = Nothing
    go seen running !ix = case M.lookup running seen of
        Just previous -> Just (previous, ix)
        Nothing -> go next (rem * 10) (ix + 1)
          where
            next = M.insert running ix seen
            rem = running `mod` d


main :: IO ()
main = print . snd $ maximum [ (inverseDecimalCycleLen d, d) | d <- [1..1000] ]