"유동성"또는 "빌더"인터페이스를 다루는 방법

Question

컴파일 타임에 구성을 알았을 때 유용하지만 런타임 조건에 따라 객체를 작성해야 할 때 이상하게 보입니다.

val req = Request() 

val secureReq = if (needSecurity) req.withSecurity else req 
val throttledReq = if (needThrottling) secureReq.withThrottling else secureReq 
val pooledReq = if (needPooling) throttledReq.withPooling else throttledReq 

// etc etc ad infinitum 

이런 종류의 코드를 스칼라에 작성하는 것이 더 좋을까요?

Answer 1

스칼라가 구조에 함축합니다.

object PimpedBuilders { 
     implicit class Pimped[T](val builder: T) extends AnyVal { 
      def unless(what: Boolean)(then: T => T): T = 
      if(what) builder else then(builder) 
     } 
    } 

    import PimpedBuilders._ 
    req 
    .unless(!needSecurity){ _.withSecurity} 
    .unless(!needThrottling} { _.withThrottling } 
    .unless(!needPooling) { _.wothPooling } 

등

Answer 2

이 해결책은 다소 복잡하지만, 자신을 반복하지 않도록한다.

REPL에서 코드를 확인할 수는 없지만 아이디어를 제공해야합니다.

/************************************************ 
* This part is used once 
************************************************/ 
//We define a request-transforming type 
type Configuration = Request => Request 

/* now we prepare configuration selectively based on a flag 
* the function is curried to store different configurations 
* once, leaving the flag to be defined only as we actually 
* prepare the request. 
* Note that a false flag will give back the identity function 
* from Predef that leaves the argument untouched 
*/ 
def configuring(conf: Configuration)(flag: boolean) = 
    if (flag) conf else identity 

//The available configuration types, wrapping the "fluent" calls 
val secured_?: Boolean => Configuration = configuring(_.withSecurity) 
val throttled_? = configuring(_.withThrottling) 
val pooled_? = configuring(_.withPooling) 

/************************************************ 
* This part is used each time we need 
* to configure a request 
************************************************/ 
val req = Request() 

/* prepare a sequence of configurations 
* and compose them sequentially 
*/ 
def configurations: Configuration = Seq(
    secured_?(needSecurity), 
    throttled_?(needThrottling), 
    pooled_?(needPooling) 
).reduce(_.compose(_)) 

/* apply the combined configuring 
* function to the new request 
*/ 
val configured = configurations(req)