anchor.diff:      and printBoolExprG (pVar : 'Var -> Doc) : BoolExpr<'Var> -> Doc =
           function
           | BVar c -> pVar c
  -        | BAnd xs -> infexprV "&&" (printBoolExpr pVar) xs
  -        | BOr xs -> infexprV "||" (printBoolExpr pVar) xs
  -        | BImplies (x, y) -> infexprV "==>" (printBoolExpr pVar)  [x; y]
  -        | BNot (BEq (x, y)) -> infexpr "!=" (printExpr pVar) [x; y]
  -        | BEq (x, y) -> infexpr "==" (printExpr pVar) [x; y]
  +        | BAnd xs -> infexprV "&&" (printBoolExprG pVar) xs
  +        | BOr xs -> infexprV "||" (printBoolExprG pVar) xs
  +        | BImplies (x, y) -> infexprV "==>" (printBoolExprG pVar)  [x; y]
  +        | BNot (BEq (x, y)) -> infexpr "!=" (printExprG pVar) [x; y]
  +        | BEq (x, y) -> infexpr "==" (printExprG pVar) [x; y]
           | _ -> failwith "Unimplemented for Grasshopper backend." 
   
       /// Pretty-prints an expression.
       and printExprG (pVar : 'Var -> Doc) : Expr<'Var> -> Doc =
           function
  -        | Int i -> printIntExpr pVar i
  -        | Bool b -> printBoolExpr pVar b
  +        | Int i -> printIntExprG pVar i
  +        | Bool b -> printBoolExprG pVar b
           | _ -> failwith "Unimplemented for Grasshopper backend." 
   
       /// Pretty-prints a symbolic sentence 
  
positive.code:         |> lift (Set.map valueOf) 
          |> lift (Set.toSeq) 
          |> returnOrFail
  
      let printTypedVarGrass (v : TypedVar) = 
          match v with 
          | Int name -> String name  
          | Bool name -> String name  
          | _ -> failwith "Unimplemented for Grasshopper backend." 
  
  
      let printZTermGrass (svars : VarMap) 
  
negative.code:         match sym with
          | Reg r -> pReg r
          | Sym { Sentence = ws; Args = xs } ->
              let pArg = printExprG (printSym pReg)
              parened
                  (printInterpolatedSymbolicSentence pArg ws xs)
  
  