2 files changed, 50 insertions, 0 deletions
diff --git a/examples/err.fwd b/examples/err.fwd
new file mode 100644
index 0000000..f2833e2
--- /dev/null
+++ b/examples/err.fwd
@@ -0,0 +1,17 @@
+do_something((auto, auto) ok);
+
+/* consume can fail */
+consume(auto a);
+
+main()
+{
+	do_something() => auto a, auto b;
+	consume(a);
+	/* try commenting out error handler or consume(b); */
+	!> e {
+		consume(b);
+		error "a failed"
+	}
+
+	consume(b);
+}
diff --git a/examples/own.fwd b/examples/own.fwd
new file mode 100644
index 0000000..6634886
--- /dev/null
+++ b/examples/own.fwd
@@ -0,0 +1,33 @@
+do_something((auto) a);
+consume(auto a);
+
+main()
+{
+	do_something() => auto a;
+	do_something() => auto b;
+	!> e {
+		/* if do_something() fails, a is still alive, so we must kill
+		 * it. However, we might enter this error block after the
+		 * callback to do_something() was run, and a might've already
+		 * been moved. own just checks if we still own the resource and
+		 * executes the block.
+		 *
+		 * admittedly, purely syntactically it would look like b is
+		 * already alive at this point, but since it's actually within
+		 * the implicit closure, it is not. Might play around with ordering
+		 * the error block to come before implicit closures...
+		 */
+		own a {consume(a);}
+		error e
+	}
+
+	consume(a);
+	!> e {
+		/* if consume fails, b is still alive, but either this error
+		 * block runs (and throws an error) or the next consume is run,
+		 * so own is not necessary here */
+		consume(b);
+		error e
+	}
+	consume(b);
+}