anchor.diff:      function 
       | Returned o -> Some <| resolveResultType o
       | Tuple tc -> 
  -        let resolvedTp = tc |> List.collect (fun t -> resolve [] [t]) |> List.rev |> ResolvedTuple
  +        let resolvedTp = tc |> List.collect (fun t -> reduceExpressions [] [t]) |> List.rev |> ResolvedTuple
           Some resolvedTp
       | _ -> None
   
  
positive.code: 
      let tokens = tokenizeString predicate
  
      //printf "%A" tokens
  
      let parsedTokens = 
          parseTokens getMember tokens
          |> (fun (res, remainder, expType) -> res)
  
      //printf "%A" parsedTokens
  
      let calculateResult input = 
          let appliedParsedTokens = 
              let rec resolveInstanceType instanceType =
                  match instanceType with
                  | PropertyCall (call) -> Returned (call input)
                  | MethodCall (call) -> let resolved = call input in Method resolved
                  | DynamicCall (name) -> resolveInstanceType (getDelayedMember name input)
  
              let rec resolveParams exprs = 
                  exprs 
                  |> List.map (function 
                               | UnresolvedInstanceType (itype) -> resolveInstanceType itype
                               | SubExpression (subEx) -> SubExpression (resolveParams subEx)
                               | Tuple (tuple) -> Tuple (resolveParams tuple)
                               | other -> other)
              resolveParams parsedTokens
          
          match resolve [] appliedParsedTokens with
          | Obj (res) :: [] -> res
          | Bool (res) :: [] -> box res
          | otherToken -> failwith (sprintf "Unexpected result: %A" otherToken)
  
negative.code:     | Method l, ResolvedTuple r -> executeParameterizedMethod l r 
      | _ -> None
  
  and reduceExpressions left right =
      match left, right with
      | [], r :: rt -> reduceExpressions [r] rt
      | (ResolveSingle resolved :: lt), right -> reduceExpressions lt (resolved :: right)
      | (SubExpression exp :: lt), right ->
          let resolvedSub = reduceExpressions [] exp
          reduceExpressions lt (resolvedSub @ right)
      | l :: [], [] -> [l]
      | l :: lt, r :: rt ->        
          match attemptToResolvePair (l, r) with
          | Some (rToken) -> reduceExpressions lt (rToken :: rt)
          | None -> reduceExpressions (r :: l :: lt) rt
      | catchall -> failwith (sprintf "Unexpected case: %A" catchall)
  
  let compareAsSameType obj1 obj2 func =
  