Made package stack compatible

Created and added stack.yaml and .gitignore files.
Relaxed the version dependency on 'binary' package in cabal file.  Is that OK?
Also brought the minimum cabal version to >=1.8, so I could add a test target that pulls in the library.
Changed all tabs to spaces - I don't know when the Haskell compiler started giving warnings about that.

Author: ScottSedgwick

.gitignore

@@ -0,0 +1,22 @@
+### Haskell ###
+dist
+dist-*
+cabal-dev
+*.o
+*.hi
+*.chi
+*.chs.h
+*.dyn_o
+*.dyn_hi
+.hpc
+.hsenv
+.cabal-sandbox/
+cabal.sandbox.config
+*.prof
+*.aux
+*.hp
+*.eventlog
+.stack-work/
+cabal.project.local
+.HTF/
+

Data/Encoding.hs

@@ -359,6 +359,6 @@ encodingFromStringExplicit codeName = case (normalizeEncoding codeName) of
 -- | Takes the name of an encoding and creates a dynamic encoding from it.
 encodingFromString :: String -> DynEncoding
 encodingFromString str = maybe
-	(error $ "Data.Encoding.encodingFromString: Unknown encoding: "++show str)
-	id
-	(encodingFromStringExplicit str)
+    (error $ "Data.Encoding.encodingFromString: Unknown encoding: "++show str)
+    id
+    (encodingFromStringExplicit str)

Data/Encoding/BootString.hs

@@ -2,8 +2,8 @@
 {- | This implements BootString en- and decoding, the foundation of Punycode
  -}
 module Data.Encoding.BootString
-	(BootString(..)
-	,punycode) where
+    (BootString(..)
+    ,punycode) where
 
 import Data.Encoding.Base
 import Data.Encoding.Exception
@@ -17,77 +17,77 @@ import Data.Typeable
 import Control.Monad (when)
 
 data BootString = BootString
-	{base :: Int
-	,tmin :: Int
-	,tmax :: Int
-	,skew :: Int
-	,damp :: Int
-	,init_bias :: Int
-	,init_n    :: Int
-	}
-	deriving (Show,Eq,Typeable)
+    {base :: Int
+    ,tmin :: Int
+    ,tmax :: Int
+    ,skew :: Int
+    ,damp :: Int
+    ,init_bias :: Int
+    ,init_n    :: Int
+    }
+    deriving (Show,Eq,Typeable)
 
 punycode :: BootString
 punycode = BootString
-	{base = 36
-	,tmin = 1
-	,tmax = 26
-	,skew = 38
-	,damp = 700
-	,init_bias = 72
-	,init_n    = 0x80
-	}
+    {base = 36
+    ,tmin = 1
+    ,tmax = 26
+    ,skew = 38
+    ,damp = 700
+    ,init_bias = 72
+    ,init_n    = 0x80
+    }
 
 punyValue :: ByteSource m => Word8 -> m Int
 punyValue c
-	| n <  0x30 = norep
-	| n <= 0x39 = return $ n-0x30+26
-	| n <  0x41 = norep
-	| n <= 0x5A = return $ n-0x41
-	| n <  0x61 = norep
-	| n <= 0x7A = return $ n-0x61
-	| otherwise = norep
-	where
-	n = fromIntegral c
-	norep = throwException (IllegalCharacter c)
+    | n <  0x30 = norep
+    | n <= 0x39 = return $ n-0x30+26
+    | n <  0x41 = norep
+    | n <= 0x5A = return $ n-0x41
+    | n <  0x61 = norep
+    | n <= 0x7A = return $ n-0x61
+    | otherwise = norep
+    where
+    n = fromIntegral c
+    norep = throwException (IllegalCharacter c)
 
 punyChar :: ByteSink m => Int -> m Word8
 punyChar c
-	| c < 0  = norep
-	| c < 26 = return $ fromIntegral $ 0x61+c
-	| c < 36 = return $ fromIntegral $ 0x30+c-26
-	| otherwise = norep
-	where
-	norep = throwException (HasNoRepresentation (chr c))
+    | c < 0  = norep
+    | c < 26 = return $ fromIntegral $ 0x61+c
+    | c < 36 = return $ fromIntegral $ 0x30+c-26
+    | otherwise = norep
+    where
+    norep = throwException (HasNoRepresentation (chr c))
 
 getT :: BootString -> Int -> Int -> Int
 getT bs k bias
-	| k <= bias + (tmin bs) = tmin bs
-	| k >= bias + (tmax bs) = tmax bs
-	| otherwise             = k-bias
+    | k <= bias + (tmin bs) = tmin bs
+    | k >= bias + (tmax bs) = tmax bs
+    | otherwise             = k-bias
 
 adapt :: BootString -> Int -> Int -> Bool -> Int
 adapt bs delta numpoints firsttime = let
