mirror of https://github.com/sbt/sbt.git
Dale Wijnand
GitHub
commit
bc059ad7bb
|
|
@ -1,296 +0,0 @@
|
|||
package sbt.util
|
||||
|
||||
import scala.annotation.tailrec
|
||||
|
||||
// Copied from Cats (MIT license)
|
||||
|
||||
/**
|
||||
* Eval is a monad which controls evaluation.
|
||||
*
|
||||
* This type wraps a value (or a computation that produces a value)
|
||||
* and can produce it on command via the `.value` method.
|
||||
*
|
||||
* There are three basic evaluation strategies:
|
||||
*
|
||||
* - Now: evaluated immediately
|
||||
* - Later: evaluated once when value is needed
|
||||
* - Always: evaluated every time value is needed
|
||||
*
|
||||
* The Later and Always are both lazy strategies while Now is eager.
|
||||
* Later and Always are distinguished from each other only by
|
||||
* memoization: once evaluated Later will save the value to be returned
|
||||
* immediately if it is needed again. Always will run its computation
|
||||
* every time.
|
||||
*
|
||||
* Eval supports stack-safe lazy computation via the .map and .flatMap
|
||||
* methods, which use an internal trampoline to avoid stack overflows.
|
||||
* Computation done within .map and .flatMap is always done lazily,
|
||||
* even when applied to a Now instance.
|
||||
*
|
||||
* It is not generally good style to pattern-match on Eval instances.
|
||||
* Rather, use .map and .flatMap to chain computation, and use .value
|
||||
* to get the result when needed. It is also not good style to create
|
||||
* Eval instances whose computation involves calling .value on another
|
||||
* Eval instance -- this can defeat the trampolining and lead to stack
|
||||
* overflows.
|
||||
*/
|
||||
sealed abstract class Eval[+A] extends Serializable { self =>
|
||||
|
||||
/**
|
||||
* Evaluate the computation and return an A value.
|
||||
*
|
||||
* For lazy instances (Later, Always), any necessary computation
|
||||
* will be performed at this point. For eager instances (Now), a
|
||||
* value will be immediately returned.
|
||||
*/
|
||||
def value: A
|
||||
|
||||
/**
|
||||
* Transform an Eval[A] into an Eval[B] given the transformation
|
||||
* function `f`.
|
||||
*
|
||||
* This call is stack-safe -- many .map calls may be chained without
|
||||
* consumed additional stack during evaluation.
|
||||
*
|
||||
* Computation performed in f is always lazy, even when called on an
|
||||
* eager (Now) instance.
|
||||
*/
|
||||
def map[B](f: A => B): Eval[B] =
|
||||
flatMap(a => Now(f(a)))
|
||||
|
||||
/**
|
||||
* Lazily perform a computation based on an Eval[A], using the
|
||||
* function `f` to produce an Eval[B] given an A.
|
||||
*
|
||||
* This call is stack-safe -- many .flatMap calls may be chained
|
||||
* without consumed additional stack during evaluation. It is also
|
||||
* written to avoid left-association problems, so that repeated
|
||||
* calls to .flatMap will be efficiently applied.
|
||||
*
|
||||
* Computation performed in f is always lazy, even when called on an
|
||||
* eager (Now) instance.
|
||||
*/
|
||||
def flatMap[B](f: A => Eval[B]): Eval[B] =
|
||||
this match {
|
||||
case c: Eval.Compute[A] =>
|
||||
new Eval.Compute[B] {
|
||||
type Start = c.Start
|
||||
// See https://issues.scala-lang.org/browse/SI-9931 for an explanation
|
||||
// of why the type annotations are necessary in these two lines on
|
||||
// Scala 2.12.0.
|
||||
val start: () => Eval[Start] = c.start
|
||||
val run: Start => Eval[B] = (s: c.Start) =>
|
||||
new Eval.Compute[B] {
|
||||
type Start = A
|
||||
val start = () => c.run(s)
|
||||
val run = f
|
||||
}
|
||||
}
|
||||
case c: Eval.Call[A] =>
|
||||
new Eval.Compute[B] {
|
||||
type Start = A
|
||||
val start = c.thunk
|
||||
val run = f
|
||||
}
|
||||
case _ =>
|
||||
new Eval.Compute[B] {
|
||||
type Start = A
|
||||
val start = () => self
|
||||
val run = f
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ensure that the result of the computation (if any) will be
|
||||
* memoized.
|
||||
*
|
||||
* Practically, this means that when called on an Always[A] a
|
||||
* Later[A] with an equivalent computation will be returned.
|
||||
*/
|
||||
def memoize: Eval[A]
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct an eager Eval[A] instance.
|
||||
*
|
||||
* In some sense it is equivalent to using a val.
|
||||
*
|
||||
* This type should be used when an A value is already in hand, or
|
||||
* when the computation to produce an A value is pure and very fast.
|
||||
*/
|
||||
final case class Now[A](value: A) extends Eval[A] {
|
||||
def memoize: Eval[A] = this
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a lazy Eval[A] instance.
|
||||
*
|
||||
* This type should be used for most "lazy" values. In some sense it
|
||||
* is equivalent to using a lazy val.
|
||||
*
|
||||
* When caching is not required or desired (e.g. if the value produced
|
||||
* may be large) prefer Always. When there is no computation
|
||||
* necessary, prefer Now.
|
||||
*
|
||||
* Once Later has been evaluated, the closure (and any values captured
|
||||
* by the closure) will not be retained, and will be available for
|
||||
* garbage collection.
|
||||
*/
|
||||
final class Later[A](f: () => A) extends Eval[A] {
|
||||
private[this] var thunk: () => A = f
|
||||
|
||||
// The idea here is that `f` may have captured very large
|
||||
// structures, but produce a very small result. In this case, once
|
||||
// we've calculated a value, we would prefer to be able to free
|
||||
// everything else.
|
||||
//
|
||||
// (For situations where `f` is small, but the output will be very
|
||||
// expensive to store, consider using `Always`.)
|
||||
lazy val value: A = {
|
||||
val result = thunk()
|
||||
thunk = null // scalastyle:off
|
||||
result
|
||||
}
|
||||
|
||||
def memoize: Eval[A] = this
|
||||
}
|
||||
|
||||
object Later {
|
||||
def apply[A](a: => A): Later[A] = new Later(a _)
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a lazy Eval[A] instance.
|
||||
*
|
||||
* This type can be used for "lazy" values. In some sense it is
|
||||
* equivalent to using a Function0 value.
|
||||
*
|
||||
* This type will evaluate the computation every time the value is
|
||||
* required. It should be avoided except when laziness is required and
|
||||
* caching must be avoided. Generally, prefer Later.
|
||||
*/
|
||||
final class Always[A](f: () => A) extends Eval[A] {
|
||||
def value: A = f()
|
||||
def memoize: Eval[A] = new Later(f)
|
||||
}
|
||||
|
||||
object Always {
|
||||
def apply[A](a: => A): Always[A] = new Always(a _)
|
||||
}
|
||||
|
||||
object Eval {
|
||||
|
||||
/**
|
||||
* Construct an eager Eval[A] value (i.e. Now[A]).
|
||||
*/
|
||||
def now[A](a: A): Eval[A] = Now(a)
|
||||
|
||||
/**
|
||||
* Construct a lazy Eval[A] value with caching (i.e. Later[A]).
|
||||
*/
|
||||
def later[A](a: => A): Eval[A] = new Later(a _)
|
||||
|
||||
/**
|
||||
* Construct a lazy Eval[A] value without caching (i.e. Always[A]).
|
||||
*/
|
||||
def always[A](a: => A): Eval[A] = new Always(a _)
|
||||
|
||||
/**
|
||||
* Defer a computation which produces an Eval[A] value.
|
||||
*
|
||||
* This is useful when you want to delay execution of an expression
|
||||
* which produces an Eval[A] value. Like .flatMap, it is stack-safe.
|
||||
*/
|
||||
def defer[A](a: => Eval[A]): Eval[A] =
|
||||
new Eval.Call[A](a _) {}
|
||||
|
||||
/**
|
||||
* Static Eval instances for some common values.
|
||||
*
|
||||
* These can be useful in cases where the same values may be needed
|
||||
* many times.
|
||||
*/
|
||||
val Unit: Eval[Unit] = Now(())
|
||||
val True: Eval[Boolean] = Now(true)
|
||||
val False: Eval[Boolean] = Now(false)
|
||||
val Zero: Eval[Int] = Now(0)
|
||||
val One: Eval[Int] = Now(1)
|
||||
|
||||
/**
|
||||
* Call is a type of Eval[A] that is used to defer computations
|
||||
* which produce Eval[A].
|
||||
*
|
||||
* Users should not instantiate Call instances themselves. Instead,
|
||||
* they will be automatically created when needed.
|
||||
*/
|
||||
sealed abstract class Call[A](val thunk: () => Eval[A]) extends Eval[A] {
|
||||
def memoize: Eval[A] = new Later(() => value)
|
||||
def value: A = Call.loop(this).value
|
||||
}
|
||||
|
||||
object Call {
|
||||
/** Collapse the call stack for eager evaluations */
|
||||
@tailrec private def loop[A](fa: Eval[A]): Eval[A] = fa match {
|
||||
case call: Eval.Call[A] =>
|
||||
loop(call.thunk())
|
||||
case compute: Eval.Compute[A] =>
|
||||
new Eval.Compute[A] {
|
||||
type Start = compute.Start
|
||||
val start: () => Eval[Start] = () => compute.start()
|
||||
val run: Start => Eval[A] = s => loop1(compute.run(s))
|
||||
}
|
||||
case other => other
|
||||
}
|
||||
|
||||
/**
|
||||
* Alias for loop that can be called in a non-tail position
|
||||
* from an otherwise tailrec-optimized loop.
|
||||
*/
|
||||
private def loop1[A](fa: Eval[A]): Eval[A] = loop(fa)
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute is a type of Eval[A] that is used to chain computations
|
||||
* involving .map and .flatMap. Along with Eval#flatMap it
|
||||
* implements the trampoline that guarantees stack-safety.
|
||||
*
|
||||
* Users should not instantiate Compute instances
|
||||
* themselves. Instead, they will be automatically created when
|
||||
* needed.
|
||||
*
|
||||
* Unlike a traditional trampoline, the internal workings of the
|
||||
* trampoline are not exposed. This allows a slightly more efficient
|
||||
* implementation of the .value method.
|
||||
*/
|
||||
sealed abstract class Compute[A] extends Eval[A] {
|
||||
type Start
|
||||
val start: () => Eval[Start]
|
||||
val run: Start => Eval[A]
|
||||
|
||||
def memoize: Eval[A] = Later(value)
|
||||
|
||||
def value: A = {
|
||||
type L = Eval[Any]
|
||||
type C = Any => Eval[Any]
|
||||
@tailrec def loop(curr: L, fs: List[C]): Any =
|
||||
curr match {
|
||||
case c: Compute[_] =>
|
||||
c.start() match {
|
||||
case cc: Compute[_] =>
|
||||
loop(
|
||||
cc.start().asInstanceOf[L],
|
||||
cc.run.asInstanceOf[C] :: c.run.asInstanceOf[C] :: fs
|
||||
)
|
||||
case xx =>
|
||||
loop(c.run(xx.value), fs)
|
||||
}
|
||||
case x =>
|
||||
fs match {
|
||||
case f :: fs => loop(f(x.value), fs)
|
||||
case Nil => x.value
|
||||
}
|
||||
}
|
||||
loop(this.asInstanceOf[L], Nil).asInstanceOf[A]
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue