Использование ленивых функций оценки в varargs - PullRequest
Новая
       17

Использование ленивых функций оценки в varargs

7 голосов
/ 12 апреля 2010

Что плохого в следующем методе? 

def someMethod(funcs: => Option[String]*) = {
 ...
}

Ответы [ 2 ]

5 голосов
/ 12 апреля 2010

Это на самом деле «работает» в 2.7.7, если вы добавляете парены: 

scala> def someMethod(funcs: => (Option[String]*)) = funcs
someMethod: (=> Option[String]*)Option[String]*

за исключением того, что он на самом деле не работает во время выполнения: 

scala> someMethod(Some("Fish"),None)
    scala.MatchError: Some(Fish)
at scala.runtime.ScalaRunTime$.boxArray(ScalaRunTime.scala:136)
at .someMethod(<console>:4)
at .<init>(<console>:6)
at .<clinit>(<console>) ...

В 2.8 он не позволяет вам указать X * в качестве вывода любой функции или параметра по имени, даже если вы можете указать его в качестве ввода (это r21230, пост-бета 1): 

scala> var f: (Option[Int]*) => Int = _
f: (Option[Int]*) => Int = null

scala> var f: (Option[Int]*) => (Option[Int]*) = _
<console>:1: error: no * parameter type allowed here
       var f: (Option[Int]*) => (Option[Int]*) = _

Но если вы попытаетесь преобразовать метод, он сработает: 

scala> def m(oi: Option[Int]*) = oi
m: (oi: Option[Int]*)Option[Int]*

scala> var f = (m _)
f: (Option[Int]*) => Option[Int]* = <function1>

scala> f(Some(1),None)
res0: Option[Int]* = WrappedArray(Some(1), None)

Так что это не совсем соответствует.

В любом случае вы можете достичь желаемого, передав массив, а затем отправив этот массив во что-то, что принимает повторяющиеся аргументы: 

scala> def aMethod(os: Option[String]*) { os.foreach(println) }
aMethod: (os: Option[String]*)Unit

scala> def someMethod(funcs: => Array[Option[String]]) { aMethod(funcs:_*) }
someMethod: (funcs: => Array[Option[String]])Unit

scala> someMethod(Array(Some("Hello"),Some("there"),None))
Some(Hello)
Some(there)
None

Если вы действительно хотите (легко) передать кучу лениво оцененных аргументов, вам понадобится немного инфраструктуры, которая, насколько я знаю, не очень хорошо существует в библиотеке (это код для 2.8; посмотреть его как вдохновение для подобной стратегии в 2.7): 

class Lazy[+T](t: () => T, lt: Lazy[T]) {
  val params: List[() => T] = (if (lt eq null) Nil else t :: lt.params)
  def ~[S >: T](s: => S) = new Lazy[S](s _,this)
}
object Lz extends Lazy[Nothing](null,null) {
  implicit def lazy2params[T : Manifest](lz: Lazy[T]) = lz.params.reverse.toArray
}

Теперь вы можете легко создать набор параметров, которые лениво оцениваются: 

scala> import Lz._  // To get implicit def
import Lz._

scala> def lazyAdder(ff: Array[()=>Int]) = {
     |   println("I'm adding now!");
     |   (0 /: ff){(n,f) => n+f()}
     | }
lazyAdder: (ff: Array[() => Int])Int

scala> def yelp = { println("You evaluated me!"); 5 }
yelp: Int

scala> val a = 3
a: Int = 3

scala> var b = 7
b: Int = 7

scala> lazyAdder( Lz ~ yelp ~ (a+b) )
I'm adding now!
You evaluated me!
res0: Int = 15

scala> val plist = Lz ~ yelp ~ (a+b)
plist: Lazy[Int] = Lazy@1ee1775

scala> b = 1
b: Int = 1

scala> lazyAdder(plist)
I'm adding now!
You evaluated me!
res1: Int = 9
3 голосов
/ 12 апреля 2010

Явно повторяющиеся аргументы недоступны для параметров по имени.

...