anchor.diff:      | LetRec(b::bs) -> 
           genLetBinding "let rec " b 
           +> colPre (rep 2 sepNln) (rep 2 sepNln) bs (genLetBinding "and ") +> sepNln
  +
       | ModuleAbbrev(s1, s2) ->
           !- "module " -- s1 +> sepEq -- s2 +> sepNln
       | NamespaceFragment(m) ->
           failwithf "NamespaceFragment hasn't been implemented yet: %O" m
  +
       | NestedModule(ats, px, ao, s, mds) -> 
           genPreXmlDoc px
           +> colPost sepNln sepNln ats genAttribute -- "module " +> opt sepSpace ao genAccess -- s +> sepEq
           +> indent +> sepNln +> genModuleDeclGroup mds +> unindent
  +
       | Open(s) ->
           !- (sprintf "open %s" s) +> sepNln
       /// There is no nested types and they have newlines in the ends of definitions
  
positive.code:               (ifElse (NoBreakInfixOps.Contains s) (sepSpace -- s +> sepSpace +> genExpr e)
                  (sepSpace +> autoNln (!- s +> sepSpace +> genExpr e)))))
          +> genInfixApps newline es
      | [] -> sepNone
  
  /// Use in indexed set and get only
  
negative.code:                                 autoNln (!- (sprintf ".%s" s) 
                                      +> ifElse (hasParenthesis e) sepBeforeArg sepSpace +> genExpr e)))
          +> unindent
  
      /// Unlike infix app, function application needs a level of indentation
      | App(e1, [e2]) -> 
          atCurrentColumn (genExpr e1 +> 
              ifElse (hasParenthesis e2) sepBeforeArg sepSpace 
              +> indent +> autoNln (genExpr e2) +> unindent)
  
      /// Always spacing in multiple arguments
      | App(e, es) -> 
          atCurrentColumn 
              (genExpr e +> colPre sepSpace sepSpace es (fun e -> indent +> autoNln (genExpr e) +> unindent))
  
      | TypeApp(e, ts) -> genExpr e -- "<" +> col sepComma ts genType -- ">"
      | LetOrUse(isRec, isUse, bs, e) ->
          let prefix = 
              if isUse then "use "
              elif isRec then "let rec "
              else "let "
  
          match bs with
          | b::bs ->
              /// and is applicable for use binding
              atCurrentColumn (genLetBinding prefix b +> 
                  colPre sepNln sepNln bs (genLetBinding "and ") +> sepNln +> genExpr e)
  
          | _ -> atCurrentColumn (col sepNln bs (genLetBinding prefix) +> sepNln +> genExpr e)
  
      /// Could customize a bit if e is single line
      | TryWith(e, cs) ->  
          atCurrentColumn (!- "try " +> indent +> sepNln +> genExpr e +> unindent ++ "with" 
              +> indentOnWith +> sepNln +> col sepNln cs genClause +> unindentOnWith)
  
      | TryFinally(e1, e2) -> 
          atCurrentColumn (!- "try " +> indent +> sepNln +> genExpr e1 +> unindent ++ "finally" 
              +> indent +> sepNln +> genExpr e2 +> unindent)    
  
      | SequentialSimple es -> atCurrentColumn (colAutoNlnSkip0 sepSemi es genExpr)
      /// It seems too annoying to use sepSemiNln
      | Sequentials es -> 
  