some work on avoiding partial functions

There are still hundreds of places that use partial functions head, tail,
init, and last.

Command/DropUnused.hs

@@ -73,6 +73,6 @@ readUnusedLog prefix = do
 		then M.fromList . map parse . lines <$> liftIO (readFile f)
 		else return M.empty
 	where
-		parse line = (num, fromJust $ readKey $ tail rest)
+		parse line = (num, fromJust $ readKey rest)
 			where
-				(num, rest) = break (== ' ') line
+				(num, rest) = separate (== ' ') line

Git.hs

@@ -507,11 +507,7 @@ configStore s repo = do
 configParse :: String -> M.Map String String
 configParse s = M.fromList $ map pair $ lines s
 	where
-		pair l = (key l, val l)
+		pair = separate (== '=')
-		key l = head $ keyval l
-		val l = join sep $ drop 1 $ keyval l
-		keyval l = split sep l :: [String]
-		sep = "="
 
 {- Calculates a list of a repo's configured remotes, by parsing its config. -}
 configRemotes :: Repo -> IO [Repo]
@@ -550,13 +546,11 @@ genRemote s repo = gen $ calcloc s
 		scpstyle v = ":" `isInfixOf` v && not ("//" `isInfixOf` v)
 		scptourl v = "ssh://" ++ host ++ slash dir
 			where
-				bits = split ":" v
+				(host, dir) = separate (== ':') v
-				host = head bits
+				slash d	| d == "" = "/~/" ++ d
-				dir = join ":" $ drop 1 bits
+					| "/" `isPrefixOf` d = d
-				slash d	| d == "" = "/~/" ++ dir
+					| "~" `isPrefixOf` d = '/':d
-					| head d == '/' = dir
+					| otherwise = "/~/" ++ d
-					| head d == '~' = '/':dir
-					| otherwise = "/~/" ++ dir
 
 {- Checks if a string from git config is a true value. -}
 configTrue :: String -> Bool

Utility/BadPrelude.hs

@@ -0,0 +1,24 @@
+{- Some stuff from Prelude should not be used, as it tends to be a source
+ - of bugs.
+ -
+ - This exports functions that conflict with the prelude, which avoids
+ - them being accidentially used.
+ -}
+
+module Utility.BadPrelude where
+
+{- head is a partial function; head [] is an error -}
+head :: [a] -> a
+head = Prelude.head
+
+{- tail is also partial -}
+tail :: [a] -> a
+tail = Prelude.tail
+
+{- init too -}
+init :: [a] -> a
+init = Prelude.init
+
+{- last too -}
+last :: [a] -> a
+last = Prelude.last

Utility/Misc.hs

@@ -27,6 +27,19 @@ readMaybe s = case reads s of
 	((x,_):_) -> Just x
 	_ -> Nothing
 
+{- Like break, but the character matching the condition is not included
+ - in the second result list.
+ -
+ - separate (== ':') "foo:bar" = ("foo", "bar")
+ - separate (== ':') "foobar" = ("foo, "")
+ -}
+separate :: (a -> Bool) -> [a] -> ([a], [a])
+separate c l = unbreak $ break c l
+	where
+		unbreak r@(a, b)
+			| null b = r
+			| otherwise = (a, tail b)
+
 {- Catches IO errors and returns a Bool -}
 catchBoolIO :: IO Bool -> IO Bool
 catchBoolIO a = catchDefaultIO a False