Question

My assignment problem is to find all non-overlapping occurences of a substring in a string and return the a list of starting indices of occurences found.

My code so far is:

-- return True when `e` (haystack) starts with `s` (needle)
_startsWith :: String -> String -> Bool
-- Anything starts with the empty string
_startsWith _ "" = True
-- An empty string cannot start with a nonempty string 
_startsWith "" (h:t) = False 
_startsWith (eh:et) (sh:st) = (eh==sh) && (_startsWith et st)

-- look for all occurences of `s` (needle) in `e` (haystack), accumulating 
-- start indices of occurences in `is`
_findAll :: [Integer] -> Integer -> String -> String -> [Integer]
_findAll is i e s
    | null e = is -- end of haystack reached, return indices found so far
    | _startsWith e s = i:(rest $ length s) -- needle found, skip its length
    | otherwise = rest (1::Int) -- needle not found, advance by one character
          -- search the rest of the string after advancing by `skip` characters
    where rest skip = _findAll is (i+skip) (drop skip e) s

GHCi and Hugs give me different type errors. The GHC one is:

Couldn't match expected type `Int' with actual type `Integer'
In the first argument of `drop', namely `skip'
In the third argument of `_findAll', namely `(drop skip e)'
In the expression: _findAll is (i + skip) (drop skip e) s

The Hugs one is:

Type error in application
*** Expression     : i + skip
*** Term           : i
*** Type           : Integer
*** Does not match : Int

From this I’m guessing the problem is that skip is used in a context that expects an Int, and a context that expects an Integral, and this can’t be resolved because there is no typeclass that would allow this.

Assuming homework restrictions – the signature of _findAll may not be changed, preferrably importing no libraries except Prelude, definitely not importing any libraries not available on a basic apt-get installation of Hugs – how can I resolve this type error? I tried randomly sprinkling fromInteger and fromIntegral around to little success, and I’m not familiar enough with ugliness that is Haskell numeric typeclasses to figure this out.

Answer 1

One simple solution is to use the generic versions genericDrop and genericLength found in Data.List. These will work with any Integral type, not just Int.