Changing return type of Nucleotide Count to Either

By using an `Either` instead of throwing an error, the resulting exercise
is more idiomatic to Haskell. The `Either` will provide a useful error
message to end users of the functions.

Closes exercism#157

Author: samjonester

exercises/nucleotide-count/example.hs

@@ -1,19 +1,20 @@
 module DNA (count, nucleotideCounts) where
-import Data.Map.Strict (Map, fromListWith)
 
-count :: Char -> String -> Int
-count needle = length . filter (nucleotide ==) . map verifyDNA
-  where nucleotide = verifyDNA needle
+import qualified Control.Applicative as A
+import Data.Map.Strict (Map, (!), fromDistinctAscList, fromListWith, findWithDefault)
 
-nucleotideCounts :: String -> Map Char Int
-nucleotideCounts strand = fromListWith (+) (defaults ++ map pair strand)
- where defaults = zip dna (repeat 0)
-       pair nucleotide = (verifyDNA nucleotide, 1)
+count :: Char -> String -> Either String Int
+count x xs = (!) A.<$> nucleotideCounts xs A.<*> valid x
 
-dna :: String
-dna = "ACGT"
+nucleotideCounts :: String -> Either String (Map Char Int)
+nucleotideCounts xs = fromDistinctAscList A.<$> mapM count' "ACGT"
+  where
+    count' x = (\c -> (x, c)) A.<$> occur' x
+    occur' x = findWithDefault 0 x . countOccurrences A.<$> mapM valid xs 
+    countOccurrences = fromListWith (+) . flip zip (repeat 1)
+
+valid :: Char -> Either String Char
+valid x
+  | x `elem` "ACGT" = Right x
+  | otherwise       = Left $ "invalid nucleotide " ++ show x
 
-verifyDNA :: Char -> Char
-verifyDNA nucleotide | nucleotide `elem` dna = nucleotide
-                     | otherwise = error ("invalid nucleotide " ++
-                                          show nucleotide)

exercises/nucleotide-count/nucleotide-count_test.hs

@@ -1,21 +1,13 @@
-import Test.HUnit (Assertion, (@=?), runTestTT, assertFailure, Test(..), Counts(..))
+import Test.HUnit (Assertion, (@=?), runTestTT, Test(..), Counts(..))
 import System.Exit (ExitCode(..), exitWith)
 import DNA (count, nucleotideCounts)
 import Data.Map (fromList)
-import qualified Control.Exception as E
 
 exitProperly :: IO Counts -> IO ()
 exitProperly m = do
   counts <- m
   exitWith $ if failures counts /= 0 || errors counts /= 0 then ExitFailure 1 else ExitSuccess
 
-assertError :: String -> a -> IO ()
-assertError err f =
-  do r <- E.try (E.evaluate f)
-     case r of
-       Left (E.ErrorCall s) | err == s -> return ()
-       _ -> assertFailure ("expecting error " ++ show err)
-
 testCase :: String -> Assertion -> Test
 testCase label assertion = TestLabel label (TestCase assertion)
 
@@ -27,29 +19,29 @@ main = exitProperly $ runTestTT $ TestList
 countTests :: [Test]
 countTests =
   [ testCase "empty dna strand has no adenosine" $
-    0 @=? count 'A' ""
+    Right 0 @=? count 'A' ""
   , testCase "repetitive cytidine gets counted" $
-    5 @=? count 'C' "CCCCC"
+    Right 5 @=? count 'C' "CCCCC"
   , testCase "counts only thymidine" $
-    1 @=? count 'T' "GGGGGTAACCCGG"
+    Right 1 @=? count 'T' "GGGGGTAACCCGG"
   , testCase "validates nucleotides" $
-    assertError "invalid nucleotide 'X'" $ count 'X' "GACT"
+    Left "invalid nucleotide 'X'" @=? count 'X' "GACT"
   , testCase "validates strand" $
-    assertError "invalid nucleotide 'Y'" $ count 'G' "GACYT"
+    Left "invalid nucleotide 'Y'" @=? count 'G' "GACYT"
   ]
 
 nucleotideCountTests :: [Test]
 nucleotideCountTests =
   [ testCase "empty dna strand has no nucleotides" $
-    fromList [('A', 0), ('T', 0), ('C', 0), ('G', 0)] @=?
+    Right (fromList [('A', 0), ('T', 0), ('C', 0), ('G', 0)]) @=?
     nucleotideCounts ""
   , testCase "repetitive-sequence-has-only-guanosine" $
-    fromList [('A', 0), ('T', 0), ('C', 0), ('G', 8)] @=?
+    Right (fromList [('A', 0), ('T', 0), ('C', 0), ('G', 8)]) @=?
     nucleotideCounts "GGGGGGGG"
   , testCase "counts all nucleotides" $
-    fromList [('A', 20), ('T', 21), ('C', 12), ('G', 17)] @=?
+    Right (fromList [('A', 20), ('T', 21), ('C', 12), ('G', 17)]) @=?
     nucleotideCounts ("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAA" ++
                       "GAGTGTCTGATAGCAGC")
   , testCase "validates strand" $
-    assertError "invalid nucleotide 'P'" $ nucleotideCounts "GPAC"
+    Left "invalid nucleotide 'P'" @=? nucleotideCounts "GPAC"
   ]