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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
*/
package scala.async.internal
import scala.language.higherKinds
import scala.reflect.macros.Context
/**
* An abstraction over a future system.
*
* Used by the macro implementations in [[scala.async.AsyncBase]] to
* customize the code generation.
*
* The API mirrors that of `scala.concurrent.Future`, see the instance
* [[ScalaConcurrentFutureSystem]] for an example of how
* to implement this.
*/
trait FutureSystem {
/** A container to receive the final value of the computation */
type Prom[A]
/** A (potentially in-progress) computation */
type Fut[A]
/** An execution context, required to create or register an on completion callback on a Future. */
type ExecContext
/** Any data type isomorphic to scala.util.Try. */
type Tryy[T]
trait Ops {
val c: Context
import c.universe._
def promType[A: WeakTypeTag]: Type
def tryType[A: WeakTypeTag]: Type
def execContextType: Type
def stateMachineClassParents: List[Type] = Nil
/** Create an empty promise */
def createProm[A: WeakTypeTag]: Expr[Prom[A]]
/** Extract a future from the given promise. */
def promiseToFuture[A: WeakTypeTag](prom: Expr[Prom[A]]): Expr[Fut[A]]
/** Construct a future to asynchronously compute the given expression */
def future[A: WeakTypeTag](a: Expr[A])(execContext: Expr[ExecContext]): Expr[Fut[A]]
/** Register an call back to run on completion of the given future */
def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[Tryy[A] => U],
execContext: Expr[ExecContext]): Expr[Unit]
def continueCompletedFutureOnSameThread = false
/** Return `null` if this future is not yet completed, or `Tryy[A]` with the completed result
* otherwise
*/
def getCompleted[A: WeakTypeTag](future: Expr[Fut[A]]): Expr[Tryy[A]] =
throw new UnsupportedOperationException("getCompleted not supported by this FutureSystem")
/** Complete a promise with a value */
def completeProm[A](prom: Expr[Prom[A]], value: Expr[Tryy[A]]): Expr[Unit]
def completeWithSuccess[A: WeakTypeTag](prom: Expr[Prom[A]], value: Expr[A]): Expr[Unit] = completeProm(prom, tryySuccess(value))
def spawn(tree: Tree, execContext: Tree): Tree =
future(c.Expr[Unit](tree))(c.Expr[ExecContext](execContext)).tree
def tryyIsFailure[A](tryy: Expr[Tryy[A]]): Expr[Boolean]
def tryyGet[A](tryy: Expr[Tryy[A]]): Expr[A]
def tryySuccess[A: WeakTypeTag](a: Expr[A]): Expr[Tryy[A]]
def tryyFailure[A: WeakTypeTag](a: Expr[Throwable]): Expr[Tryy[A]]
/** A hook for custom macros to transform the tree post-ANF transform */
def postAnfTransform(tree: Block): Block = tree
}
def mkOps(c0: Context): Ops { val c: c0.type }
def freshenAllNames: Boolean = false
def emitTryCatch: Boolean = true
def resultFieldName: String = "result"
}
object ScalaConcurrentFutureSystem extends FutureSystem {
import scala.concurrent._
type Prom[A] = Promise[A]
type Fut[A] = Future[A]
type ExecContext = ExecutionContext
type Tryy[A] = scala.util.Try[A]
def mkOps(c0: Context): Ops {val c: c0.type} = new Ops {
val c: c0.type = c0
import c.universe._
def promType[A: WeakTypeTag]: Type = weakTypeOf[Promise[A]]
def tryType[A: WeakTypeTag]: Type = weakTypeOf[scala.util.Try[A]]
def execContextType: Type = weakTypeOf[ExecutionContext]
def createProm[A: WeakTypeTag]: Expr[Prom[A]] = reify {
Promise[A]()
}
def promiseToFuture[A: WeakTypeTag](prom: Expr[Prom[A]]) = reify {
prom.splice.future
}
def future[A: WeakTypeTag](a: Expr[A])(execContext: Expr[ExecContext]) = reify {
Future(a.splice)(execContext.splice)
}
def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[scala.util.Try[A] => U],
execContext: Expr[ExecContext]): Expr[Unit] = reify {
future.splice.onComplete(fun.splice)(execContext.splice)
}
override def continueCompletedFutureOnSameThread: Boolean = true
override def getCompleted[A: WeakTypeTag](future: Expr[Fut[A]]): Expr[Tryy[A]] = reify {
if (future.splice.isCompleted) future.splice.value.get else null
}
def completeProm[A](prom: Expr[Prom[A]], value: Expr[scala.util.Try[A]]): Expr[Unit] = reify {
prom.splice.complete(value.splice)
c.Expr[Unit](Literal(Constant(()))).splice
}
def tryyIsFailure[A](tryy: Expr[scala.util.Try[A]]): Expr[Boolean] = reify {
tryy.splice.isFailure
}
def tryyGet[A](tryy: Expr[Tryy[A]]): Expr[A] = reify {
tryy.splice.get
}
def tryySuccess[A: WeakTypeTag](a: Expr[A]): Expr[Tryy[A]] = reify {
scala.util.Success[A](a.splice)
}
def tryyFailure[A: WeakTypeTag](a: Expr[Throwable]): Expr[Tryy[A]] = reify {
scala.util.Failure[A](a.splice)
}
}
}
|
