anchor.diff:          | SText of int * string * SimpleDoc
           | SLine of int * SimpleDoc
   
  +    /// The empty document.
       let empty = Empty
   
       let line = Line false
   
       let linebreak = Line true
   
  +    /// Lift a string into the Doc type.
       let text (s:string) =
           match s.Length with
           | 0 -> Empty
           | l -> Text (l, s)
   
  +    /// Place two documents side-by-side
       let beside x y = Cat (x,y)
   
  -    // in haskell this is <>, but this collides poorly with <> in F#
  +    /// Infix notation for beside.  In haskell this is <>, but this collides 
  +    /// poorly with <> in F# so it was renamed.
       let inline (<<>>) (x:Doc) (y:Doc) = beside x y
   
       // to avoid issues with existing functions like int and float
       // those are renamed to mkint and mkfloat.  then, to keep these
       // functions consistent, the others are also prefaced with "mk"
   
  +    /// Given a string with one or more lines of text separated by newline
  +    /// characters, create a sequence of Doc objects for each line and then
  +    /// fold the resulting Doc objects together with the <<>> operator
  +    /// with a line between each.
       let rec mkstring (s:string) =
           let parts = s.Split([|'\n'|])
                       |> Array.map text
  
positive.code: 
      let fillCat = fold (<//>)
  
      let enclose l r x = l <<>> x <<>> r
  
      let brackets = enclose lbracket rbracket
  
      let angles = enclose langle rangle
  
      let parens = enclose lparen rparen
  
      let braces = enclose lbrace rbrace
  
      let dquotes = enclose dquote dquote
  
      let squotes = enclose squote squote
  
      let nest i x = Nest (i,x)
  
negative.code:                    | Nesting f   -> scan k (f 0::ds)
          scan 0 [x]
  
      /// Render a SimpleDoc as a string.
      let rec displayS = function
          | SEmpty        -> ""
          | SChar (c,x)   -> string(c) + (displayS x)
          | SText (l,s,x) -> s + (displayS x)
          | SLine (i,x)   -> "\n"+(indentation i)+(displayS x)
  
      /// Render a Doc as a string assuming an 80 column width.
      let displayString s = renderPretty 0.4 80 s |> displayS
  
      /// Render a Doc as a string with a given width w.
      let displayStringW w s = renderPretty 0.4 w s |> displayS
  
  