2017-09-18 1 views
0

Ich möchte Studenten und Mitarbeiter erhalten, die in Land Indien und China arbeitetEffiziente Weise Fall Objekt in scala passen

object Countries { 
    sealed trait Country {def name: String} 
    case object FRANCE extends Country {val name = "FRANCE"} 
    case object INDIA extends Country {val name = "INDIA"} 
    case object CHINA extends Country {val name = "CHINA"} 
    val list = Seq(FRANCE, INDIA, CHINA) 
} 

def getCountry: Option[Countries.Country] ={ 
    //some DB call to return country based on some parameters .I assume INDIA here 
    Option(Countries.INDIA) 
} 

case class Student(name: String, id: Symbol = Symbol("Id")) 

def getStudentName(name: Option[String]): Option[Student]={ 
    val std = name 
    .filterNot(_.isEmpty) 
    .map(Student(_)) 

    getCountry.collect { 
    case Countries.INDIA => std 
    case Countries.CHINA => std 
    }.flatten    
} 

case class Emp(id: Int) 

def getEmp(id: Option[String]): Option[Emp] = { 
    val emp = id.flatMap(_ => Option(Emp(id.get.toInt))) 
    getCountry.collect { 
    case Countries.INDIA => emp 
    case Countries.CHINA => emp 
    }.flatten 
} 

Gibt es eine effiziente Möglichkeit der wiederholten Code collect und Fall Matching Ich habe getan, zu vermeiden .

+0

Ich habe abgelehnt, weil der Code nicht annähernd kompiliert, so dass die Frage für mich nicht verständlich ist. – C4stor

+0

was meinst du mit "effizient"? Meinst du Lesbarkeit (z. B. sich nicht wiederholen) oder irgendetwas anderes (z. B. bessere Leistung)? –

+0

@ C4stor bitte überprüfen – coder25

Antwort

2
def ifCountry[T](result: => Option[T], countries: Country*) = getCountry 
    .filter(countries.toSet) 
    .flatMap(_ => result) 


def getStudentName(name: Option[String]) = ifCountry(
    name.filterNot(_.isEmpty).map(Student(_)), 
    INDIA, CHINA 
) 

def getEmp(id: Option[String]) = ifCountry(
    id.map(Emp(_)), 
    INDIA, CHINA 
} 
+0

kann jemand erklären 'Ergebnis: => Option [T]' und ': => Symbol in Scala – coder25

+0

ist es die Syntax für' by name' Parameter. Das bedeutet, dass der Parameter nur bei Bedarf und nicht vorher ausgewertet wird. – mdm

+0

Ein Argument, dessen Typ "=> A" ist, ist ein Argument, dessen Typ "A" ist, das aber nach Name und nicht nach Wert übergeben wird. Das heißt, es wird jedes Mal, wenn es im Code auftritt, ausgewertet und nicht genau einmal, wenn die Funktion aufgerufen wird. –