anchor.diff:              >> 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
  +      let defaultPrinter = TestPrinters.Default
  +      { defaultPrinter with
             summary = fun summary ->
  -            TestPrinters.Default.summary summary
  -            logSummary summary }
  +            defaultPrinter.summary summary
  +            logSummary defaultPrinter.log summary }
  +
  +    member m.MakeAsync() = m.log.Async := true
  +    member m.MakeSync() = m.log.Async := false
   
       type WrappedFocusedState =
         | Enabled of state:FocusState
  
positive.code: 
      let align (d:int) offset = d.ToString().PadLeft(offset + digits)
  
      logger.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 "failed" failed
        >> setField "failedCount" (align failedCount 1)
        >> setField "errored" errored
        >> setField "erroredCount" (align erroredCount))
  
  
    /// Hooks to print report through test run
    type TestPrinters =
      { /// 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
  
negative.code:     |> evalTestList printer map
  
    /// Evaluates tests sequentially
    let evalSeq (printer: TestPrinters) =
      printer.MakeSync()
      eval printer List.map
  
    /// Evaluates tests in parallel
    let evalPar (printer: TestPrinters) =
  
      let pmap fn ts =
        let sequenced, parallel =
          List.mapi (fun i t -> i, t) ts
          |> List.partition (fun (i, t) -> t.sequenced)
        
        printer.MakeAsync()
  
        let parallelResults =
          List.map (fun (index, test) ->
  