Converting English words to numbers in Haskell

Question

A few weeks ago, I finished a number to word converter and received an excellent review. It caused me to make several fundamental changes to numToWord, such as using a list instead of a pattern matched function, using quotRem, and removing Show constraints. I also tried to use zipWith, but I wasn't sure how to make it work correctly when filtering before uncurrying. However, I'm more interested in improving my newer wordToNum converter. I played a little bit with trying to use Maybe and Nothing instead of defaulting to 0 everywhere, but it got very ugly very fast. Would there be a clean way of using Maybe throughout the module, and would it be better than defaulting to 0? Also, is there a cleaner way of splitting groups and blocks?

module MathSolver.NLP.WordNum (numToWord, wordToNum) where
import Data.Bool (bool)
import Data.Char
import Data.List.Split.Internals
import Data.Maybe
ones :: Integral a => [(String, a)]
ones = [("one",1), ("two",2), ("three",3), ("four",4), ("five",5), ("six",6), ("seven",7),
 ("eight",8), ("nine",9)]
teens :: Integral a => [(String, a)]
teens = [("ten",10), ("eleven",11), ("twelve",12), ("thirteen",13), ("fourteen",14),
 ("fifteen",15), ("sixteen",16), ("seventeen",17), ("eighteen",18), ("nineteen",19)]
tens :: Integral a => [(String, a)]
tens = [("ten",10), ("twenty",20), ("thirty",30), ("forty",40), ("fifty",50), ("sixty",60),
 ("seventy",70), ("eighty",80), ("ninety",90)]
groups :: [String]
groups = ["", " thousand", " million", " billion", " trillion", " quadrillion", " quintillion",
 " sextillion", " septillion", " octillion", " nonillion", " decillion", " undecillion",
 " duodecillion", " tredecillion", " quattuordecillion", " quindecillion", " sexdecillion",
 " septendecillion", " octodecillion", " novemdecillion", " vigintillion"]
-- Maps a word to its power of 10 to calculate a group multiplier
groupList :: Integral a => [(String, a)]
groupList = [("thousand",3), ("million",6), ("billion",9), ("trillion",12), ("quadrillion",15),
 ("quintillion",18), ("sextillion",21), ("septillion",24), ("octillion",27),
 ("nonillion",30), ("decillion",33), ("undecillion",36), ("duodecillion",39),
 ("tredecillion",42), ("quattuordecillion",45), ("quindecillion",48),
 ("sexdecillion",51), ("septendecillion",54), ("octodecillion",57),
 ("novemdecillion",60), ("vigintillion",63)]
{--------------------------------------------------------------------------------------------------}
{--- NUMBER TO WORD CONVERSION ---}
{--------------------------------------------------------------------------------------------------}
-- Converts an Int or Integer to its String representation
numToWord :: Integral a => a -> String
numToWord n
 | n < 0 = "negative " ++ numToWord (-n)
 | n == 0 = "zero"
 | n >= 10^65 = error "numToWord: Doesn't support numbers bigger than vigintillions! (10^65-1)"
 | isHundred = groupToWord d100 ++ " hundred"
 | otherwise = unwords $ reverse buildGroups
 where
 buildGroups = map (uncurry (++)) (filter (\(block,_) -> block /= "") (zip wordGroups groups))
 wordGroups = map groupToWord $ splitNum n
 isHundred = n <= 9000 && r1000 /= 0 && r100 == 0
 r1000 = n `rem` 1000
 (d100,r100) = n `quotRem` 100
-- Splits a number into groups in reverse order
splitNum :: Integral a => a -> [a]
splitNum n
 | d == 0 = [n]
 | otherwise = m : splitNum d
 where
 (d,m) = n `quotRem` 1000
-- Converts a group of digits to a number.
-- A group is usually 1 to 3 digits, but also includes numbers that are multiples of 100, but not
-- 1000, such as 1900. Words are not comma-separated as per the Chicago Manual of Style. This
-- prevents numbers from potentially seeming like a list of smaller numbers.
groupToWord :: Integral a => a -> String
groupToWord n = unwords $ numWords n
 where
 numWords :: Integral a => a -> [String]
 numWords r
 | r < 0 = "negative" : numWords (-r)
 | r == 0 = []
 | r < 10 = [toWord r ones]
 | r < 20 = [toWord r teens]
 | r < 100 && r10 /= 0 = [toWord n10 tens ++ "-" ++ toWord r10 ones]
 | r < 100 = toWord n10 tens : numWords r10
 | r < 1000 = toWord d100 ones : "hundred" : numWords r100
 | otherwise = error "groupToWord: not a 3-digit or hundred group"
 where
 (n10, r10) = (r - r10, r `rem` 10)
 (d100, r100) = r `quotRem` 100
-- Converts a number to a word given a number translation map
toWord :: Integral a => a -> [(String, a)] -> String
toWord n table = fromMaybe "" (lookup n (map swap table))
 where
 swap :: Integral a => (String, a) -> (a, String)
 swap (x,y) = (y,x)
{--------------------------------------------------------------------------------------------------}
{--- WORD TO NUMBER CONVERSION ---}
{--------------------------------------------------------------------------------------------------}
-- Converts a single block to an Int or Integer
wordToNum :: Integral a => String -> a
wordToNum s
 | s == "" = 0
 | isNegative = (-1) * wordToNum (unwords $ tail (words s))
 | otherwise = fromGroups $ splitGroups s
 where
 isNegative = head (words s) `elem` ["negative", "minus"]
-- Splits a full number into blocks on group words, keeping delimeters at the end of each group.
splitGroups :: String -> [String]
splitGroups str = map unwords $ split (dropBlanks $ oneOf groupWords) (words str)
 where
 -- Removes initial space in each entry of `groups` and ignores initial ""
 groupWords = map tail (tail groups)
-- Calculates the total sum of all groups' values
fromGroups :: Integral a => [String] -> a
fromGroups (block:group:bs) = fromBlock (splitBlock block) * (multiplier group) + fromGroups bs
fromGroups [block] = fromBlock (splitBlock block)
fromGroups [] = 0
-- Calculates a group's multiplier, or defaults to 1 (10^0) if the group isn't valid
multiplier :: Integral a => String -> a
multiplier g = 10 ^ fromMaybe 0 (lookup g groupList)
-- Splits a block on "hundred", keeping the delimeter, and cleaning spacing and punctuation
splitBlock :: String -> [String]
splitBlock block = map clean $ split (onSublist "hundred") block
 where
 -- Switches all hyphens to spaces and removes all other non-letters
 clean :: String -> String
 clean w = [bool ' ' c (c /= '-') | c <- (unwords.words) w, isLetter c || c == '-' || c == ' ']
-- Calculates a block's value, defaulting to 0 if there's invalid input
fromBlock :: Integral a => [String] -> a
fromBlock [x,"hundred",y] = fromBlock (words x) * 100 + fromBlock (words y)
fromBlock [x,"hundred"] = fromBlock (words x) * 100
fromBlock [x,y]
 | mapMember x (tail tens) && mapMember y ones = fromWord x tens + fromWord y ones
 | otherwise = 0
fromBlock [w]
 | length (words w) > 1 = fromBlock (words w)
 | mapMember w ones = fromWord w ones
 | mapMember w teens = fromWord w teens
 | mapMember w tens = fromWord w tens
 | otherwise = 0
fromBlock _ = 0
-- Converts a word to its numeric value from a given conversion table
fromWord :: Integral a => String -> [(String, a)] -> a
fromWord word table = fromMaybe 0 (lookup word table)
-- Determines whether a word is a member of a conversion table
mapMember :: Integral a => String -> [(String, a)] -> Bool
mapMember w table = isJust (lookup w table)

Edit: For groupWords in splitGroups, would it be better to use map (\(group,_) -> group) groupList? Similarly, would it be better to replace groups entirely with "" : map (\(group,_) -> " " ++ group) groupList?