anchor.diff:          (f : 'T -> bool) 
           (shouldMsg : string) 
           (shouldNotMsg : string) =
  +    let wrapF = fun a -> 
  +        match f a with
  +        | true -> MatchSuccess (a :> obj)
  +        | false -> MatchFail (a :> obj)
       { new Matcher<'T> () with
  -        member __.ApplyActual g actual = f actual |> g
  +        member __.ApplyActual g actual = wrapF actual |> g
           member __.FailureMsgForShould = shouldMsg
           member __.FailureMsgForShouldNot = shouldNotMsg
       }
   let createMatcher<'T> (f : 'T -> bool) (shouldMsg : string) =
  +    let wrapF = fun a -> 
  +        match f a with
  +        | true -> MatchSuccess (a :> obj)
  +        | false -> MatchFail (a :> obj)
       { new Matcher<'T> () with
  -        member __.ApplyActual g actual = f actual |> g
  +        member __.ApplyActual g actual = wrapF actual |> g
           member __.FailureMsgForShould = shouldMsg
       }
   
  
positive.code:                 a ()
                  false
              with
              | e -> e.Message |> applyMatcher matcher id
          createMatcher f
              (sprintf "throw exception with message %s" matcher.FailureMsgForShould)
              
  
negative.code:     
  let shouldNot<'T> (matcher:Matcher<'T>) (actual:'T) =
      let continuation = function
          | MatchFail _ -> ()
          | MatchSuccess a ->
              let msg = sprintf "Expected %A to %s" a matcher.FailureMsgForShouldNot
              raise (AssertionError { Message = msg })
      matcher.ApplyActual continuation actual
      
  let should<'T> (matcher:Matcher<'T>) (actual:'T) =
      let continuation = function
          | MatchSuccess _ -> ()
          | MatchFail a -> 
              let msg = sprintf "Expected %A to %s" a matcher.FailureMsgForShould
              raise (AssertionError { Message = msg })
      matcher.ApplyActual continuation actual
  
  