anchor.diff:                  | _ -> 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 =
  
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 =
  