Maybe reduction pass 2

Command.hs

@@ -91,20 +91,12 @@ prepCommand Command { cmdseek = seek } params = do
 
 {- Runs a command through the start, perform and cleanup stages -}
 doCommand :: CommandStart -> CommandCleanup
-doCommand start = do
+doCommand = start
-	s <- start
+	where
-	case s of
+		start   = stage $ maybe (return True) perform
-		Nothing -> return True
+		perform = stage $ maybe (showEndFail >> return False) cleanup
-		Just perform -> do
+		cleanup = stage $ \r -> showEndResult r >> return r
-			p <- perform
+		stage a b = b >>= a
-			case p of
-				Nothing -> do
-					showEndFail
-					return False
-				Just cleanup -> do
-					c <- cleanup
-					if c then showEndOk else showEndFail
-					return c
 
 notAnnexed :: FilePath -> Annex (Maybe a) -> Annex (Maybe a)
 notAnnexed file a = maybe a (const $ return Nothing) =<< Backend.lookupFile file

GitRepo.hs

@@ -210,9 +210,9 @@ assertUrl repo action =
 				" not supported"
 
 configBare :: Repo -> Bool
-configBare repo = case Map.lookup "core.bare" $ config repo of
+configBare repo = maybe unknown configTrue $ Map.lookup "core.bare" $ config repo
-	Just v -> configTrue v
+	where
-	Nothing -> error $ "it is not known if git repo " ++
+		unknown = error $ "it is not known if git repo " ++
 			repoDescribe repo ++
 			" is a bare repository; config not read"
 
@@ -260,11 +260,10 @@ workTreeFile repo@(Repo { location = Dir d }) file = do
 	where
 		-- normalize both repo and file, so that repo
 		-- will be substring of file
-		absrepo = case (absNormPath "/" d) of
+		absrepo = maybe bad addTrailingPathSeparator $ absNormPath "/" d
-			Just f -> addTrailingPathSeparator f
-			Nothing -> error $ "bad repo" ++ repoDescribe repo
 		absfile c = maybe file id $ secureAbsNormPath c file
 		inrepo f = absrepo `isPrefixOf` f
+		bad = error $ "bad repo" ++ repoDescribe repo
 workTreeFile repo _ = assertLocal repo $ error "internal"
 
 {- Path of an URL repo. -}
@@ -627,23 +626,19 @@ expandTilde = expandt True
 
 {- Finds the current git repository, which may be in a parent directory. -}
 repoFromCwd :: IO Repo
-repoFromCwd = do
+repoFromCwd = getCurrentDirectory >>= seekUp isRepoTop >>= maybe norepo makerepo
-	cwd <- getCurrentDirectory
+	where
-	top <- seekUp cwd isRepoTop
+		makerepo = return . newFrom . Dir
-	case top of
+		norepo = error "Not in a git repository."
-		-- repoFromAbsPath is not used to avoid looking for
-		-- "dir.git" directories.
-		(Just dir) -> return $ newFrom $ Dir dir
-		Nothing -> error "Not in a git repository."
 
-seekUp :: FilePath -> (FilePath -> IO Bool) -> IO (Maybe FilePath)
+seekUp :: (FilePath -> IO Bool) -> FilePath -> IO (Maybe FilePath)
-seekUp dir want = do
+seekUp want dir = do
 	ok <- want dir
 	if ok
 		then return (Just dir)
 		else case (parentDir dir) of
 			"" -> return Nothing
-			d -> seekUp d want
+			d -> seekUp want d
 
 isRepoTop :: FilePath -> IO Bool
 isRepoTop dir = do

Messages.hs

@@ -45,6 +45,10 @@ showEndOk = verbose $ liftIO $ putStrLn "ok"
 showEndFail :: Annex ()
 showEndFail = verbose $ liftIO $ putStrLn "\nfailed"
 
+showEndResult :: Bool -> Annex ()
+showEndResult True = showEndOk
+showEndResult False = showEndFail
+
 showErr :: (Show a) => a -> Annex ()
 showErr e = warning $ "git-annex: " ++ show e
 

Remote/Encryptable.hs

@@ -54,21 +54,14 @@ encryptableRemote c storeKeyEncrypted retrieveKeyFileEncrypted r =
 		cost = cost r + encryptedRemoteCostAdj
 	}
 	where
-		store k = do
+		store k = cip k >>= maybe
-			v <- cipherKey c k
+			(storeKey r k)
-			case v of
+			(\x -> storeKeyEncrypted x k)
-				Nothing -> (storeKey r) k
+		retrieve k f = cip k >>= maybe
-				Just x -> storeKeyEncrypted x k
+			(retrieveKeyFile r k f)
-		retrieve k f = do
+			(\x -> retrieveKeyFileEncrypted x f)
-			v <- cipherKey c k
+		withkey a k = cip k >>= maybe (a k) (a . snd)
-			case v of
+		cip = cipherKey c
-				Nothing -> (retrieveKeyFile r) k f
-				Just x -> retrieveKeyFileEncrypted x f
-		withkey a k = do
-			v <- cipherKey c k
-			case v of
-				Nothing -> a k
-				Just (_, k') -> a k'
 
 {- Gets encryption Cipher. The decrypted Cipher is cached in the Annex
  - state. -}
@@ -87,10 +80,8 @@ remoteCipher c = maybe expensive cached =<< Annex.getState Annex.cipher
 {- Gets encryption Cipher, and encrypted version of Key. -}
 cipherKey :: Maybe RemoteConfig -> Key -> Annex (Maybe (Cipher, Key))
 cipherKey Nothing _ = return Nothing
-cipherKey (Just c) k = do
+cipherKey (Just c) k = remoteCipher c >>= maybe (return Nothing) encrypt
-	cipher <- remoteCipher c
+	where
-	case cipher of	
+		encrypt ciphertext = do
-		Just ciphertext -> do
 			k' <- liftIO $ encryptKey ciphertext k
 			return $ Just (ciphertext, k')
-		Nothing -> return Nothing