anchor.diff:              | invalid -> failwith (sprintf "If predicate returned an invalid result: %A" invalid)
           | IfThenElse (ifexpr, thenexpr, elseexpr) ->
               match reduceExpressions [] ifexpr bindings with
  +            // If fully resolved in initial reduction, resolve and return the result clause
               | Obj (:? bool as res) :: [] -> 
                   if res then reduceExpressions [] thenexpr bindings
                   else reduceExpressions [] elseexpr bindings
                   |> (fun resExpr -> Some (SubExpression(resExpr)))
  +            // If not fully resolved in initial reduction, reduce both clauses and return the result
  +            // Note: If in the future globally scoped Variables are added, resolving them here will cause problems with inner non-pure calls
               | rif -> 
                   let rthen = reduceExpressions [] thenexpr bindings |> List.rev
                   let relse = reduceExpressions [] elseexpr bindings |> List.rev
  
positive.code:             | Method l, Unit -> executeUnitMethod l
              | Method l, Obj r -> executeParameterizedMethod l r 
              | Invoke, Unknown r -> AppliedInvoke r |> Some
              | Invoke, Resolved (IndexArgs r) -> IndexArgs r |> Resolved |> Some //Here for F#-like indexing (if you want it)
              | Obj l, AppliedInvoke r -> resolveInvoke l r
              | IndexedProperty l, Resolved (IndexArgs (Obj r)) -> executeIndexer l r
              | Obj l, Resolved (IndexArgs (Obj r)) -> callIndexedProperty l r
  
negative.code:     
      and (|ResolveTriple|_|) =
          function
          // Order of Operations case 1: Obj_L InfixOp_R1 Obj_R InfixOp_R2
          // If InfixOp_R1 <= InfixOp_R2 then we can safely apply InfixOp_R1
          | (Infix (lp, lfun)) :: Obj l :: lt, Obj r :: (Infix (rp, rfrun)) :: rt when finalReduction ->
              if lp <= rp then 
                  Some (Obj (lfun l r), lt, (Infix (rp, rfrun)) :: rt)
              else None
          // Order of Operations case 2: Obj InfixOp Obj END 
          // We've reached the end of our list, it's safe to use InfixOp
          | (Infix (lp, lfun)) :: Obj l :: lt, Obj r :: [] when finalReduction ->
              Some (Obj (lfun l r), lt, [])
          | _ -> None
  
      // Tries to merge/convert local tokens, if it can't it moves to the right
      and reduceExpressions lleft lright (bindings: (string, ExprTypes Lazy) Map) =
          #if DEBUG
          printfn "L: %A R: %A" lleft lright
  