diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# `nix-diff 1.0.1`
+# `nix-diff 1.0.2`
 
 This package provides a `nix-diff` executable which explains why two Nix
 derivations differ.  The most common use cases for this are:
diff --git a/nix-diff.cabal b/nix-diff.cabal
--- a/nix-diff.cabal
+++ b/nix-diff.cabal
@@ -1,5 +1,5 @@
 name:                nix-diff
-version:             1.0.1
+version:             1.0.2
 synopsis:            Explain why two Nix derivations differ
 description:         This package provides a @nix-diff@ executable which
                      explains why two Nix derivations (i.e. @*.drv@ files)
@@ -24,7 +24,7 @@
                      , Diff             >= 0.3  && < 0.4
                      , text             >= 1.2  && < 1.3
                      , system-filepath  >= 0.4  && < 0.5
-                     , optparse-generic >= 1.1  && < 1.3
+                     , optparse-generic >= 1.1  && < 1.4
                      , nix-derivation   >= 1.0  && < 1.1
                      , mtl              >= 2.2  && < 2.3
                      , unix                        < 2.8
diff --git a/src/Main.hs b/src/Main.hs
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -408,54 +408,53 @@
 
             let leftInputs  = groupByName (Nix.Derivation.inputDrvs leftDerivation)
             let rightInputs = groupByName (Nix.Derivation.inputDrvs rightDerivation)
-    
+
             let leftNames  = Data.Map.keysSet leftInputs
             let rightNames = Data.Map.keysSet rightInputs
             let leftExtraNames  = Data.Set.difference leftNames  rightNames
             let rightExtraNames = Data.Set.difference rightNames leftNames
 
-            if leftNames /= rightNames
-            then do
+            Control.Monad.State.when (leftNames /= rightNames) $ do
                 echo (explain "The set of input names do not match:")
                 diffWith leftExtraNames rightExtraNames $ \(sign, names) -> do
                     forM_ names $ \name -> do
                         echo ("    " <> sign name)
-            else do 
-                let assocs = Data.Map.toList (innerJoin leftInputs rightInputs)
-                descended <- forM assocs $ \(inputName, (leftPaths, rightPaths)) -> do
-                    let leftExtraPaths =
-                            Data.Map.difference leftPaths  rightPaths
-                    let rightExtraPaths =
-                            Data.Map.difference rightPaths leftPaths
-                    case (Data.Map.toList leftExtraPaths, Data.Map.toList rightExtraPaths) of
-                        _   | leftPaths == rightPaths -> do
-                            return False
-                        ([(leftPath', leftOutputs')], [(rightPath', rightOutputs')])
-                            | leftOutputs' == rightOutputs' -> do
-                            echo (explain ("The input named `" <> inputName <> "` differs"))
-                            indented 2 (diff leftPath' leftOutputs' rightPath' rightOutputs')
-                            return True
-                        _ -> do
-                            echo (explain ("The set of inputs named `" <> inputName <> "` do not match"))
-                            diffWith leftExtraPaths rightExtraPaths $ \(sign, extraPaths) -> do
-                                forM_ (Data.Map.toList extraPaths) $ \(extraPath, outputs) -> do
-                                    echo ("    " <> sign (pathToText extraPath <> renderOutputs outputs))
-                            return False
-                if or descended
+
+            let assocs = Data.Map.toList (innerJoin leftInputs rightInputs)
+            descended <- forM assocs $ \(inputName, (leftPaths, rightPaths)) -> do
+                let leftExtraPaths =
+                        Data.Map.difference leftPaths  rightPaths
+                let rightExtraPaths =
+                        Data.Map.difference rightPaths leftPaths
+                case (Data.Map.toList leftExtraPaths, Data.Map.toList rightExtraPaths) of
+                    _   | leftPaths == rightPaths -> do
+                        return False
+                    ([(leftPath', leftOutputs')], [(rightPath', rightOutputs')])
+                        | leftOutputs' == rightOutputs' -> do
+                        echo (explain ("The input named `" <> inputName <> "` differs"))
+                        indented 2 (diff leftPath' leftOutputs' rightPath' rightOutputs')
+                        return True
+                    _ -> do
+                        echo (explain ("The set of inputs named `" <> inputName <> "` do not match"))
+                        diffWith leftExtraPaths rightExtraPaths $ \(sign, extraPaths) -> do
+                            forM_ (Data.Map.toList extraPaths) $ \(extraPath, outputs) -> do
+                                echo ("    " <> sign (pathToText extraPath <> renderOutputs outputs))
+                        return False
+            if or descended
+            then return ()
+            else do
+                let leftSrcs  = Nix.Derivation.inputSrcs leftDerivation
+                let rightSrcs = Nix.Derivation.inputSrcs rightDerivation
+                differed <- diffSrcs leftSrcs rightSrcs
+
+                if not differed
                 then return ()
                 else do
-                    let leftSrcs  = Nix.Derivation.inputSrcs leftDerivation
-                    let rightSrcs = Nix.Derivation.inputSrcs rightDerivation
-                    differed <- diffSrcs leftSrcs rightSrcs
-
-                    if not differed
-                    then return ()
-                    else do
-                        let leftEnv  = Nix.Derivation.env leftDerivation
-                        let rightEnv = Nix.Derivation.env rightDerivation
-                        let leftOutNames  = Data.Map.keysSet leftOuts
-                        let rightOutNames = Data.Map.keysSet rightOuts
-                        diffEnv leftOutNames rightOutNames leftEnv rightEnv
+                    let leftEnv  = Nix.Derivation.env leftDerivation
+                    let rightEnv = Nix.Derivation.env rightDerivation
+                    let leftOutNames  = Data.Map.keysSet leftOuts
+                    let rightOutNames = Data.Map.keysSet rightOuts
+                    diffEnv leftOutNames rightOutNames leftEnv rightEnv
 
 main :: IO ()
 main = do