anchor.diff:          let bindings = l.Bindings |> Map.add bindname (Obj arg |> Lazy.CreateFromValue)
           Lambda({ l with Params = restprms; Bindings = bindings })
   
  -let inline subexprIfNeeded (input: ExprRep list): ExprTypes =   
  +let inline SubExpressionIfNeeded (input: ExprRep list): ExprTypes =   
       match input with
       | h :: [] -> h.Expr
       | list -> SubExpression list
  
positive.code:                             tc |> Array.map (fun t -> 
                                      match reduceExpressions [] [t] bindings |> fst  with 
                                      | ({ Expr = Obj o } & oobj) :: [] -> oobj 
                                      | res -> SubExpression res |> wrapit)
                          match reducedTuples |> Array.forall (function | {Expr = Obj o} -> true | _ -> false) with
                          | true -> reducedTuples |> (fun tc -> Obj (tupleToObj tc |> box))
                          | false -> reducedTuples |> Tuple |> Unresolved
  
negative.code:                     let cleanBinds = lambda.Params |> List.fold (fun bnds pn -> if bnds |> Map.containsKey pn then bnds |> Map.remove pn else bnds) bindings         
                      let reducedExpr, _ = reduceExpressions [] [lambda.Contents] cleanBinds
                      let recLambda = 
                          let newLambda = {lambda with Contents = { lambda.Contents with Expr = SubExpressionIfNeeded reducedExpr }}
                          do newLambda.Bindings <- newLambda.Bindings |> Map.add bindName (Lambda newLambda |> Lazy.CreateFromValue)
                          { lmbExpr with Expr = Lambda newLambda }
                      let newbindings = bindings |> Map.add bindName (lazy recLambda.Expr)
                      let res = { bindExpr with Expr = reduceExpressions [] [boundScope] newbindings |> fst |> SubExpressionIfNeeded }
                      reduceExpressions left (res :: rt) newbindings
              // Normal Value Binding
              | rexpr -> 
                  let newbindings = bindings |> Map.add bindName (lazy SubExpressionIfNeeded rexpr) in
                      let res = { bindExpr with Expr = reduceExpressions [] [boundScope] newbindings |> fst |> SubExpressionIfNeeded }
                      reduceExpressions left (res :: rt) bindings
          | ResolveSingle bindings (res, lt, rt)
          | ResolveTuple bindings (res, lt, rt) 
  