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:                 | _ -> failwith (sprintf "Unexpected Token: %A" head)
      parseTokensInner tokens [] [] StandardExpression
  
  let rec applyInstanceState getDelayedMember (input: obj) exprs =
      let rec resolveInstanceType expr =
              match expr with 
              | UnresolvedInstanceType (PropertyCall (call)) -> Returned (call input)
              | UnresolvedInstanceType (MethodCall (call)) -> let resolved = call input in Method resolved
              | UnresolvedInstanceType (DynamicCall (name)) -> resolveInstanceType (UnresolvedInstanceType <| getDelayedMember name input)
              | SubExpression (subEx) -> SubExpression (applyInstanceState getDelayedMember input subEx)
              | Tuple (tuple) -> Tuple (applyInstanceState getDelayedMember input tuple) 
              | other -> other
      exprs |> List.map (fun expr -> resolveInstanceType expr)
  
  
  let buildExpression (localType: Type) (predicate: string) : (obj -> obj) =
  
      let memberMap =
  