Skip to content

Expression parser #449

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
christiankjaer wants to merge 6 commits into
base: main
Choose a base branch
from
Open

Expression parser #449

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
940e2dd
Ported expression parser
Sep 25, 2022
bf3fc53
Added some tests
Sep 25, 2022
cf079c3
Add comments
Sep 25, 2022
526d7ef
Get rid of flatMap
Sep 27, 2022
50b6487
Property based test
Sep 27, 2022
0ef7837
Added microbenchmark
Sep 27, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Property based test
  • Loading branch information
Christian Kjær Larsen committed Sep 27, 2022
commit 50b6487f4a856892d67ea7a0e569112671b29431
11 changes: 7 additions & 4 deletions core/shared/src/main/scala/cats/parse/expr/ExprParser.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,12 @@ import cats.parse.{Parser, Parser0}

object ExprParser {

/** Parser of binary operator
*/
type BinP[A] = Parser[(A, A) => A]

/** Parser of unary operator
*/
type UnP[A] = Parser[A => A]

/** Takes a parser for terms and a list of operator precedence levels and returns a parser of
Expand All @@ -34,7 +39,7 @@ object ExprParser {
def make[A](term: Parser[A], table: List[List[Operator[A]]]): Parser[A] =
table.foldLeft(term)(addPrecLevel)

/** Internal helper class for splitting an operator precedence level into the varios types.
/** Internal helper class for splitting an operator precedence level into the various types.
*/
private final case class Batch[A](
inn: List[BinP[A]],
Expand All @@ -61,12 +66,10 @@ object ExprParser {

private def addPrecLevel[A](p: Parser[A], level: List[Operator[A]]): Parser[A] = {

val idParser = Parser.pure((x: A) => x)

val batch = Batch(level)

def orId(p: Parser[A => A]): Parser0[A => A] =
p.orElse(idParser)
p.orElse(Parser.pure((x: A) => x))

def parseTerm(prefix: UnP[A], postfix: UnP[A]): Parser[A] =
(orId(prefix).with1 ~ p ~ orId(postfix)).map { case ((pre, t), post) =>
Expand Down
12 changes: 6 additions & 6 deletions core/shared/src/main/scala/cats/parse/expr/Operator.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,23 +28,23 @@ import cats.parse.Parser
sealed abstract class Operator[A]
object Operator {

/** Non-associative infix operator. Example: &&, ||
*/
/** Non-associative infix operator. Example: ==, !=
*/
final case class InfixN[A](c: Parser[(A, A) => A]) extends Operator[A]

/** Left-associative infix operator. Example: +, *, /
*/
*/
final case class InfixL[A](c: Parser[(A, A) => A]) extends Operator[A]

/** Right-associative infix operator. Example: assignment in C
*/
*/
final case class InfixR[A](c: Parser[(A, A) => A]) extends Operator[A]

/** Prefix operator like for instance unary negation
*/
*/
final case class Prefix[A](c: Parser[A => A]) extends Operator[A]

/** Postfix operator
*/
*/
final case class Postfix[A](c: Parser[A => A]) extends Operator[A]
}
147 changes: 125 additions & 22 deletions core/shared/src/test/scala/cats/parse/ExprTest.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -23,11 +23,13 @@ package cats.parse

import cats.parse.expr.ExprParser
import cats.parse.expr.Operator
import org.scalacheck.Prop.forAll
import org.scalacheck.Gen

class ExprTest extends munit.FunSuite {
object ExprTest {

sealed trait Exp
final case class N(n: String) extends Exp
sealed abstract class Exp
final case class N(n: Int) extends Exp
final case class Neg(a: Exp) extends Exp
final case class Q(a: Exp) extends Exp
final case class Minus(a: Exp, b: Exp) extends Exp
Expand All @@ -52,46 +54,147 @@ class ExprTest extends munit.FunSuite {
Operator.InfixL(token(Parser.char('-')).as(Minus.apply))
),
List(
Operator.InfixN(token(Parser.char('&')).as(And.apply)),
Operator.InfixN(token(Parser.char('&')).as(And.apply))
),
List(
Operator.InfixR(token(Parser.char('=')).as(Eq.apply))
)
)

def pLevel(e: Exp): Int = e match {
case N(_) => -1
case Neg(_) | Q(_) => 0
case Times(_, _) => 1
case Plus(_, _) | Minus(_, _) => 2
case And(_, _) => 3
case Eq(_, _) => 4
}

/** Quick and dirty pretty printer than inserts few parenthesis
*/
def pp(e: Exp): String = {

// Left-associative. Precedence level should be lower in right branch
def leftAssoc(level: Int, a: Exp, b: Exp, op: String): String = {
val leftStr = if (pLevel(a) <= level) pp(a) else s"(${pp(a)})"
val rightStr = if (pLevel(b) < level) pp(b) else s"(${pp(b)})"
s"$leftStr $op $rightStr"
}
e match {
case N(n) => n.toString

case Neg(a) =>
if (pLevel(a) < 0) s"-${pp(a)}" else s"-(${pp(a)})"

case Q(a) =>
if (pLevel(a) < 0) s"${pp(a)}?" else s"(${pp(a)})?"

case Times(a, b) => leftAssoc(1, a, b, "*")
case Plus(a, b) => leftAssoc(2, a, b, "+")
case Minus(a, b) => leftAssoc(2, a, b, "-")

// Non-associative. Precedence level should be lower in both branches
case And(a, b) => {
val leftStr = if (pLevel(a) < 3) pp(a) else s"(${pp(a)})"
val rightStr = if (pLevel(b) < 3) pp(b) else s"(${pp(b)})"
s"$leftStr & $rightStr"
}

// Right-associative. Precedence level should be lower in left branch
case Eq(a, b) => {
val leftStr = if (pLevel(a) < 4) pp(a) else s"(${pp(a)})"
val rightStr = if (pLevel(b) <= 4) pp(b) else s"(${pp(b)})"
s"$leftStr = $rightStr"
}
}
}

val genN: Gen[Exp] = Gen.choose(0, 100).map(N.apply)

val genAnd: Gen[Exp] = genExp.flatMap(a => genExp.map(b => And(a, b)))
val genEq: Gen[Exp] = genExp.flatMap(a => genExp.map(b => Eq(a, b)))
val genPlus: Gen[Exp] = genExp.flatMap(a => genExp.map(b => Plus(a, b)))
val genMinus: Gen[Exp] = genExp.flatMap(a => genExp.map(b => Minus(a, b)))
val genTimes: Gen[Exp] = genExp.flatMap(a => genExp.map(b => Times(a, b)))
val genNeg: Gen[Exp] = genExp.map(a => Neg(a))
val genQ: Gen[Exp] = genExp.map(a => Q(a))

def genExp: Gen[Exp] = Gen.sized(n =>
if (n <= 1) genN
else
Gen.oneOf(
Gen.lzy(Gen.resize(n / 2, genAnd)),
Gen.lzy(Gen.resize(n / 2, genEq)),
Gen.lzy(Gen.resize(n / 2, genPlus)),
Gen.lzy(Gen.resize(n / 2, genMinus)),
Gen.lzy(Gen.resize(n / 2, genTimes)),
Gen.lzy(Gen.resize(n - 1, genNeg)),
Gen.lzy(Gen.resize(n - 1, genQ))
)
)

}

class ExprTest extends munit.ScalaCheckSuite {

import ExprTest._

test("non-recursive") {

val term = token(Numbers.digits.map(N.apply))
val term = token(Numbers.nonNegativeIntString.map(x => N(x.toInt)))
val exprParser = ExprParser.make(term, table)

assertEquals(exprParser.parseAll("1"), Right(N("1")))
assertEquals(exprParser.parseAll("-1"), Right(Neg(N("1"))))
assertEquals(exprParser.parseAll("-1?"), Right(Q(Neg(N("1")))))
assertEquals(exprParser.parseAll("1 + 2"), Right(Plus(N("1"), N("2"))))
assertEquals(exprParser.parseAll("1 + -2"), Right(Plus(N("1"), Neg(N("2")))))
assertEquals(exprParser.parseAll("1 + 2 - 3"), Right(Minus(Plus(N("1"), N("2")), N("3"))))
assertEquals(exprParser.parseAll("1 + 2 + 3 + 4"), Right(Plus(Plus(Plus(N("1"), N("2")), N("3")), N("4"))))
assertEquals(exprParser.parseAll("1+2*3"), Right(Plus(N("1"), Times(N("2"), N("3")))))
assertEquals(exprParser.parseAll("1"), Right(N(1)))
assertEquals(exprParser.parseAll("-1"), Right(Neg(N(1))))
assertEquals(exprParser.parseAll("-1?"), Right(Q(Neg(N(1)))))
assertEquals(exprParser.parseAll("1 + 2"), Right(Plus(N(1), N(2))))
assertEquals(exprParser.parseAll("1 + -2"), Right(Plus(N(1), Neg(N(2)))))
assertEquals(exprParser.parseAll("1 + 2 - 3"), Right(Minus(Plus(N(1), N(2)), N(3))))
assertEquals(
exprParser.parseAll("1 + 2 + 3 + 4"),
Right(Plus(Plus(Plus(N(1), N(2)), N(3)), N(4)))
)
assertEquals(exprParser.parseAll("1+2*3"), Right(Plus(N(1), Times(N(2), N(3)))))
assert(exprParser.parseAll("1 & 2 & 3").isLeft)
assertEquals(exprParser.parseAll("1 = 2"), Right(Eq(N("1"), N("2"))))
assertEquals(exprParser.parseAll("1 & 2"), Right(And(N("1"), N("2"))))
assertEquals(exprParser.parseAll("1 = 2 + 3"), Right(Eq(N("1"), Plus(N("2"), N("3")))))
assertEquals(exprParser.parseAll("1 = 2 = 3"), Right(Eq(N("1"), Eq(N("2"), N("3")))))
assertEquals(exprParser.parseAll("1 = 2"), Right(Eq(N(1), N(2))))
assertEquals(exprParser.parseAll("1 & 2"), Right(And(N(1), N(2))))
assertEquals(exprParser.parseAll("1 = 2 + 3"), Right(Eq(N(1), Plus(N(2), N(3)))))
assertEquals(exprParser.parseAll("1 = 2 = 3"), Right(Eq(N(1), Eq(N(2), N(3)))))
assertEquals(exprParser.parseAll("1 = 2 & 3"), Right(Eq(N(1), And(N(2), N(3)))))
assertEquals(exprParser.parseAll("1 & 2 = 3"), Right(Eq(And(N(1), N(2)), N(3))))

}

test("recursive") {

val exprParser = Parser.recursive[Exp] { expr =>
val term = token(Numbers.digits.map(N.apply)) | expr.between(
val term = token(Numbers.nonNegativeIntString.map(n => N(n.toInt))) | expr.between(
token(Parser.char('(')),
token(Parser.char(')'))
)
ExprParser.make(term, table)
}

assertEquals(exprParser.parseAll("( (2) )"), Right(N(2)))
assertEquals(exprParser.parseAll("-(-1)"), Right(Neg(Neg(N(1)))))
assertEquals(exprParser.parseAll("1*( 2+3 )"), Right(Times(N(1), Plus(N(2), N(3)))))
assertEquals(exprParser.parseAll("(1 = 2) = 3?"), Right(Eq(Eq(N(1), N(2)), Q(N(3)))))

}

property("foo") {

val exprParser = Parser.recursive[Exp] { expr =>
val term = token(Numbers.nonNegativeIntString.map(x => N(x.toInt))) | expr.between(
token(Parser.char('(')),
token(Parser.char(')'))
)
ExprParser.make(term, table)
}

assertEquals(exprParser.parseAll("( (2) )"), Right(N("2")))
assertEquals(exprParser.parseAll("-(-1)"), Right(Neg(Neg(N("1")))))
assertEquals(exprParser.parseAll("1*( 2+3 )"), Right(Times(N("1"), Plus(N("2"), N("3")))))
assertEquals(exprParser.parseAll("(1 = 2) = 3?"), Right(Eq(Eq(N("1"), N("2")), Q(N("3")))))
forAll(genExp) { (e: Exp) =>
assertEquals(exprParser.parseAll(pp(e)), Right(e))
}

}

Expand Down