Scala manera de programar el grupo de ifs

Question

estoy comenzando con scala, y trato de aplicarlo de manera funcional, pero saqué un montón de construcciones if \ if anidadas que son difíciles de leer, y me pregunto si hay alguna mejor forma de programar tales cosas? Por ejemplo he escrito guión, que realiza el equilibrio de paréntesis

def balance(chars: List[Char]): Boolean = { 
    def checkParentesys(chars: List[Char], parentesis: List[Char]): Boolean = 
     if (chars.isEmpty && parentesis.isEmpty) 
     true 
     else 
     if (chars.head == '(') 
      checkParentesys(chars.tail, '(' :: parentesis) 
     else 
      if (parentesis.isEmpty) 
       false 
      else 
       checkParentesys(chars.tail, parentesis.tail) 

    checkParentesys(chars.filter(s => s == '(' || s == ')'), List()) 
    } 

puede sugerir, cómo puedo escribir Scala más funcional y más como?

Answer 1

Puede ser que sea más agradable para escribir como un pliegue:

def balance(chars: List[Char]): Boolean = chars.foldLeft(0){ 
    case (0, ')') => return false 
    case (x, ')') => x - 1 
    case (x, '(') => x + 1 
    case (x, _ ) => x 
} == 0 

Answer 2

Bueno:

1. Se podría empezar por escribir con else if condiciones.
2. Continúe anotándolo con tailrec ya que es recursivo en la cola.
3. La condición de filtro se puede escribir más simplemente como Set('(', ')'), que es una función Char-Boolean
4. Creo que se está perdiendo la condición en la que chars está vacía, pero no es parenthesis.

Por lo que se vería así:

def balance(chars: List[Char]): Boolean = { 
    @tailrec 
    def checkParentesys(chars: List[Char], parentesis: List[Char]): Boolean = 
    if (chars.isEmpty && parentesis.isEmpty) 
     true 
    else if (chars.head == '(') 
     checkParentesys(chars.tail, '(' :: parentesis) 
    else if (chars.isEmpty || parentesis.isEmpty) 
     false 
    else 
     checkParentesys(chars.tail, parentesis.tail) 

    checkParentesys(chars.filter(Set('(', ')')), List()) 
} 

También puedes, simplemente convertir todo el asunto en una coincidencia de patrón:

def balance(chars: List[Char]): Boolean = { 
    @tailrec 
    def checkParentesys(chars: List[Char], parentesis: List[Char]): Boolean = 
    (chars, parentesis) match { 
     case (Nil, Nil) => true 
     case ('(' :: charsTail, _) => checkParentesys(charsTail, '(' :: parentesis) 
     case (Nil, _) => false 
     case (_, Nil) => false 
     case (')' :: charsTail, '(' :: parentesisTail) => checkParentesys(charsTail, parentesisTail) 
    } 
    checkParentesys(chars.filter(Set('(', ')')), List()) 
} 

Answer 3

No creo que haya ninguna razón para filtrar la lista antes de atravesarla Simplemente puede ignorar los paréntesis no a medida que atraviesa la lista. Creo que tampoco es necesario construir la segunda lista. Todo lo que quiere saber es que el recuento de paréntesis abierto nunca es negativo:

def balance(chars: List[Char]): Boolean = { 
    @tailrec 
    def _balance(chars: List[Char], count: Int) : Boolean = 
    chars match { 
     case Nil => count == 0 // end of the string did we close every open? 
     case '(' :: xs => _balance(xs, count+1) 
     case ')' :: xs => (count > 0) && _balance(xs, count-1) 
     case _ => _balance(chars.tail, count) // uninteresting char, skip it 
    } 

    _balance(chars, 0) 
} 

Answer 4

var parens :List[Char] = Nil 
def matcher(chrs: List[Char]): Boolean = { 
    if (chrs.isEmpty) { 
     return parens.isEmpty 
    } 
    else { 
     chrs.head match { 
      case '(' => parens = '(' :: parens ;matcher(chrs.tail) 
      case ')' => if (parens.isEmpty) return false 
          else if (parens.apply(0) == '(') parens = parens.drop(1) 
          else return false; 
          matcher(chrs.tail); 
      case _ => matcher(chrs.tail) 
     } 
    } 
} 

Como se puede ver que no usó el conteo porque el recuento no funcionará en()) (