anchor.diff:          | Int name -> String name  
           | Bool name -> String name  
           | _ -> failwith "Unimplemented for Grasshopper backend." 
  -
  -    // Print infix operator across multiple lines
  -    let infexprV (op : string) (pxs : 'x -> Doc) (xs : seq<'x>) : Doc = 
  -        let mapped = Seq.map pxs xs 
  -        let resseq = Seq.map (fun x -> vsep [(String op); Indent x]) (Seq.tail mapped) 
  -        hsep [Seq.head mapped; (hsep resseq)] 
  -        |> parened 
  -
  -    // Print infix operator on one line
  -    let infexpr (op : string) (pxs : 'x -> Doc) (xs : seq<'x>) : Doc = 
  -        let mapped = Seq.map pxs xs 
  -        let resseq = Seq.map (fun x -> hsep [(String op); x]) (Seq.tail mapped) 
  -        hsep [Seq.head mapped; (hsep resseq)] 
  -        |> parened 
   
       /// Pretty-prints an arithmetic expression.
       let rec printIntExprG (pVar : 'Var -> Doc) : IntExpr<'Var> -> Doc =
  
positive.code:             parened
                  (printInterpolatedSymbolicSentence pArg ws xs)
  
      let printExprGrass (a : BoolExpr<Sym<MarkedVar>>) : Doc  = 
          printBoolExprG (printSymGrass printMarkedVarGrass) a 
  
      let findVarsGrass (zterm : Backends.Z3.Types.ZTerm) : seq<MarkedVar> = 
          // TODO @(septract) Should this conjoin the command as well? 
          BAnd [zterm.SymBool.WPre; zterm.SymBool.Goal] 
  
negative.code:         |> lift (Set.toSeq) 
          |> returnOrFail
  
      /// Print a single Grasshopper query from a ZTerm 
      let printZTermGrass (svars : VarMap) 
                          (name : string) 
                          (zterm: Backends.Z3.Types.ZTerm) : Doc =
  
          // TODO @(septract) print variable types
          let svarprint = VarMap.toTypedVarSeq svars
                          |> Seq.map printTypedVarGrass 
          let varprint = Seq.map printMarkedVarGrass (findVarsGrass zterm) 
                         |> Seq.append svarprint 
                         |> (fun x -> VSep(x,String ",")) 
                         |> Indent 
  
          // Print the requires / ensures clauses 
          let wpreprint = zterm.SymBool.WPre 
                          |> printBoolExprG (printSymGrass printMarkedVarGrass) 
          let goalprint = zterm.SymBool.Goal 
                          |> printBoolExprG (printSymGrass printMarkedVarGrass) 
  
          // TODO @(septract) print command properly 
          let cmdprint = zterm.SymBool.Cmd 
                         |> (Core.Expr.Pretty.printBoolExpr (printSymGrass printMarkedVarGrass))
          vsep [ String "procedure" <+> String name <+> (varprint |> parened) 
  