• The output is the source of normalize_file(ast): exposed items and imports in elm-format's order, elm-format's parentheses and literal forms, and doc comments with their Markdown and Elm code formatted.
• Every regular comment prints once, where elm-format puts it: a comment leads the node after it, trails the node before it on its line, or goes before the closing token of its container. A comment moves with an exposed item or an import that elm-format reorders. A block comment gets elm-format's form ({-a-} gives {- a -}). No comment is dropped: one that the printer cannot place raises Unprintable with UnplacedComment.
• Raises ParseFailed when the source has a syntax error in dialect.

test {
  let source = "module A exposing (a)\n\na = f x -- why\n  y\n"
  inspect(
    @printer.format(source),
    content=(
      #|module A exposing (a)
      #|
      #|
      #|a =
      #|    f x
      #|        -- why
      #|        y
      #|
    ),
  )
}

test {
  let result = @parser.parse_module(
    @scanner.SourceText::new("module A exposing (a)\n\na = [1,2]\n"),
    @scanner.DefaultScanner::new(),
  )
  inspect(
    @printer.format_parsed(result, layout=Width(40)),
    content=(
      #|module A exposing (a)
      #|
      #|
      #|a =
      #|    [ 1, 2 ]
      #|
    ),
  )
}

• The module's exposed items are a set: a duplicate is removed (T and T(..) give T(..)). They are sorted: operators, then types, then values, each by name. When the module documentation has @docs lines, the items that they name come first, in the order of those lines.
• The imports are sorted by module name. The imports of one module are merged into the first: a later alias replaces an earlier one, and the exposing lists are joined ((..) wins). An alias equal to the module name is removed (import A as A). Each exposing list is a sorted set, as above.
• Parentheses that neither the parser nor elm-format needs go (elm-format formatExpression, syntaxParens): case (f x) of gives case f x of, a - (f b) gives a - f b, f (-x) gives f -x. Parentheses around an operator chain in a chain stay.
• Parentheses are added where print_file writes them: elm-format's, around a lambda, if, case or let at the end of an operator chain, except after <| (x |> (\y -> y)), and around a constructor pattern with arguments before or after :: and in an as ((Just a) :: rest); and the ones that the parser needs, for example around an operator chain that cannot join its parent's chain ((a + b) * c).

• Doc comments (documentation and the doc comments in File.comments) are written as elm-format writes them: Markdown through @markdown.format_doc, Elm code in them formatted (see format). As elm-format, this is not idempotent for some doc comments: @docsT(..) (it names no exposed item, then it names T(..) as T), emphasis that starts after a letter (a*b c* gives a_b c_, then text), two bullet lists in a row (one list the next time), [a] [a] (one link), and a fenced Elm code block that starts with a blank line (the line goes the next time).

test {
  let text = "module A exposing (b, a)\n\nimport C\nimport B as B\n\n\na =\n    1\n"
  let file = @parser.parse_module(
    @scanner.SourceText::new(text),
    @scanner.DefaultScanner::new(),
  ).ast.unwrap()
  inspect(
    @printer.print_file(@printer.normalize_file(file)),
    content=(
      #|module A exposing (a, b)
      #|
      #|import B
      #|import C
      #|
      #|
      #|a =
      #|    1
      #|
    ),
  )
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  let int : @ast.Node[@ast.TypeAnnotation] = {
    range: r,
    value: Typed({ range: r, value: ([][:], "Int"), }, [][:]),
  }
  let decl : @ast.Node[@ast.Declaration] = {
    range: r,
    value: AliasDeclaration({
      documentation: None,
      name: { range: r, value: "Age", },
      generics: [][:],
      type_annotation: int,
    }),
  }
  inspect(
    @printer.print_declaration(decl),
    content=(
      #|type alias Age =
      #|    Int
    ),
  )
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  fn v(name : String) -> @ast.Node[@ast.Expression] {
    { range: r, value: FunctionOrValue([][:], name), }
  }
  let sum : @ast.Node[@ast.Expression] = {
    range: r,
    value: OperatorApplication("+", Left, v("a"), v("b")),
  }
  let product : @ast.Node[@ast.Expression] = {
    range: r,
    value: OperatorApplication("*", Left, sum, v("c")),
  }
  inspect(@printer.print_expression(product), content="(a + b) * c")
}

test {
  let text = "module Main exposing (main)\n\n\nmain =\n    1 + 2\n"
  let result = @parser.parse_module(
    @scanner.SourceText::new(text),
    @scanner.DefaultScanner::new(),
  )
  inspect(@printer.print_file(result.ast.unwrap()) == text, content="true")
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  fn pvar(name : String) -> @ast.Node[@ast.Pattern] {
    { range: r, value: VarPattern(name), }
  }
  let inner : @ast.Node[@ast.Pattern] = {
    range: r,
    value: UnConsPattern(pvar("a"), pvar("b")),
  }
  let outer : @ast.Node[@ast.Pattern] = {
    range: r,
    value: UnConsPattern(inner, pvar("rest")),
  }
  // `::` is right-associative, so an `::` on its left gets parentheses.
  inspect(@printer.print_pattern(outer), content="(a :: b) :: rest")
  // elm-format writes a constructor with arguments before `::` in
  // parentheses.
  let just : @ast.Node[@ast.Pattern] = {
    range: r,
    value: NamedPattern({ module_name: [][:], name: "Just", }, [pvar("a")][:]),
  }
  inspect(
    @printer.print_pattern({
      range: r,
      value: UnConsPattern(just, pvar("rest")),
    }),
    content="(Just a) :: rest",
  )
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  let a : @ast.Node[@ast.TypeAnnotation] = {
    range: r,
    value: GenericType("a"),
  }
  let maybe : @ast.Node[@ast.TypeAnnotation] = {
    range: r,
    value: Typed({ range: r, value: ([][:], "Maybe"), }, [a][:]),
  }
  let list : @ast.Node[@ast.TypeAnnotation] = {
    range: r,
    value: Typed({ range: r, value: ([][:], "List"), }, [maybe][:]),
  }
  inspect(@printer.print_type_annotation(list), content="List (Maybe a)")
}