Merge pull request #164 from davidchambers/return-type

update return type

lib/Comparison.js

@@ -0,0 +1,28 @@
+//    Incorrect :: Array Effect -> Array Effect -> Comparison
+const Incorrect = actual => expected => ({
+  tag: 'Incorrect',
+  actual,
+  expected,
+});
+
+//    Correct :: Array Effect -> Comparison
+const Correct = actual => ({
+  tag: 'Correct',
+  actual,
+});
+
+//    comparison :: (Array Effect -> Array Effect -> a)
+//               -> (Array Effect -> a)
+//               -> Comparison
+//               -> a
+const comparison = incorrect => correct => comparison => {
+  switch (comparison.tag) {
+    case 'Incorrect':
+      return incorrect (comparison.actual) (comparison.expected);
+    case 'Correct':
+      return correct (comparison.actual);
+  }
+};
+
+
+export {Incorrect, Correct, comparison};

lib/Effect.js

@@ -0,0 +1,31 @@
+//    Failure :: Any -> Effect
+const Failure = exception => ({
+  tag: 'Failure',
+  exception,
+});
+
+//    Success :: Any -> Effect
+const Success = value => ({
+  tag: 'Success',
+  value,
+});
+
+//    effect :: (Any -> a) -> (Any -> a) -> Effect -> a
+const effect = failure => success => effect => {
+  switch (effect.tag) {
+    case 'Failure': return failure (effect.exception);
+    case 'Success': return success (effect.value);
+  }
+};
+
+//    encase :: AnyFunction -> ...Any -> Effect
+const encase = f => (...args) => {
+  try {
+    return Success (f (...args));
+  } catch (exception) {
+    return Failure (exception);
+  }
+};
+
+
+export {Failure, Success, effect, encase};

lib/Line.js

@@ -0,0 +1,5 @@
+//    Line :: Integer -> String -> Line
+const Line = number => text => ({number, text});
+
+
+export {Line};

lib/command.js

@@ -1,13 +1,17 @@
+import {comparison} from './Comparison.js';
 import doctest from './doctest.js';
 import program from './program.js';
 
 
 Promise.all (
   program.args.map (path =>
     doctest (program) (path)
-    .then (results =>
-      results.reduce ((status, [correct]) => correct ? status : 1, 0)
-    )
+    .then (tests => tests.reduce (
+      (status, test) => comparison (_ => _ => 1)
+                                   (_ => status)
+                                   (test.comparison),
+      0
+    ))
   )
 )
 .then (