Like Elm.Parser but able to parse badly indented code and similar somewhat incorrect syntax, similar to elm-format.

This is not a fault-tolerant parser! So if you write something it can't recognize in a file, the whole thing will fail.

Also, precise ranges of some parts in in the parsed result are not reliable. Though they will still be correct when viewed relative to each other and will tell you how many lines they span. This means ElmSyntaxPrint can pick this up and format it in a way compatible with the compiler or Elm.Parser.

Some additional lenient parsing:

• f | g → f |> g

• a != b → a /= b

• merges consecutive , in record, list or explicit exposing

• removes extra , before first record field, list element or expose

• removes remove extra | before first variant declaration

• corrects expression record field name-value separators

  { name : value } or { name value }

  → { name = value }

• corrects type record field name-value separators

  { name = value } or { name value }

  → { name : value }

• expands expression record field punning

  { field } → { field = field }

• corrects -> to = in an expression declaration and let expression declaration

  function parameters -> result

  → function parameters = result

• allows omitting the name before the type in an expression declaration or let expression declaration

  : Type
  function parameters =
      result

  →

  function : Type
  function parameters =
      result

• allows matching everything before

  3 |> String.toInt case
      Nothing ->
          0
  
  
      Just n ->
          n

  →

  case 3 |> String.toInt of
      Nothing ->
          0
  
  
      Just n ->
          n

• moves import statements anywhere at the top level to the import section

• corrects exposing (...) → (..)

That's all you'll need most of the time.

Sometimes it's useful to parse only some part of the syntax, to, say, display only an expression in an article or reparse only the touched declarations on save.

whitespace

low-level