anchor.diff:              | 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)
  +            | 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
  
positive.code:         for t in tuple do
              match t with
              | Obj v -> yield box v
              | Unknown v -> yield v :> obj
              | what -> failwith (sprintf "Cannot resolve the given tuple-internal expression to a object type: %A" what)
      }
  
  
  
  
  let resolveExpression exprs initialBindings (finalReduction: bool) = 
  
      let rec (|ResolveIfThenElse|_|) bindings =
          function
          | Resolved (IfThenElse (ifexpr, thenexpr, elseexpr)) when finalReduction ->
              match reduceExpressions [] ifexpr bindings with
              | Obj (:? bool as res) :: [] -> 
                  if res then reduceExpressions [] thenexpr bindings
  
negative.code:             | 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
  