blob: 00f617fd11796dcff3f2f074b300cf0d80da7817 (
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
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
## Building
The async macro and its test suite can be built and run with SBT.
## Contributing
If you are interested in contributing code, we ask you to complete and submit
to us the Scala Contributor License Agreement, which allows us to ensure that
all code submitted to the project is unencumbered by copyrights or patents.
The form is available at:
http://www.scala-lang.org/sites/default/files/contributor_agreement.pdf
Before submitting a pull-request, please make sure you have followed the guidelines
outlined in our [Pull Request Policy](https://github.com/scala/scala/wiki/Pull-Request-Policy).
## Troubleshooting
- Logging of the transform can be enabled with `scalac -Dscala.async.debug=true`.
- Tracing of the ANF transform: `scalac -Dscala.async.trace=true`
- Debug the macro expansion by checking out the project and executing the application
[`scala.async.TreeInterrogation`](https://github.com/scala/async/blob/master/src/test/scala/scala/async/TreeInterrogation.scala#L59)
## Generated Code examples
```scala
val future = async {
val f1 = async { true }
val x = 1
def inc(t: Int) = t + x
val t = 0
val f2 = async { 42 }
if (await(f1)) await(f2) else { val z = 1; inc(t + z) }
}
```
After ANF transform.
- await calls are moved to only appear on the RHS of a value definition.
- `if` is not used as an expression, instead each branch writes its result
to a synthetic `var`.
```scala
{
();
val f1: scala.concurrent.Future[Boolean] = {
scala.concurrent.Future.apply[Boolean](true)(scala.concurrent.ExecutionContext.Implicits.global)
};
val x: Int = 1;
def inc(t: Int): Int = t.+(x);
val t: Int = 0;
val f2: scala.concurrent.Future[Int] = {
scala.concurrent.Future.apply[Int](42)(scala.concurrent.ExecutionContext.Implicits.global)
};
val await$1: Boolean = scala.async.Async.await[Boolean](f1);
var ifres$1: Int = 0;
if (await$1)
{
val await$2: Int = scala.async.Async.await[Int](f2);
ifres$1 = await$2
}
else
{
ifres$1 = {
val z: Int = 1;
inc(t.+(z))
}
};
ifres$1
}
```
After async transform:
- one class synthesized to act as the state machine. It's `apply()` method will
be used to start the computation (even the code before the first await call
is executed asynchronously), and the `apply(tr: scala.util.Try[Any])` method
will continue after each completed background task.
- each chunk of code moved into the a branch of the pattern match in `resume$async`.
- value and method definitions accessed from multiple states are lifted to be
members of `class stateMachine`. Others remain local, e.g. `val z`.
```scala
{
class stateMachine$7 extends ... {
def <init>() = {
super.<init>();
()
};
var state$async: Int = 0;
val result$async: scala.concurrent.Promise[Int] = scala.concurrent.Promise.apply[Int]();
val execContext$async = scala.concurrent.ExecutionContext.Implicits.global;
var x$1: Int = 0;
def inc$1(t: Int): Int = t.$plus(x$1);
var t$1: Int = 0;
var f2$1: scala.concurrent.Future[Int] = null;
var await$1: Boolean = false;
var ifres$1: Int = 0;
var await$2: Int = 0;
def resume$async(): Unit = try {
state$async match {
case 0 => {
();
val f1 = {
scala.concurrent.Future.apply[Boolean](true)(scala.concurrent.ExecutionContext.Implicits.global)
};
x$1 = 1;
t$1 = 0;
f2$1 = {
scala.concurrent.Future.apply[Int](42)(scala.concurrent.ExecutionContext.Implicits.global)
};
f1.onComplete(this)(execContext$async)
}
case 1 => {
ifres$1 = 0;
if (await$1)
{
state$async = 2;
resume$async()
}
else
{
state$async = 3;
resume$async()
}
}
case 2 => {
f2$1.onComplete(this)(execContext$async);
()
}
case 5 => {
ifres$1 = await$2;
state$async = 4;
resume$async()
}
case 3 => {
ifres$1 = {
val z = 1;
inc$1(t$1.$plus(z))
};
state$async = 4;
resume$async()
}
case 4 => {
result$async.complete(scala.util.Success.apply(ifres$1));
()
}
}
} catch {
case NonFatal((tr @ _)) => {
{
result$async.complete(scala.util.Failure.apply(tr));
()
};
()
}
};
def apply(tr: scala.util.Try[Any]): Unit = state$async match {
case 0 => {
if (tr.isFailure)
{
result$async.complete(tr.asInstanceOf[scala.util.Try[Int]]);
()
}
else
{
await$1 = tr.get.asInstanceOf[Boolean];
state$async = 1;
resume$async()
};
()
}
case 2 => {
if (tr.isFailure)
{
result$async.complete(tr.asInstanceOf[scala.util.Try[Int]]);
()
}
else
{
await$2 = tr.get.asInstanceOf[Int];
state$async = 5;
resume$async()
};
()
}
};
def apply: Unit = resume$async()
};
val stateMachine$7: StateMachine[scala.concurrent.Promise[Int], scala.concurrent.ExecutionContext] = new stateMachine$7();
scala.concurrent.Future.apply(stateMachine$7.apply())(scala.concurrent.ExecutionContext.Implicits.global);
stateMachine$7.result$async.future
}
```
|
