blob: 43340886b4098bad9107f974a0db7fe574895bb1 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
/*
* Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
*/
package scala.async.internal
import language.experimental.macros
import scala.reflect.macros.Context
import scala.reflect.internal.SymbolTable
object AsyncId extends AsyncBase {
lazy val futureSystem = IdentityFutureSystem
type FS = IdentityFutureSystem.type
def async[T](body: T) = macro asyncIdImpl[T]
def asyncIdImpl[T: c.WeakTypeTag](c: Context)(body: c.Expr[T]): c.Expr[T] = asyncImpl[T](c)(body)(c.literalUnit)
}
/**
* A trivial implementation of [[FutureSystem]] that performs computations
* on the current thread. Useful for testing.
*/
object IdentityFutureSystem extends FutureSystem {
class Prom[A] {
var a: A = _
}
type Fut[A] = A
type ExecContext = Unit
def mkOps(c: SymbolTable): Ops {val universe: c.type} = new Ops {
val universe: c.type = c
import universe._
def execContext: Expr[ExecContext] = Expr[Unit](Literal(Constant(())))
def promType[A: WeakTypeTag]: Type = weakTypeOf[Prom[A]]
def execContextType: Type = weakTypeOf[Unit]
def createProm[A: WeakTypeTag]: Expr[Prom[A]] = reify {
new Prom()
}
def promiseToFuture[A: WeakTypeTag](prom: Expr[Prom[A]]) = reify {
prom.splice.a
}
def future[A: WeakTypeTag](t: Expr[A])(execContext: Expr[ExecContext]) = t
def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[scala.util.Try[A] => U],
execContext: Expr[ExecContext]): Expr[Unit] = reify {
fun.splice.apply(util.Success(future.splice))
Expr[Unit](Literal(Constant(()))).splice
}
def completeProm[A](prom: Expr[Prom[A]], value: Expr[scala.util.Try[A]]): Expr[Unit] = reify {
prom.splice.a = value.splice.get
Expr[Unit](Literal(Constant(()))).splice
}
def castTo[A: WeakTypeTag](future: Expr[Fut[Any]]): Expr[Fut[A]] = ???
}
}
|
