Scala парсер комбинатор для списка логотипов?

Question

Я пытаюсь создать на основе токенов анализатор скалы для логотипа UCB. Проблема, с которой я сталкиваюсь, заключается в том, что в Logo любое выражение, которое перечисляет значения логотипа UCB в списке, может быть разделено одним из ']', '[', ' '. Если есть какие-либо другие виды разделителей, содержимое в списке следует рассматривать как слово.

Короче говоря, как я могу сделать анализатор токенов, который будет учитывать следующее:
[ 4 3 2 ] - должен быть список
[ [ 4 3 2 ] ] - должен быть список в списке
[ 1 + 2 ] - должно быть слово внутри списка
[ [ 1 2 3 ] + ] - должно быть слово внутри списка

Следующие

 '[' ~ rep(chrExcept('[', ']')) ~ ']'

производит эти токены: токены: List([, [1 2 3], +, ])

от [ [ 1 2 3 ] + ], Я считаю, что это должно произвести токены:List([, [1 2 3] +, ]) -> объединить знак + с токеном [1 2 3],

Это текущий код Lexical, который я использую:

package lexical

import scala.language.postfixOps

import scala.util.parsing.combinator.lexical.Lexical
import scala.util.parsing.input.CharSequenceReader._

/**
 * Created by Marin on 28/03/16.
*/
class MyLexical extends Lexical with MyTokens {

def token: Parser[Token] = (
    //procDef                                   ^^ { case first ~ chars => processNewProcedure(chars  mkString "") }
  word2 ^^ { case rest => {

      /*val s = if (second.isEmpty) "" else second mkString ""
      val t = if(third.isEmpty) "" else  third mkString ""
      val f = if(fourth.isEmpty) "" else fourth mkString ""

      StringLit(s"$first$s$t$f$rest")*/

      println(rest)
      StringLit("Smth")
  }
  }
  | formalChar ~ rep(identChar | digit)       ^^ { case first ~ rest => Formal(first :: rest mkString "") }
  | identChar ~ rep(identChar | digit)        ^^ { case first ~ rest => processIdent(first :: rest mkString "") }
  | procDigit                                 ^^ { case first ~ second ~ rest => NumericLit((first mkString "") :: second.getOrElse("") :: rest mkString "") }
  | '\"' ~ rep(chrExcept('\"', EofCh)) ~ ' '  ^^ { case '\"' ~ chars ~ ' ' => StringLit(chars mkString "") }
  | EofCh                                     ^^^ EOF
  | delim
  | failure("Illegal character")
  )

def processNewProcedure(chars: String) =
    if(reserved.contains(chars)) throw new RuntimeException
    else {
        Identifier(chars)
    }

def procDef = toSeq ~> identChar ~ rep(identChar | elem('_')) <~ formalChar.* <~ endSeq

def toSeq = 't' ~ 'o' ^^^ "to"
def endSeq = 'e' ~ 'n' ~ 'd' ^^^ "end"

def processIdent(name: String) = {

    if (reserved contains name) {
        Keyword(name)
    } else {
        Identifier(name)
    }
}

def word = {

    '[' ~ ((whitespaceChar | digit)*) ~ (_delim | identChar) ~ rep(whitespaceChar | digit) ~ ']'
}

def word2 = {

    //'[' ~> rep(whitespaceChar | digit) ~> rep(_delim | identChar) <~ rep(whitespaceChar | digit) <~ ']'
    //'[' ~ rep(chrExcept('[', ']')) ~ ']'

    rep1('[') ~ rep1(chrExcept('[', ']') | digit) ~ rep(_delim) ~ rep1(']')

    //rep1('[') ~ identChar ~ rep(']') ~ rep('+') ~ rep1(']')
    //'[' ~ (_delim | chrExcept('[', ']')) ~ ']'
}

def word3 = {

    '[' ~> rep(digit | letter | _delim) <~ ']'
}

def procDigit = digit.+ ~ '.'.? ~ digit.*

def identChar = letter | elem('_')

def formalChar =  ':' ~ identChar

override def whitespace: Parser[Any] = rep[Any] (
    whitespaceChar
    | ';' ~ comment
)

def comment: Parser[Any] = rep(chrExcept(EofCh, ';')) ^^ { case _ => ' ' }


/****** Pure copy-paste ******/

/** The set of reserved identifiers: these will be returned as `Keyword`s. */
val reserved = new scala.collection.mutable.HashSet[String]

/** The set of delimiters (ordering does not matter). */
val delimiters = new scala.collection.mutable.HashSet[String]

private lazy val _delim: Parser[Token] = {
    // construct parser for delimiters by |'ing together the parsers for the individual delimiters,
    // starting with the longest one -- otherwise a delimiter D will never be matched if there is
    // another delimiter that is a prefix of D
    def parseDelim(s: String): Parser[Token] = accept(s.toList) ^^ { x => Keyword(s) }

    val d = new Array[String](delimiters.size)
    delimiters.copyToArray(d, 0)
    scala.util.Sorting.quickSort(d)
    (d.toList map parseDelim).foldRight(failure("no matching delimiter"): Parser[Token])((x, y) => y | x)
}
protected def delim: Parser[Token] = _delim
}