diff -rN -u old-split/Data/List/Split/Internals.hs new-split/Data/List/Split/Internals.hs
--- old-split/Data/List/Split/Internals.hs	2012-07-21 09:30:43.000000000 +0200
+++ new-split/Data/List/Split/Internals.hs	2012-07-21 09:30:43.000000000 +0200
@@ -1,4 +1,3 @@
-{-# LANGUAGE GADTs #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.List.Split.Internal
@@ -6,7 +5,7 @@
 -- License     :  BSD-style (see LICENSE)
 -- Maintainer  :  byorgey@gmail.com
 -- Stability   :  stable
--- Portability :  GADTs
+-- Portability :  Haskell 98
 --
 -- Implementation module for "Data.List.Split", a combinator library
 -- for splitting lists.  See the "Data.List.Split" documentation for
@@ -68,14 +67,14 @@
 
 -- | A delimiter can either be a predicate on elements, or a list of
 --   elements to be matched as a subsequence.
-data Delimiter a where
-  DelimEltPred :: (a -> Bool) -> Delimiter a
-  DelimSublist :: Eq a => [a] -> Delimiter a
+data Delimiter a =
+    DelimEltPred (a -> Bool)
+  | DelimSublist [a]
 
 -- | Try to match a delimiter at the start of a list, either failing
 --   or decomposing the list into the portion which matched the delimiter
 --   and the remainder.
-matchDelim :: Delimiter a -> [a] -> Maybe ([a],[a])
+matchDelim :: Eq a => Delimiter a -> [a] -> Maybe ([a],[a])
 matchDelim (DelimEltPred p) (x:xs) | p x       = Just ([x],xs)
                                    | otherwise = Nothing
 matchDelim (DelimEltPred _) [] = Nothing
@@ -137,7 +136,7 @@
 --   representation with chunks tagged as delimiters or text.  This
 --   transformation is lossless; in particular, @'concatMap' 'fromElem'
 --   ('splitInternal' d l) == l@.
-splitInternal :: Delimiter a -> [a] -> SplitList a
+splitInternal :: Eq a => Delimiter a -> [a] -> SplitList a
 splitInternal _ [] = []
 splitInternal d xxs
   | null xs   = toSplitList match
@@ -149,7 +148,7 @@
   toSplitList (Just ([],r:rs))    = Delim [] : Text [r] : splitInternal d rs
   toSplitList (Just (delim,rest)) = Delim delim : splitInternal d rest
 
-breakDelim :: Delimiter a -> [a] -> ([a],Maybe ([a],[a]))
+breakDelim :: Eq a => Delimiter a -> [a] -> ([a],Maybe ([a],[a]))
 breakDelim d@(DelimEltPred p) (x:xs)
   | p x       = ([],Just ([x],xs))
   | otherwise = let (ys,match) = breakDelim d xs in (x:ys,match)
@@ -247,7 +246,7 @@
 -- | Split a list according to the given splitting strategy.  This is
 --   how to \"run\" a 'Splitter' that has been built using the other
 --   combinators.
-split :: Splitter a -> [a] -> [[a]]
+split :: Eq a => Splitter a -> [a] -> [[a]]
 split s = map fromElem . postProcess s . splitInternal (delimiter s)
 
 -- ** Basic strategies
@@ -403,7 +402,7 @@
 --   @'split' . 'dropDelims' . 'whenElt'@.  For example:
 --
 -- > splitWhen (<0) [1,3,-4,5,7,-9,0,2] == [[1,3],[5,7],[0,2]]
-splitWhen :: (a -> Bool) -> [a] -> [[a]]
+splitWhen :: Eq a => (a -> Bool) -> [a] -> [[a]]
 splitWhen = split . dropDelims . whenElt
 
 -- | A synonym for 'splitOn'.
@@ -449,7 +448,7 @@
 --   @split . dropBlanks . dropDelims . whenElt@.  For example:
 --
 -- > wordsBy (=='x') "dogxxxcatxbirdxx" == ["dog","cat","bird"]
-wordsBy :: (a -> Bool) -> [a] -> [[a]]
+wordsBy :: Eq a => (a -> Bool) -> [a] -> [[a]]
 wordsBy = split . dropBlanks . dropDelims . whenElt
 
 -- | Split into lines, with line boundaries indicated by the given
@@ -457,7 +456,7 @@
 --   @split . dropFinalBlank . dropDelims . whenElt@.  For example:
 --
 -- > linesBy (=='x') "dogxxxcatxbirdxx" == ["dog","","","cat","bird",""]
-linesBy :: (a -> Bool) -> [a] -> [[a]]
+linesBy :: Eq a => (a -> Bool) -> [a] -> [[a]]
 linesBy = split . dropFinalBlank . dropDelims . whenElt
 
 -- * Other splitting methods
diff -rN -u old-split/Data/List/Split.hs new-split/Data/List/Split.hs
--- old-split/Data/List/Split.hs	2012-07-21 09:30:43.000000000 +0200
+++ new-split/Data/List/Split.hs	2012-07-21 09:30:43.000000000 +0200
@@ -5,7 +5,7 @@
 -- License     :  BSD-style (see LICENSE)
 -- Maintainer  :  Brent Yorgey <byorgey@gmail.com>
 -- Stability   :  stable
--- Portability :  GADTs
+-- Portability :  Haskell 98
 --
 -- The "Data.List.Split" module contains a wide range of strategies
 -- for splitting lists with respect to some sort of delimiter, mostly