-	delta1 = if firsttime
-		then delta `div` (damp bs)
-		else delta `div` 2
-	delta2 = delta1 + (delta1 `div` numpoints)
-	(rd,rk) = head
-		$ filter ((<=((base bs - tmin bs) * (tmax bs)) `div` 2).fst)
-		$ iterate (\(d,k) -> (d `div` (base bs - tmin bs),k+(base bs))) (delta2,0)
-	in rk + (((base bs - tmin bs +1) * rd) `div` (rd + skew bs))
+    delta1 = if firsttime
+        then delta `div` (damp bs)
+        else delta `div` 2
+    delta2 = delta1 + (delta1 `div` numpoints)
+    (rd,rk) = head
+        $ filter ((<=((base bs - tmin bs) * (tmax bs)) `div` 2).fst)
+        $ iterate (\(d,k) -> (d `div` (base bs - tmin bs),k+(base bs))) (delta2,0)
+    in rk + (((base bs - tmin bs +1) * rd) `div` (rd + skew bs))
 
 decodeValue :: ByteSource m => BootString -> Int -> Int -> Int -> Int -> [Int] -> m (Int,[Int])
 decodeValue bs bias i k w (x:xs)
-	| x >= base bs                     = throwException OutOfRange
-	| x > (maxBound - i) `div` w       = throwException OutOfRange
-	| x <  t                           = return (ni,xs)
-	| w > maxBound `div` (base bs - t) = throwException OutOfRange
+    | x >= base bs                     = throwException OutOfRange
+    | x > (maxBound - i) `div` w       = throwException OutOfRange
+    | x <  t                           = return (ni,xs)
+    | w > maxBound `div` (base bs - t) = throwException OutOfRange
         | null xs                          = throwException OutOfRange
-	| otherwise = decodeValue bs bias ni (k+base bs) (w*(base bs - t)) xs
-	where
-	ni = i + x*w
-	t  = getT bs k bias
+    | otherwise = decodeValue bs bias ni (k+base bs) (w*(base bs - t)) xs
+    where
+    ni = i + x*w
+    t  = getT bs k bias
 
 decodeValues :: ByteSource m => BootString -> Int -> [Int] -> m [(Char,Int)]
 decodeValues bs len xs = decodeValues' bs (init_n bs) 0 (init_bias bs) len xs
@@ -108,8 +108,8 @@ decodeValues' bs n i bias len xs = do
 insertDeltas :: [(a,Int)] -> [a] -> [a]
 insertDeltas [] str     = str
 insertDeltas ((c,p):xs) str = let
-	(l,r) = splitAt p str
-	in insertDeltas xs (l++[c]++r)
+    (l,r) = splitAt p str
+    in insertDeltas xs (l++[c]++r)
 
 punyDecode :: ByteSource m => [Word8] -> [Word8] -> m String
 punyDecode base ext = do
@@ -119,32 +119,32 @@ punyDecode base ext = do
 
 encodeValue :: BootString -> Int -> Int -> Int -> Int -> [Int]
 encodeValue bs bias delta n c = unfoldr (\(q,k,out) -> let
-		t = getT bs k bias
-		(nq,dc) = (q-t) `divMod` (base bs - t)
-		in if out
-			then Nothing
-			else (if q < t
-				then Just (q,(q,k+base bs,True))
-				else Just (t + dc,(nq,k+base bs,False)))
-		) (delta,base bs,False)
+        t = getT bs k bias
+        (nq,dc) = (q-t) `divMod` (base bs - t)
+        in if out
+            then Nothing
+            else (if q < t
+                then Just (q,(q,k+base bs,True))
+                else Just (t + dc,(nq,k+base bs,False)))
+        ) (delta,base bs,False)
 
 encodeValues' :: BootString -> Int -> Int -> Int -> Int -> Int -> [Int] -> (Int,Int,Int,[Int])
 encodeValues' _  _ h bias delta _ []     = (delta,h,bias,[])
 encodeValues' bs b h bias delta n (c:cs) = case compare c n of
