Combinators Scala Parser: Liste d'extrait d'un type

Question

J'écris l'analyseur et le grammer en utilisant scala.util.parsing.combinator. Mon entrée est ":za >= 1 alok && :ft == 9"

case class Expression(op1:Operand,operator:Operator,op2:Operand) 

def word: Parser[String] = """[a-z\\\s]+""".r ^^ { _.toString } 

def colonWord:Parser[Operand]=":"~> word ^^{case variable => Operand(variable)} 

def constant:Parser[Operand]="""^[a-zA-Z0-9\\\s-]*""".r ^^ {case constant => Operand(constant)} 

def expression:Parser[Expression] = colonWord ~ operator ~ constant ^^{ case op1~operator~op2 => Expression(op1, operator, op2)} 

def expressions = expression ~ opt(" && " ~> expression)* 

mais quand je parse chaîne de l'exemple, le résultat ne devrait pas. La deuxième expression après && n'est pas analysée. Veuillez noter qu'il peut y avoir plusieurs expressions jointes en utilisant &&.

Quand j'Execute:

val expr= ":za >= 1 alok && :ft == 9" 
    parse(expressions, expr) match { 
     case Success(matched, _) => println(matched) 
     case ..} 

sortie est:

List((Expression(za ,>= ,1 alok)~None)) 

Je ne vois pas la deuxième expression en cours d'analyse. Quelqu'un peut-il aider ce que j'ai manqué ici?

EDIT -----------------------------------

Le l'exigence est d'obtenir List[Expression]. quand je dis, incorporting les changements mentionnés à Ans:

def expressions = expression ~ ("&&" ~> expression)* 

Le type de retour des expressions est pas la liste [expression]. Pour exemple: Si j'écris une autre définition:

case class Condition(exprs: List[Expression], st:Statement) 
def condition = expressions ~","~statement ^^{ 
    case exprs~commaa~statement => Condition(exprs,statement) //This is giving error. 

l'erreur est: incompatibilité de type; trouvé: ~ [Expression, Expression]] requis: Expressions. Alors comment convertir [Expression, Expression] en List [Expressions]? Comment convertir une expression [Expression, Expression] en List [Expressions]?

Merci

Answer 1

La correction nécessaire était:

expression ~ opt("&&" ~> expression)* 

espace Supprimer dans && et il devrait fonctionner. C'est parce que vous couvrez déjà l'espace dans votre parseur constant.

Edit: Sur la base de question éditée, est-ce que vous voulez:

def expressions = expression ~ (("&&" ~> expression)*) ^^{ 
    case x ~ y => x :: y 
    } 

Maintenant, le type de retour est expressionsList[Expression]. Votre condition va maintenant compiler