anchor.diff:      | 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)
  +            member __.Visit<'Arg>() =
  +                let cfunc = meaning<'Arg -> 'T> (cast func)
  +                let carg = meaning<'Arg> (cast arg)
                   EQ(fun env -> (cfunc env) (carg env)) }
   
       | Lambda(var, body) ->
  
positive.code: 
  type CompiledExpr<'T> = Environment -> 'T
  
  and Environment private (index : Map<Var, obj ref list>) =
      new () = new Environment(Map.empty)
      member __.NewVar(v : Var, value : obj) =
          let stack = defaultArg (index.TryFind v) []
          new Environment(Map.add v (ref value :: stack) index)
  
      member __.GetVar(v : Var) = index.[v].Head.Value
      member __.UpdateVar(v : Var, value : obj) = index.[v].Head := value
  
  
  let rec meaning<'T> (expr : Expr<'T>) : CompiledExpr<'T> =
  
negative.code:                         let cElem = meaning<'Elem> (cast e)
                          fun env t -> let e = cElem env in s.Inject t e }
  
              let celems =
                  Seq.zip shape.Elements exprs
                  |> Seq.map cElem
                  |> Seq.toArray
  
              fun env ->
                  let mutable tuple = shape.CreateUninitialized()
                  for ce in celems do tuple <- ce env tuple
                  tuple
  
          | _ -> failwith "internal error"
  