[parser4k] Add by delegates for .with caching

[duangsuse]

object MinimalCalculator {
    val cache = OutputCache<BigDecimal>()
    fun binaryExpr(s: String) = inOrder(ref { expr }, token(s), ref { expr })

    val number = oneOrMore(oneOf('0'..'9')).map { it.joinToString("").toBigDecimal() }.with(cache)
}

why not add getValue(k, p, self) for OutputCache:

class OutputCacheBy<out T>(private val p: Parser<T>) {
  fun getValue(k: KClass<*>, p: KProperty<*>, self: OutputCache) = p.with(self)
}

and then:

object MinimalCalculator {
    val cache = OutputCache<BigDecimal>()
    fun binaryExpr(s: String) = inOrder(ref { expr }, token(s), ref { expr })

    val number = by cache { oneOrMore(oneOf('0'..'9')).map { it.joinToString("").toBigDecimal() } }
}

Eh... looks ugly, but in real projects, I think p.with(cache) should have a shorter expression (maybe with a CachedParsers baseclass ext-fun?).

[daviddenton]

@dkandalov ... 😄

[dkandalov]

Sorry for the slow response.
@duangsuse yes, I was thinking about exactly this approach just haven't experimented with it enough yet.
If you have some code for PR or can just add it here as a comment, I'll be happy to try it out.

[duangsuse]

Sorry for the slow response.
@duangsuse yes, I was thinking about exactly this approach just haven't experimented with it enough yet.
If you have some code for PR or can just add it here as a comment, I'll be happy to try it out.

Eh... Finally, I've found that the usage of getValue is incorrect(or changed) in 1.4, and it cannot receive /*>*/cache {} as an argument, so I decided to make self a CacheContainer<T>(cache:OutputCache<T>).

Looks better(sometimes?), but really no worth to change the original form 😄, since inline optimization is unreliable currently, and adding the first reference to kotlin.reflect seems :(

In fact, I submit this issue to complain that I don't like the modeling style used in better-parse (maybe they added by delegates for syntax analysis based optimizations); but for this project, it's really unnecessary. 😟

import parser4k.*
import parser4k.commonparsers.token
import java.io.BufferedReader
import java.io.InputStreamReader
import java.math.BigDecimal
import kotlin.reflect.KProperty

abstract class CacheContainer<T>(val cache: OutputCache<T> = OutputCache())
object MinimalCalculator: CacheContainer<BigDecimal>() {
  fun binaryExpr(s: String) = inOrder(ref { expr }, token(s), ref { expr })

  val number by cache { oneOrMore(oneOf('0'..'9')).map { it.joinToString("").toBigDecimal() } }
  val paren by cache { inOrder(token("("), ref { expr }, token(")")).skipWrapper() }

  val power by cache { binaryExpr("^").map { (l, _, r) -> l.pow(r.toInt()) } }
  val divide by cache { binaryExpr("/").mapLeftAssoc { (l, _, r) -> l.divide(r) } }
  val multiply by cache { binaryExpr("*").mapLeftAssoc { (l, _, r) -> l * r } }

  val minus by cache { binaryExpr("-").mapLeftAssoc { (l, _, r) -> l - r } }
  val plus by cache { binaryExpr("+").mapLeftAssoc { (l, _, r) -> l + r } }

  val expr: Parser<BigDecimal> = oneOfWithPrecedence(
    oneOf(plus, minus),
    oneOf(multiply, divide),
    power,
    paren.nestedPrecedence(),
    number
  ).reset(cache)

  fun evaluate(s: String) = s.parseWith(expr)
}
operator fun <T> OutputCache<T>.invoke(get_p: () -> Parser<T>) = OutputCacheBy(get_p())
class OutputCacheBy<T>(private val p: Parser<T>) {
  operator fun getValue(self: CacheContainer<T>, _p: KProperty<*>) = p.with(self.cache)
}

fun main(args: Array<String>) {
  val lr = BufferedReader(InputStreamReader(System.`in`))
  fun ps1() = print(">")
  ps1()
  while (true) {
    val ln = lr.readLine()
    if (ln.isNullOrBlank()) break
    println(MinimalCalculator.evaluate(ln)); ps1()
  }
}