anchor.diff:  
       let align (d:int) offset = d.ToString().PadLeft(offset + digits)
   
  -    logger.info (
  +    log.Write Info (
         eventX "EXPECTO?! Summary...\nPassed: {passedCount}\n\t{passed}Ignored: {ignoredCount}\n\t{ignored}Failed: {failedCount}\n\t{failed}Errored: {erroredCount}\n\t{errored}"
         >> setField "passed" passed
         >> setField "passedCount" (align passedCount 1)
         >> setField "ignored" ignored
  -      >> setField "ignoredCount" (align ignoredCount)
  +      >> setField "ignoredCount" (align ignoredCount 0)
         >> setField "failed" failed
         >> setField "failedCount" (align failedCount 1)
         >> setField "errored" errored
  -      >> setField "erroredCount" (align erroredCount))
  -
  +      >> setField "erroredCount" (align erroredCount 0))
   
     /// Hooks to print report through test run
     type TestPrinters =
  -    { /// Called before a test run (e.g. at the top of your main function)
  +    {
  +      /// Underlying log command
  +      log: Log
  +      /// Called before a test run (e.g. at the top of your main function)
         beforeRun: Test -> unit
         /// Called before atomic test (TestCode) is executed.
         beforeEach: string -> unit
  
positive.code:             >> setField "spirit" spirit)
            }
  
      static member silent =
        { beforeRun = fun _ -> ()
          beforeEach = fun _ -> ()
          info = fun _ -> ()
          passed = fun _ _ -> ()
          ignored = fun _ _ -> ()
          failed = fun _ _ _ -> ()
          exn = fun _ _ _ -> ()
          summary = fun _ -> () }
  
      static member Default =
        TestPrinters.logger (fun l m -> logger.logWithAck l m |> Async.RunSynchronously)
  
      static member Async =
        TestPrinters.logger (fun l m -> logger.log l m |> Async.Start)
  
      static member combined (async:bool ref) =
        TestPrinters.logger (fun l m ->
          if !async then logger.log l m |> Async.Start
          else logger.logWithAck l m |> Async.RunSynchronously)
  
      static member Summary =
        { TestPrinters.Default with
            summary = fun summary ->
              TestPrinters.Default.summary summary
              logSummary summary }
  
      type WrappedFocusedState =
        | Enabled of state:FocusState
  
negative.code:       /// Prints a summary given the test result counts
        summary : TestResultSummary -> unit }
  
      static member silent =
        {
          log = {Async=ref false}
          beforeRun = fun _ -> ()
          beforeEach = fun _ -> ()
          info = fun _ -> ()
          passed = fun _ _ -> ()
          ignored = fun _ _ -> ()
          failed = fun _ _ _ -> ()
          exn = fun _ _ _ -> ()
          summary = fun _ -> () }
  
      static member Default =
        let log = {Async=ref false}
        {
          log = log
          beforeRun = fun _tests ->
            log.Write Info (
              eventX "EXPECTO? Running tests...")
  
          beforeEach = fun n ->
            log.Write Debug (
              eventX "{testName} starting..."
              >> setField "testName" n)
  
          info = fun s ->
            log.Write Info (eventX s)
  
          passed = fun n d ->
            log.Write Debug (
              eventX "{testName} passed in {duration}."
              >> setField "testName" n
              >> setField "duration" d)
  
          ignored = fun n m ->
            log.Write Debug (
              eventX "{testName} was ignored. {reason}"
              >> setField "testName" n
              >> setField "reason" m)
  
          failed = fun n m d ->
            log.Write LogLevel.Error (
              eventX "{testName} failed in {duration}. {message}"
              >> setField "testName" n
              >> setField "duration" d
              >> setField "message" m)
  
          exn = fun n e d ->
            log.Write LogLevel.Error (
              eventX "{testName} errored in {duration}"
              >> setField "testName" n
              >> setField "duration" d
  