anchor.diff:  module FSpec.Core.MatchersV3
  +
  +type MatchResult =
  +    | MatchSuccess of obj
  +    | MatchFail of obj
  +    with static member apply f = function
  +                                    | MatchSuccess _ -> f true
  +                                    | _ -> f false
   
   [<AbstractClass>]
   type Matcher<'TActual> () = 
  -    abstract member ApplyActual<'TResult> : (bool -> 'TResult) -> 'TActual -> 'TResult
  +    abstract member ApplyActual<'TResult> : (MatchResult -> 'TResult) -> 'TActual -> 'TResult
       abstract member FailureMsgForShould : string
       abstract member FailureMsgForShouldNot : string
       default this.FailureMsgForShouldNot : string = sprintf "not %s" this.FailureMsgForShould
  
positive.code:     
  let shouldNot<'T> (matcher:Matcher<'T>) (actual:'T) =
      let continuation = function
          | false -> ()
          | true -> 
              let msg = sprintf "Expected %A to %s" actual matcher.FailureMsgForShouldNot
              raise (AssertionError { Message = msg })
      matcher.ApplyActual continuation actual
      
  let should<'T> (matcher:Matcher<'T>) (actual:'T) =
      let continuation = function
          | true -> ()
          | false -> 
              let msg = sprintf "Expected %A to %s" actual matcher.FailureMsgForShould
              raise (AssertionError { Message = msg })
      matcher.ApplyActual continuation actual
  
  
negative.code: 
  module have =
      let atLeastOneElement matcher =
          let f a = a |> Seq.exists (applyMatcher matcher (MatchResult.apply id))
          let msg = sprintf "contain at least one element to %s" matcher.FailureMsgForShould
          let notMsg = sprintf "contain no elements to %s" matcher.FailureMsgForShould
          createFullMatcher f msg notMsg
      
      let length matcher =
          let f a = a |> Seq.length |> applyMatcher matcher (MatchResult.apply id)
          let msg = sprintf "have length to %s" matcher.FailureMsgForShould
          createMatcher f msg
  
      let exactly no matcher =
          let f a = a |> Seq.filter (applyMatcher matcher (MatchResult.apply id)) |> Seq.length = no
          let msg = 
              sprintf "contain exactly %d element to %s" no 
                  matcher.FailureMsgForShould
  