Условного метода построения цепочки на основе варианта

Question

Недавно я обнаружил, что пишут либо запросы к БД или простой Seq метода цепи, которые я хотел бы быть динамическими на основе пользовательского ввода, например:

def between(from: Option[DateTime], to: Option[DateTime]): Seq[MyObject] = { 
    db.all() // let's say this returns Seq[MyObject] 
    /* Here I want to either restrict the upper/lower bounds with from/to if 
     they exist or take all the values otherwise */ 
} 

Если бы я был ленив я d просто пойти с:

def between(from: Option[DateTime], to: Option[DateTime]): Seq[MyObject] = { 
    if(from.isEmpty && to.isEmpty) db.all() 
    else if(from.isEmpty) db.all().filter(_.date <= to.get) 
    else if(to.isEmpty) db.all().filter(_.date >= from.get) 
    else db.all().filter(_.date >= from.get && _.date <= to.get) 
} 

Очевидно filter это просто пример, у меня та же проблема с, например take, когда я хочу взять n элементы или все они основаны на Option.

Но что делать, если у меня есть больше параметров? Каким будет идиоматический способ сделать это в Scala?

Я могу пойти с шаблоном, но это не сильно отличается от if/else?

я мог бы сделать несколько vals и сделать from.map(...).getOrElse() но вводит временный vals и снова не выглядит намного лучше, чем if/else.

Есть ли другие трюки, которые я мог бы использовать?

Answer 1

Я не думаю, что это хороший дизайн для начала, потому что он нарушает сам смысл слова between.

я бы просто иметь отдельные методы для каждого случая, с четкой семантикой:

def between(from: DateTime, DateTime) 
def after(from: DateTime) 
def before(to: DateTime) 
def anytime() 

В противном случае, если вы действительно хотите, чтобы сохранить его таким образом:

def between(from: Option[Date], to: Option[Date]) = { 
val datePredicate = (test: (Date,Date) => Boolean, date: Option[Date]) => (o: MyObject) => date.map(test(o.date, _)).getOrElse(true) 
val fromPredicate = datePredicate(_ >= _, from) 
val toPredicate = datePredicate(_ <= _, to) 
db.all().filter(x => fromPredicate(x) && toPredicate(x)) 
} 

Это более общий и расширяемый , но очень неясный.