중첩 목록의 일반 형식 매개 변수

Question

Prolog 목록 (예 : [1,2,3,4])을 해당 스칼라 목록으로 구문 분석해야하는 파서를 작성하려고합니다. 나는 Scalas 파싱 연결자로 파서를 프로그래밍했다.

내 파서는 지금까지 다음과 같습니다 : 더 구체적인 무언가로 처음 두 파서의 유형 매개 변수를 설정하는 가능성은

class PListParser extends JavaTokenParsers{ 
    def list:Parser[List[Any]] = "[" ~> listArgs <~ "]" 
    def listArgs:Parser[List[Any]] = list | repsep(args, ",") 
    def args:Parser[String] = "(.)*".r 
} 

있습니까? 임의의 차원의 중첩 목록에 대한 일반 매개 변수와 같지만 동일한 기본 유형입니다. 나는 그것이 나무해야한다고 생각

Answer 1

, 즉 임의의 깊이

sealed trait Tree[A] 
case class Leaf[A](value: A) extends Tree[A] { 
    override def toString: String = value.toString 
} 
case class Node[A](items: List[Tree[A]]) extends Tree[A] { 
    override def toString: String = "Node(" + items.mkString(", ") + ")" 
} 

에 중첩 된 목록에 대한 적절한 구조 (당신이 좋아 취하는 toString를 수행합니다,하지만 난 기본 하나 오히려 너무 장황 생각)

그런 다음 문법을 약간 수정하여

object PrologListParser extends JavaTokenParsers{ 
    def list:Parser[Tree[String]] = "[" ~> listArgs <~ "]" 
    def listArgs:Parser[Tree[String]] = repsep(list | args, ",") ^^ {Node(_)} 
    def args:Parser[Tree[String]] = """([^,\[\]])*""".r ^^ {Leaf(_)} 
    def parse(s: String): ParseResult[Tree[String]] = parse(list, s) 
} 


PrologListParser.parse("[a, b, [c, [d, e], f, [g], h], [i, j], k]") 

이 res0을 (+ 구문 분석 방법, 그냥 REPL에 쉽게 테스트) : Prolo를 노드 (a, b, 노드 (c, 노드 (d, e), f, 노드 (g), h), 노드 (i, j), k 테스트되지 않음)

Answer 2

()

sealed trait PrologTerm 

case class PInt(i: Integer) extends PrologTerm { 
    override def toString = i.toString 
} 
case class PAtom(s: String) extends PrologTerm { 
    override def toString = s.toString 
} 
case class PComplex(f: PAtom, args: List[PrologTerm]) extends PrologTerm { 
    override def toString = f.toString+"("+args.mkString(", ")+")" 
} 
case class PList(items: List[PrologTerm]) extends PrologTerm { 
    override def toString = "["+items.mkString(", ")+"]" 
} 

object PrologListParser extends JavaTokenParsers { 
    def term : Parser[PrologTerm] = int | complex | atom | list 
    def int : Parser[PInt] = wholeNumber ^^ {s => PInt(s.toInt)} 
    def complex : Parser[PComplex] = 
    (atom ~ ("(" ~> repsep(term, ",") <~ ")")) ^^ {case f ~ args => PAtom(f, args)} 
    def atom : Parser[PAtom] = "[a-z][a-zA-Z_]*".r ^^ {PAtom(_)} 
    def list : Parser[PList] = ("[" ~> repsep(term, ",") <~ "]") ^^ {PList(_)} 
}