anchor.diff:  
       let tokens = tokenizeString predicate
   
  -    //printf "%A" tokens
  +    printfn "T: %A" tokens
   
       let parsedTokens = 
           parseTokens getMember tokens
           |> (fun (res, remainder, expType) -> res)
   
  -    //printf "%A" parsedTokens
  +    printfn "PT: %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
  +
  +        let appliedParsedTokens = applyInstanceState getDelayedMember input parsedTokens
           
  -        match resolve [] appliedParsedTokens with
  +        printfn "APT: %A" appliedParsedTokens
  +        
  +        match reduceExpressions [] appliedParsedTokens with
           | Obj (res) :: [] -> res
           | Bool (res) :: [] -> box res
           | otherToken -> failwith (sprintf "Unexpected result: %A" otherToken)
  
positive.code:     function 
      | Returned o -> Some <| resolveResultType o
      | Tuple tc -> 
          let resolvedTp = tc |> List.collect (fun t -> resolve [] [t]) |> List.rev |> ResolvedTuple
          Some resolvedTp
      | _ -> None
  
  
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 =
  