anchor.diff:          | Bool b -> printBoolExprG pVar fr b
           | _ -> failwith "[printExprG] Case unimplemented for Grasshopper backend." 
   
  +    let printSymbolicGrass (pArg : 'Arg -> Doc) (s : Symbolic<'Arg>) : Doc =
  +        let { Sentence = ws; Args = xs } = s
  +        parened (printInterpolatedSymbolicSentence pArg ws xs)
  +
       /// Pretty-prints a symbolic sentence 
       let rec printSymGrass (pReg : MarkedVar -> Doc) (sym : Sym<MarkedVar>) : Doc =
           match sym with
           | Reg r -> pReg r
  -        | Sym { Sentence = ws; Args = xs } ->
  -            let pArg = printExprG (printSym pReg) false
  -            printInterpolatedSymbolicSentence pArg ws xs
  -            |> parened 
  +        | Sym s -> printSymbolicGrass (printExpr (printSym pReg)) s
   
       /// Get the set of accessed variables. 
       let findVarsGrass (zterm : Backends.Z3.Types.ZTerm) : seq<MarkedVar> = 
  
positive.code:                         |> printBoolExprG (printSymGrass printMarkedVarGrass) true
  
          // TODO @(septract) print command properly 
          let cmdprint = zterm.SymBool.Cmd 
                         |> (Core.Expr.Pretty.printBoolExpr (printSymGrass printMarkedVarGrass))
          vsep [ String "procedure" <+> String name 
                 varprint |> Indent |> parened 
                 String "requires" 
                 Indent wpreprint 
                 String "ensures" 
                 Indent goalprint
                 cmdprint |> ssurround "/*" "*/" |> Indent |> braced 
               ]  
  
      /// Print all the Grasshopper queries that haven't been eliminated by Z3.      
  
negative.code: 
  open Chessie.ErrorHandling
  
  open Starling
  open Starling.Collections
  open Starling.Utils
  open Starling.Core.Command
  open Starling.Core.TypeSystem
  open Starling.Core.Var
  open Starling.Core.Expr
  