Range-based facts generation

src/main/scala/pl/edu/agh/kis/eis/ndl/parser/FactParser.scala

+package pl.edu.agh.kis.eis.ndl.parser
+
+import pl.edu.agh.kis.eis.ndl.{Fact, FactGenerator, RangeFact}
+
+class FactParser extends FunctorParser {
+  val range: Parser[Range] = value ~ ".." ~ value ^^ { case start ~ _ ~ end => start to end }
+
+  val rangeUnaryFact: Parser[FactGenerator[Domain]] = braced(functorName ~ range ^^
+    { case name ~ r => RangeFact(name, r) })
+
+  val rangeBinaryFact: Parser[FactGenerator[Domain]] = braced(functorName ~ range ~ range ^^
+    { case name ~ r1 ~ r2 => RangeFact(name, r1, Some(r2)) })
+
+  val fact: Parser[Fact[Domain]] = functor ^^ { Fact(_) }
+
+  val factGen: Parser[FactGenerator[Domain]] = rangeUnaryFact | rangeBinaryFact | fact
+}

src/main/scala/pl/edu/agh/kis/eis/ndl/parser/FunctorParser.scala

@@ -7,15 +7,16 @@ import scala.util.parsing.combinator.JavaTokenParsers
 class FunctorParser extends JavaTokenParsers {
   type Domain = Int
 
-  def variable: Parser[Variable[Int]] = "[A-Za-z]+".r ^^ Variable[Int]
-  def const: Parser[Const[Int]] = wholeNumber ^^ { number => Const(number.toInt) }
-  def param: Parser[VarOrAtom[Int]] = const | variable
+  def variable: Parser[Variable[Domain]] = "[A-Za-z]+".r ^^ Variable[Domain]
+  def value: Parser[Domain] = wholeNumber ^^ (_.toInt)
+  def const: Parser[Const[Domain]] = value.map(Const(_))
+  def param: Parser[VarOrAtom[Domain]] = const | variable
   def functorName: Parser[String] = "[A-Za-z=\\\\<]+".r
-  def functorArgs: Parser[Functor[Int]] = functorName ~ rep1(param) ^^ {
-    case name ~ params => Functor[Int](name, params: _*)
+  def functorArgs: Parser[Functor[Domain]] = functorName ~ rep1(param) ^^ {
+    case name ~ params => Functor[Domain](name, params: _*)
   }
 
   def braced[T](parser: Parser[T]): Parser[T] = "(" ~> parser <~ ")"
 
-  def functor: Parser[Functor[Int]] = braced(functorArgs)
+  def functor: Parser[Functor[Domain]] = braced(functorArgs)
 }

src/main/scala/pl/edu/agh/kis/eis/ndl/parser/NDLParser.scala

 package pl.edu.agh.kis.eis.ndl.parser
 import pl.edu.agh.kis.eis.ndl._
 
-import scala.util.parsing.input.CharSequenceReader
-
-class NDLParser extends FunctorParser with ConstraintParser[FunctorParser#Domain] {
-  def parse(input: String): ParseResult[NDL[Domain]] =
-    parser(new CharSequenceReader(input))
+class NDLParser extends FactParser with ConstraintParser[FunctorParser#Domain] {
+  def parse(input: String): ParseResult[NDL[Domain]] = parse(parser, input)
 
   def parser: Parser[NDL[Domain]] =
-    (functor | query).map {
-      case f: Functor[Domain] => Fact(f)
+    (factGen | query).map {
+      case f: FactGenerator[Domain] => f
       case q: List[Functor[Domain]] => buildQuery(q)
     }
 

src/main/scala/pl/edu/agh/kis/eis/ndl/repl/REPL.scala

@@ -22,16 +22,18 @@ trait REPL extends App with LazyLogging {
 
   def read(): parser.ParseResult[NDL[Domain]] = {
     val input: String = readInput()
-    val parsed = parser.parser(new CharSequenceReader(input))
+    val parsed = parser.parse(input)
     logger.trace("parse result: {}", parsed)
     parsed
   }
 
   def eval(kb: KnowledgeBase[Domain], in: NDL[Domain]): Evaluation = {
     in match {
-      case fact: Fact[Domain] =>
+      case fact: FactGenerator[Domain] =>
         logger.trace("eval(): expanding kb")
-        (kb.addFact(fact), Iterator.empty)
+        // FIXME poor performance (set rebuild for each fact)
+        val augmentedKb = fact.generate.foldLeft(kb) { (newKb, x) => newKb.addFact(x) }
+        (augmentedKb, Iterator.empty)
       case q: Query[Domain] =>
         logger.trace("eval(): query")
         (kb, executeQuery(kb)(q))

src/main/scala/pl/edu/agh/kis/eis/ndl/KnowledgeBase.scala

 package pl.edu.agh.kis.eis.ndl
 
 import pl.edu.agh.kis.eis.ndl
-import pl.edu.agh.kis.eis.ndl.constraint.Constraint
 
 class KnowledgeBase[A](val facts: Set[Product])(implicit ordering: Ordering[A]) extends
   FactSelector[A] with QueryExecutor[A] {