anchor.diff:              func (sprintf "%%{%s}" sym) (Seq.map printExpression args)
           | BopExpr(op, a, b) ->
               hsep [ printExpression a
  -                   printBop op
  +                   printBinOp op
                      printExpression b ]
               |> parened
  -    and printExpression x = printExpressionType x.Node
  +    and printExpression (x : Expression) : Doc = printExpression' x.Node
   
       /// Pretty-prints views.
  -    let rec printView =
  +    let rec printView : View -> Doc =
           function
           | View.Func f -> printFunc printExpression f
           | View.Unit -> String "emp" |> syntaxView
  
positive.code:             bs
              |> List.map (printBlock pView (printCommand pView))
              |> hsepStr "||"
      and printCommand pView x = printCommandType pView x.Node
  
      /// Pretty-prints a view prototype.
      let printViewProto { Name = n; Params = ps } =
          hsep [ "view" |> String |> syntax
                 func n (List.map (printCTyped String) ps) ]
          |> withSemi
  
      /// Pretty-prints a search directive.
      let printSearch i =
          hsep [ String "search" |> syntax
                 sprintf "%d" i |> String ]
  
      /// Pretty-prints a script variable of the given class.
      let printScriptVar cls v =
          hsep [ String cls |> syntax; printCTyped String v ] |> withSemi
  
      /// Pretty-prints script lines.
      let printScriptLineType =
          function
          | Global v -> printScriptVar "shared" v
          | Local v -> printScriptVar "thread" v
          | Method m ->
              fun mdoc -> vsep [Nop; mdoc; Nop]
              <| printMethod (printMarkedView printView) (printCommand (printMarkedView printView)) m
  
          | ViewProto v -> printViewProto v
          | Search i -> printSearch i
          | Constraint c -> printConstraint c
      let printScriptLine x = printScriptLineType x.Node
  
      /// Pretty-prints scripts.
      /// each line on its own line
      let printScript xs = VSep(List.map printScriptLine xs, Nop)
  
  
  (*
  
negative.code:         >> ssurround "{| " " |}"
  
      /// Pretty-prints view definitions.
      let rec printDView : DView -> Doc =
          function
          | DView.Func f -> printFunc String f
          | DView.Unit -> String "emp" |> syntaxView
          | DView.Join(l, r) -> binop "*" (printDView l) (printDView r)
  
      /// Pretty-prints constraints.
      let printConstraint (cs : ViewDef<DView, Expression>) : Doc =
          hsep [ String "constraint" |> syntax
                 printDView (viewOf cs)
                 String "->" |> syntax
  