-	LT -> encodeValues' bs b h bias (delta+1) n cs
-	GT -> encodeValues' bs b h bias delta n cs
-	EQ -> let
-		(ndelta,nh,nbias,rest) = encodeValues' bs b (h+1) (adapt bs delta (h+1) (h==b)) 0 n cs
-		xs = encodeValue bs bias delta n c
-		in (ndelta,nh,nbias,xs++rest)
+    LT -> encodeValues' bs b h bias (delta+1) n cs
+    GT -> encodeValues' bs b h bias delta n cs
+    EQ -> let
+        (ndelta,nh,nbias,rest) = encodeValues' bs b (h+1) (adapt bs delta (h+1) (h==b)) 0 n cs
+        xs = encodeValue bs bias delta n c
+        in (ndelta,nh,nbias,xs++rest)
 
 encodeValues :: BootString -> Int -> Int -> Int -> Int -> Int -> Int -> [Int] -> [Int]
 encodeValues bs b l h bias delta n cps
-	| h == l = []
-	| otherwise = outp++encodeValues bs b l nh nbias (ndelta+1) (m+1) cps
-	where
-	m = minimum (filter (>=n) cps)
-	(ndelta,nh,nbias,outp) = encodeValues' bs b h bias (delta + (m - n)*(h + 1)) m cps
+    | h == l = []
+    | otherwise = outp++encodeValues bs b l nh nbias (ndelta+1) (m+1) cps
+    where
+    m = minimum (filter (>=n) cps)
+    (ndelta,nh,nbias,outp) = encodeValues' bs b h bias (delta + (m - n)*(h + 1)) m cps
 
 breakLast :: (a -> Bool) -> [a] -> Maybe ([a],[a])
 breakLast p xs = do
@@ -166,7 +166,7 @@ instance Encoding BootString where
     encodeChar _ c = error "Data.Encoding.BootString.encodeChar: Please use 'encode' for encoding BootStrings"
     decodeChar _ = error "Data.Encoding.BootString.decodeChar: Please use 'decode' for decoding BootStrings"
     encode bs str = let (base,nbase) = partition (\c -> ord c < init_n bs) str
-	                b = length base
+                        b = length base
                     in do
                       res <- mapM punyChar $ encodeValues bs b (length str) b (init_bias bs) 0 (init_n bs) (map ord str)
                       when (not $ null base) $ do
@@ -178,8 +178,8 @@ instance Encoding BootString where
       let m = fromIntegral $ ord '-'
       case breakLast (==m) wrds of
         Just ([],_) -> throwException (IllegalCharacter m)
-	Just (base,_:nbase) -> case find (\w -> fromIntegral w > init_n bs) base of
-                                Nothing -> punyDecode base nbase
-                                Just ww -> throwException (IllegalCharacter ww)
-	Nothing -> punyDecode [] wrds
+        Just (base,_:nbase) -> case find (\w -> fromIntegral w > init_n bs) base of
+                                 Nothing -> punyDecode base nbase
+                                 Just ww -> throwException (IllegalCharacter ww)
+        Nothing -> punyDecode [] wrds
     encodeable bs c = True -- XXX: hm, really?

Data/Encoding/Exception.hs

@@ -9,22 +9,22 @@ import Control.Monad.Identity
 -- | This exception type is thrown whenever something went wrong during the
 --   encoding-process.
 data EncodingException
-    = HasNoRepresentation Char	-- ^ Thrown if a specific character
-				--   is not representable in an encoding.
+    = HasNoRepresentation Char  -- ^ Thrown if a specific character
+                                --   is not representable in an encoding.
     deriving (Eq,Ord,Show,Read,Typeable)
 
 instance Exception EncodingException
 
 -- | This exception type is thrown whenever something went wrong during the
 --   decoding-process.
 data DecodingException
-    = IllegalCharacter Word8	-- ^ The sequence contained an illegal
-				--   byte that couldn't be decoded.
-    | UnexpectedEnd		-- ^ more bytes were needed to allow a
-				--   successfull decoding.
-    | OutOfRange		-- ^ the decoded value was out of the unicode range
-    | IllegalRepresentation [Word8]	-- ^ The character sequence encodes a
-					--   character, but is illegal.
+    = IllegalCharacter Word8        -- ^ The sequence contained an illegal
+                                    --   byte that couldn't be decoded.
+    | UnexpectedEnd                 -- ^ more bytes were needed to allow a
+                                    --   successfull decoding.
+    | OutOfRange                    -- ^ the decoded value was out of the unicode range
+    | IllegalRepresentation [Word8] -- ^ The character sequence encodes a
+                                    --   character, but is illegal.
     deriving (Eq,Ord,Show,Read,Typeable)
 
 instance Exception DecodingException

Data/Encoding/KOI8R.hs

@@ -3,7 +3,7 @@
      See <http://en.wikipedia.org/wiki/KOI8-R> for more information.
  -}
 module Data.Encoding.KOI8R
-	(KOI8R(..)) where
+    (KOI8R(..)) where
 
 import Control.Throws
 import Data.Array.Unboxed
