aboutsummaryrefslogtreecommitdiff
path: root/exercises
diff options
context:
space:
mode:
authorDave Gauer <dave@ratfactor.com>2021-05-12 20:35:29 -0400
committerDave Gauer <dave@ratfactor.com>2021-05-12 20:35:29 -0400
commite555fdc3dfbc7f0f7654ab5d530a0a1d8f0d628e (patch)
tree74b7743a72798e3b56154003a12d3dda67a09a27 /exercises
parent86e071f25607817a6a507956b1f759e5d13be5df (diff)
downloadziglings-e555fdc3dfbc7f0f7654ab5d530a0a1d8f0d628e.tar.gz
ziglings-e555fdc3dfbc7f0f7654ab5d530a0a1d8f0d628e.tar.bz2
ziglings-e555fdc3dfbc7f0f7654ab5d530a0a1d8f0d628e.tar.xz
ziglings-e555fdc3dfbc7f0f7654ab5d530a0a1d8f0d628e.zip
add ex084 async
Diffstat (limited to 'exercises')
-rw-r--r--exercises/084_async.zig56
1 files changed, 56 insertions, 0 deletions
diff --git a/exercises/084_async.zig b/exercises/084_async.zig
new file mode 100644
index 0000000..fe68b03
--- /dev/null
+++ b/exercises/084_async.zig
@@ -0,0 +1,56 @@
+//
+// Six Facts:
+//
+// 1. The memory space allocated to your program for the
+// invocation of a function and all of its data is called a
+// "stack frame".
+//
+// 2. The 'return' keyword "pops" the current function
+// invocation's frame off of the stack (it is no longer needed)
+// and returns control to the place where the function was
+// called.
+//
+// fn foo() void {
+// return; // Pop the frame and return control
+// }
+//
+// 3. Like 'return', the 'suspend' keyword returns control to the
+// place where the function was called BUT the function
+// invocation's frame remains so that it can regain control again
+// at a later time. Functions which do this are "async"
+// functions.
+//
+// fn fooThatSuspends() void {
+// suspend; // return control, but leave the frame alone
+// }
+//
+// 4. To call any function in async context and get a reference
+// to its frame for later use, use the 'async' keyword:
+//
+// var foo_frame = async fooThatSuspends();
+//
+// 5. If you call an async function without the 'async' keyword,
+// the function FROM WHICH you called the async function itself
+// becomes async! In this example, the bar() function is now
+// async because it calls fooThatSuspends(), which is async.
+//
+// fn bar() void {
+// fooThatSuspends();
+// }
+//
+// 6. The main() function cannot be async!
+//
+// Given facts 3 and 4, how do we fix this program (broken by facts
+// 5 and 6)?
+//
+const print = @import("std").debug.print;
+
+pub fn main() void {
+ foo();
+}
+
+fn foo() void {
+ print("foo() A\n", .{});
+ suspend;
+ print("foo() B\n", .{});
+}