Условное накопление scala

Достаточно ли этого решения?

scala> val stringToParse = "ignore/me/$aaa$/once-again/ignore/me/$bbb$/still-to-be/ignored"
stringToParse: String = ignore/me/$aaa$/once-again/ignore/me/$bbb$/still-to-be/ignored

scala> val P = """\$([^\$]+)\$""".r
P: scala.util.matching.Regex = \$([^\$]+)\$

scala> P.findAllIn(stringToParse).map{case P(s) => s}.toSeq
res1: Seq[String] = List(aaa, bbb)

Я представлю вам два решения. Первый - это самый прямой перевод того, что вы сделали. В Scala слово accumulate обычно переводится как вариант fold или reduce.

def

 extractValues(s: String) =
  {
    //We can combine the functionality of your boolean and stringbuilder by using an Option
    s.foldLeft[(ListBuffer[String],Option[StringBuilder])]((new ListBuffer[String], Option.empty))
                  {
                    //As we fold through, we have the accumulated list, possibly a partially built String, and the current letter
                    case ((accumulator,sbOption),char) =>
                    {
                      char match
                      {
                        //This logic pretty much matches what you had, adjusted to work with the Option
                        case '$' =>
                        {
                          sbOption match
                          {
                            case Some(sb) =>
                            {
                              accumulator.append(sb.mkString)
                              (accumulator,None)
                            }
                            case None =>
                            {
                              (accumulator,Some(new StringBuilder))
                            }
                          }
                        }
                        case _ =>
                        {
                          sbOption.foreach(_.append(char))
                          (accumulator,sbOption)
                        }
                      }
                    }
                  }._1.map(_.mkString).toList
  }

Однако это кажется довольно сложным, поскольку кажется, что это должна быть простая задача. Мы можем использовать регулярные выражения, но это страшно, поэтому давайте их избегать. На самом деле, если немного подумать, эта проблема становится довольно простой.

 def extractValuesSimple(s: String)=
  {
    s.split('$').//split the string on the $ character
      dropRight(1).//Drops the rightmost item, to handle the case with an odd number of $
      zipWithIndex.filter{case (str, index) => index % 2 == 1}.//Filter out all of the even indexed items, which will always be outside of the matching $
      map{case (str, index) => str}.toList//Remove the indexes from the output
  }