여러 옵션 스칼라에서 효과적인 패턴 매칭 방법

우선 스칼라가 채택한 권장 코드 스타일에 대한 의견이 거의 없습니다.

변수/함수/def 이름은 camelCase 로되어 있습니다

incomeScreenStatus   IncomeScreenStatus 대신 .

statusCd   status_cd 대신

passInd   pass_ind 대신

이제

def incomeScreenStatus(statusCd: Option[String],
                       score: Option[Int],
                       income: Option[Double]) : String  = {
  (score, income, statusCd) match {
    case (Some(scoreV), Some(incomeV), Some(statusCdV)) => {
      (statusCdV, incomeV, scoreV) match {
        case ("UNEMPLOYMENT", _, _) if incomeV <= 7000 => "p"
        case ("STUDENT", _, _) if incomeV <= 18000 => "p"
        case _ if (scoreV < 100 || scoreV > 150) && incomeV <= 8500 => "P"
        case _ if (scoreV <= 167 && scoreV >= 100) && incomeV <= 10500 => "P"
        case _ => "F"
      }
    }
    case _ => "F"
  }
}

어쩌면 이렇게 될까요? (나는 그것을 시도하지 않았으며 그것이 정확하다는 것을 보증하지 않습니다.)

def IncomeScreenStatus( mb_status_cd : Option[String], mb_score : Option[Int], mb_income : Option[Double]) : String  = {
  def nsu( score : Int, income : Double ) = { // neither student nor unemployed
    if ( (score < 100 || score > 150) && income <= 8500 )         "P"
    else if ( (score <= 167 && score >= 100) && income <= 10500 ) "P"
    else                                                          "F"
  }
  ( mb_status_cd, mb_score, mb_income ) match {
    case ( Some( "STUDENT"                  ), Some( score ), Some( income ) ) if ( income <= 18000 ) => "P"
    case ( Some( "UNEMPLOYMENT"             ), Some( score ), Some( income ) ) if ( income <=  7000 ) => "P"
    case ( Some( "STUDENT" | "UNEMPLOYMENT" ), Some( _     ), Some( _      ) )                        => "F"
    case ( Some( _                          ), Some( score ), Some( income ) )                        => nsu( score, income )
    case _                                                                                            => "F"
  }
}

여기에 첫 번째 균열이 있습니다.

def IncomeScreenStatus(status_cd: Option[String]
                      ,score    : Option[Int]
                      ,income   : Option[Double]) : String  = {
  for {
    stat <- status_cd
    scr  <- score
    incm <- income
  } yield stat match {
    case "UNEMPLOYMENT" => if (incm <=  7000) "P" else "F"
    case "STUDENT"      => if (incm <= 18000) "P" else "F"
    case _ => if ((scr <  100 || scr >  150) && incm <=  8500 ||
                  (scr <= 167 && scr >= 100) && incm <= 10500) "P" else "F"
  }
}.getOrElse("F")

전달 된 매개 변수와 같은 이름으로 지역 변수를 생성하면 실제로 컴파일러가 혼동됩니다.

함수 프로그래밍에서는 큰 함수 대신 작은 함수를 사용하는 것이 좋습니다. 아래처럼 무언가를 선호합니다 :

 def screenStudent(income:Double):String = {
    if (income <= 18000) "P" else "F"
  }
  def screenUnemployment(income:Double):String = {
    if (income <= 7000) "P" else "F"
  }
  def screenOthers(income:Double, score:Int):String = {
    (income, score) match {
      case (income, score) if (score < 100 || score > 150) && income <= 8500 => "P"
      case (income, score) if (score <= 167 && score >= 100) && income <= 10500 => "P"
      case _ => "F"
    }
  }
  def incomeScreenStatus(
    status_cd: Option[String],
    score: Option[Int],
    income: Option[Double]
  ) : String  =
  (status_cd , score, income) match {
    case (Some("STUDENT"), Some(_), Some(i)) => screenStudent(i)
    case (Some("UNEMPLOYMENT"), Some(_), Some(i)) => screenUnemployment(i)
    case (Some(_), Some(s), Some(i)) => screenOthers(i, s)
    case _ => "F"
  }

예를 들어 각 필드를 정의해야하므로 Option 를 압축 할 수 있습니다 함께. 또한 본인의 진술서에 명시 적 경비원 대신 추출기를 사용하고 싶습니다.

귀하의 상태가 유한 세트 인 경우 sealed trait 를 사용하는 것이 좋습니다.  그것을 표현하기 위해.

object Example {
  sealed trait Status
  case object Student extends Status
  case object Unemployed extends Status
  case object Other extends Status
  object PoorStudent {
    def unapply(income: Int) = if (income <= 18000) Some(income) else None
  }
  object PoorUnemployed {
    def unapply(income: Int) = if (income <= 7000) Some(income) else None
  }
  object IncomeScoreRange {
    def unapply(score: Int, income: Double) =
      if (((score < 100 || score > 150) && income <= 8500) || (income <= 10500 && (100 to 167 contains score)))
        Some((score, income))
      else
        None
  }
  def compute(status: Option[Status], score: Option[Int], income: Option[Double]): String = {
    (status, score, income).zipped
      .collect {
        case (Student, _, PoorStudent(_))                    => "P"
        case (Unemployed, _, PoorUnemployed(_))              => "P"
        case (Other, IncomeScoreRange(_, _))                 => "P"
      }
      .headOption
      .getOrElse("F")
  }
}