@@ -28,23 +28,23 @@ koi8rMap = fromList (zip koi8rList [128..])
 
 koi8rList :: [Char]
 koi8rList =
-	['\x2500','\x2502','\x250c','\x2510','\x2514','\x2518','\x251c','\x2524'
-	,'\x252c','\x2534','\x253c','\x2580','\x2584','\x2588','\x258c','\x2590'
-	,'\x2591','\x2592','\x2593','\x2320','\x25a0','\x2219','\x221a','\x2248'
-	,'\x2264','\x2265','\x00a0','\x2321','\x00b0','\x00b2','\x00b7','\x00f7'
-	,'\x2550','\x2551','\x2552','\x0451','\x2553','\x2554','\x2555','\x2556'
-	,'\x2557','\x2558','\x2559','\x255a','\x255b','\x255c','\x255d','\x255e'
-	,'\x255f','\x2560','\x2561','\x0401','\x2562','\x2563','\x2564','\x2565'
-	,'\x2566','\x2567','\x2568','\x2569','\x256a','\x256b','\x256c','\x00a9'
-	,'\x044e','\x0430','\x0431','\x0446','\x0434','\x0435','\x0444','\x0433'
-	,'\x0445','\x0438','\x0439','\x043a','\x043b','\x043c','\x043d','\x043e'
-	,'\x043f','\x044f','\x0440','\x0441','\x0442','\x0443','\x0436','\x0432'
-	,'\x044c','\x044b','\x0437','\x0448','\x044d','\x0449','\x0447','\x044a'
-	,'\x042e','\x0410','\x0411','\x0426','\x0414','\x0415','\x0424','\x0413'
-	,'\x0425','\x0418','\x0419','\x041a','\x041b','\x041c','\x041d','\x041e'
-	,'\x041f','\x042f','\x0420','\x0421','\x0422','\x0423','\x0416','\x0412'
-	,'\x042c','\x042b','\x0417','\x0428','\x042d','\x0429','\x0427','\x042a'
-	]
+    ['\x2500','\x2502','\x250c','\x2510','\x2514','\x2518','\x251c','\x2524'
+    ,'\x252c','\x2534','\x253c','\x2580','\x2584','\x2588','\x258c','\x2590'
+    ,'\x2591','\x2592','\x2593','\x2320','\x25a0','\x2219','\x221a','\x2248'
+    ,'\x2264','\x2265','\x00a0','\x2321','\x00b0','\x00b2','\x00b7','\x00f7'
+    ,'\x2550','\x2551','\x2552','\x0451','\x2553','\x2554','\x2555','\x2556'
+    ,'\x2557','\x2558','\x2559','\x255a','\x255b','\x255c','\x255d','\x255e'
+    ,'\x255f','\x2560','\x2561','\x0401','\x2562','\x2563','\x2564','\x2565'
+    ,'\x2566','\x2567','\x2568','\x2569','\x256a','\x256b','\x256c','\x00a9'
+    ,'\x044e','\x0430','\x0431','\x0446','\x0434','\x0435','\x0444','\x0433'
+    ,'\x0445','\x0438','\x0439','\x043a','\x043b','\x043c','\x043d','\x043e'
+    ,'\x043f','\x044f','\x0440','\x0441','\x0442','\x0443','\x0436','\x0432'
+    ,'\x044c','\x044b','\x0437','\x0448','\x044d','\x0449','\x0447','\x044a'
+    ,'\x042e','\x0410','\x0411','\x0426','\x0414','\x0415','\x0424','\x0413'
+    ,'\x0425','\x0418','\x0419','\x041a','\x041b','\x041c','\x041d','\x041e'
+    ,'\x041f','\x042f','\x0420','\x0421','\x0422','\x0423','\x0416','\x0412'
+    ,'\x042c','\x042b','\x0417','\x0428','\x042d','\x0429','\x0427','\x042a'
+    ]
 
 instance Encoding KOI8R where
     decodeChar _ = do
@@ -53,8 +53,8 @@ instance Encoding KOI8R where
         then return $ chr $ fromIntegral w
         else return $ koi8rArr!w
     encodeChar _ ch
-	| ch < '\128' = pushWord8 $ fromIntegral $ ord ch
-	| otherwise   = case lookup ch koi8rMap of
-		Just w -> pushWord8 w
-		Nothing -> throwException (HasNoRepresentation ch)
+      | ch < '\128' = pushWord8 $ fromIntegral $ ord ch
+      | otherwise   = case lookup ch koi8rMap of
+                        Just w -> pushWord8 w
+                        Nothing -> throwException (HasNoRepresentation ch)
     encodeable _ c = member c koi8rMap