anchor.diff:                     | 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
   
  
positive.code:         | _ -> Array.fold (fun (x:Doc) (y:Doc) -> x <<>> line <<>> y)
                            parts.[0] parts.[1..]
  
      let mkchar c =
          match c with
          | '\n' -> line
          | c -> Char c
  
      let mkbool = function
          | true -> text "True"
          | false -> text "False"
  
      let mkint (i:int) = string i |> text
  
      let mkfloat (f:float) = string f |> text
  
      let mkdouble (d:double) = string d |> text
  
      let dot       = mkchar '.'
      let backslash = mkchar '\\'
      let equals    = mkchar '='
      let space     = mkchar ' '
      let comma     = mkchar ','
      let colon     = mkchar ':'
      let semi      = mkchar ';'
      let dquote    = mkchar '"' // hacky fix for syntax highligher stupidity -> "
      let squote    = mkchar '\''
      let rbracket  = mkchar ']'
      let lbracket  = mkchar '['
      let rbrace    = mkchar '}'
      let lbrace    = mkchar '{'
      let rparen    = mkchar ')'
      let lparen    = mkchar '('
      let rangle    = mkchar '>'
      let langle    = mkchar '<'
  
      let spaces = function
          | n when n <= 0 -> ""
          | n             -> String.replicate n " "
  
      let indentation = spaces
  
      let inline (<+>) (x:Doc) (y:Doc) = x <<>> space <<>> y
  
      let fold f = function
          | []    -> empty
          | x::xs -> List.fold f x xs
  
      // <$> and <$$> in haskell, <*> and <**> in F#
      let inline (<*>) x y = x <<>> line <<>> y
      let inline (<**>) x y = x <<>> linebreak <<>> y
  
      let vcat = fold (<**>)
  
      // break in Haskell is isbreak in F# due to reserved word collision
  
negative.code: 
      let align d = column (fun k -> nesting (fun i -> nest (k-i) d))
  
      /// Enclose a list of Doc objects between a left and right Doc, and
      /// separate the list elements with the given separator Doc.
      let encloseSep left right sep ds =
          match ds with
          | []    -> left <<>> right
  