Earlier versions of Syntax supported custom state which have been used in the bash pretty printer example to implement indentation. We removed the custom state support but indentation is common use case enough to have special support it in syntax/printer.

It would be great if we could support ScalaJS.

Parsing something like this —

FOO
[FOO
[[FOO]]
[[[FOO]]]

In the above syntax, FOO can be wrapped any number of times inside a square bracket.
The parser is implemented using the following code —

val foo = Syntax.string("FOO", "foo")

def wrappedN(foo: Syntax[String, Char, Char, String]): Syntax[String, Char, Char, String] = {
  val wrapped = foo.between(Syntax.char('['), Syntax.char(']'))
  wrapped | wrappedN(wrapped)
}

val syntax = wrappedN(foo)

val input = "[[FOO]]"

println(syntax.parseString(input)) // Stack overflow exception

Failing Test: https://github.com/zio/zio-parser/pull/115/files

Update 1:
Using a lazy val instead of a def works properly.

lazy val syntax: Syntax[String, Char, Char, Unit] =
  (
    Syntax.string("FOO", {}) | syntax
  ).between(Syntax.char('['), Syntax.char(']'))

As we discovered on Zymposium on 22th of April, this example:

import zio.Chunk
import zio.parser._
import zio.parser.internal.Debug

object Example extends App {


  case class ChessCoord(row: Char, col: Byte)
  case class ChessMove(from: ChessCoord, to: ChessCoord)

  val chessCoord =
    (Syntax.charIn("ABCDEFGH") ~ Syntax.digit.transform(
      _.toString.toByte,
      (byte: Byte) => byte.toString.head
    )).transform(
      { case (r, c) => ChessCoord(r, c) },
      (cc: ChessCoord) => (cc.row, cc.col)
    )

  val whitespaces = Syntax.whitespace.repeat.unit(Chunk(' '))

  val chessMove =
    (chessCoord ~ whitespaces ~ Syntax.string("->", ()) ~ whitespaces ~ chessCoord).transform(
      { case (from ,to) => ChessMove(from, to) },
      (cm: ChessMove) => (cm.from, cm.to)
    )

  Debug.printParserTree(chessMove.asParser.optimized)

  val parsed = chessMove.parseString("""E1  -> A4""")
  val printed = chessMove.printString(parsed.toOption.get)

  println(parsed)
  println(printed)
}

runs very slowly.

It would be great if we supported ScalaNative.

Instead of a.widen[S] | b.widen[S] | c.widen[S]

Write more benchmarks and see if Regex implementation can be further optimized, as it will speed up all string parsers.

The contributor's guide link is broken
https://zio.dev/about/contributing in the README

It would be very similar to the .to[] macro in zio-config

It is only added accidentally

It would be nice to know the position where Syntax.end failed, and exactly what part of the input was left unconsumed.

I've encountered that repeat/repeatWithSep silently swallow errors, and the only way to know about the error is to use Syntax.end, but it doesn't provide any information about the parsing error either.

Ability to pretty print parser errors to the console, as demonstrated on ZIO World

The Syntax/Parser/Printer types are all designed to be generic in their input/output types but currently the parser input is fixed to be String, fixing the parser input to be Char. This is for performance reasons, but we could reintroduce this feature for non performance critical applications.

An operator (let's say >>>) can be introduced to plug Syntaxes with compatible input/outputs together.

Earlier versions of the parser supported streaming input which was dropped in favor of using strings directly to maximize performance. We should keep the direct string parsing for use cases where high performance is needed but could also reintroduce support for streaming input:

• Parsing input to be a ZStream of characters
• Syntax converted to sink/pipeline to inject parsing and printing into streams
• Reintroduce the cut operator and the maxDistance modifier to control memory buffering required for backtracking on streams

Understand why the lucene query example fails on pretty printing and either fix the issue or try to improve Syntax to avoid creating such syntaxes.