anchor.diff:                          let cElem = meaning<'Elem> (cast e)
                           fun env t -> let e = cElem env in s.Inject t e }
   
  -            let elemWriters =
  +            let celems =
                   Seq.zip shape.Elements exprs
                   |> Seq.map cElem
                   |> Seq.toArray
   
               fun env ->
                   let mutable tuple = shape.CreateUninitialized()
  -                for w in elemWriters do tuple <- w env tuple
  +                for ce in celems do tuple <- ce env tuple
                   tuple
   
           | _ -> failwith "internal error"
  
positive.code:     | Application(func, arg) ->
          let argShape = TypeShape.Create arg.Type
          argShape.Accept { new ITypeShapeVisitor<CompiledExpr<'T>> with
              member __.Visit<'a>() =
                  let cfunc = meaning<'a -> 'T> (cast func)
                  let carg = meaning<'a> (cast arg)
                  EQ(fun env -> (cfunc env) (carg env)) }
  
      | Lambda(var, body) ->
  
negative.code: 
  type CompiledExpr<'T> = Environment -> 'T
  
  and Environment private (index : Map<Var, obj ref>) =
      new () = new Environment(Map.empty)
      member __.NewVar(v : Var, value : obj) = new Environment(Map.add v (ref value) index)
      member __.GetVar(v : Var) = index.[v].Value
      member __.UpdateVar(v : Var, value : obj) = index.[v] := value
  
  
  let rec meaning<'T> (expr : Expr<'T>) : CompiledExpr<'T> =
  