Index: doc/theses/andrew_beach_MMath/features.tex =================================================================== --- doc/theses/andrew_beach_MMath/features.tex (revision 6aa84e084b48dcf666a33d982e713b31e37674ce) +++ doc/theses/andrew_beach_MMath/features.tex (revision 814f87d13c0b297d181252f3cdad7a0f2bccc966) @@ -908,5 +908,5 @@ After a coroutine stack is unwound, control returns to the @resume@ function that most recently resumed it. @resume@ reports a -@CoroutineCancelled@ exception, which contains a references to the cancelled +@CoroutineCancelled@ exception, which contains a reference to the cancelled coroutine and the exception used to cancel it. The @resume@ function also takes the \defaultResumptionHandler{} from the Index: doc/theses/andrew_beach_MMath/implement.tex =================================================================== --- doc/theses/andrew_beach_MMath/implement.tex (revision 6aa84e084b48dcf666a33d982e713b31e37674ce) +++ doc/theses/andrew_beach_MMath/implement.tex (revision 814f87d13c0b297d181252f3cdad7a0f2bccc966) @@ -414,8 +414,9 @@ of a function's state with @setjmp@ and restoring that snapshot with @longjmp@. This approach bypasses the need to know stack details by simply -reseting to a snapshot of an arbitrary but existing function frame on the +resetting to a snapshot of an arbitrary but existing function frame on the stack. It is up to the programmer to ensure the snapshot is valid when it is reset and that all required cleanup from the unwound stacks is performed. -This approach is fragile and requires extra work in the surrounding code. +Because it does not automate or check any of this cleanup, +it can be easy to make mistakes and always must be handled manually. With respect to the extra work in the surrounding code, @@ -435,6 +436,7 @@ library that provides tools for stack walking, handler execution, and unwinding. What follows is an overview of all the relevant features of -libunwind needed for this work, and how \CFA uses them to implement exception -handling. +libunwind needed for this work. +Following that is the description of the \CFA code that uses libunwind +to implement termination. \subsection{libunwind Usage} Index: doc/theses/andrew_beach_MMath/intro.tex =================================================================== --- doc/theses/andrew_beach_MMath/intro.tex (revision 6aa84e084b48dcf666a33d982e713b31e37674ce) +++ doc/theses/andrew_beach_MMath/intro.tex (revision 814f87d13c0b297d181252f3cdad7a0f2bccc966) @@ -220,5 +220,5 @@ unwinding the stack like in termination exception handling.\cite{RustPanicMacro}\cite{RustPanicModule} -Go's panic through is very similar to a termination, except it only supports +Go's panic though is very similar to a termination, except it only supports a catch-all by calling \code{Go}{recover()}, simplifying the interface at the cost of flexibility.\cite{Go:2021} @@ -265,6 +265,8 @@ This pattern is very popular in any functional or semi-functional language with primitive support for tagged unions (or algebraic data types). -% We need listing Rust/rust to format code snippets from it. -% Rust's \code{rust}{Result} +Return unions can also be expressed as monads (evaluation in a context) +and often are in languages with special syntax for monadic evaluation, +such as Haskell's \code{haskell}{do} blocks. + The main advantage is that an arbitrary object can be used to represent an error, so it can include a lot more information than a simple error code. @@ -272,4 +274,11 @@ execution, and if there aren't primitive tagged unions proper, usage can be hard to enforce. +% We need listing Rust/rust to format code snippets from it. +% Rust's \code{rust}{Result} + +Return unions as monads will result in the same code, but can hide most +of the work to propagate errors in simple cases. The code to actually handle +the errors, or to interact with other monads (a common case in these +languages) still has to be written by hand. \item\emph{Handler Functions}: Index: doc/theses/andrew_beach_MMath/performance.tex =================================================================== --- doc/theses/andrew_beach_MMath/performance.tex (revision 6aa84e084b48dcf666a33d982e713b31e37674ce) +++ doc/theses/andrew_beach_MMath/performance.tex (revision 814f87d13c0b297d181252f3cdad7a0f2bccc966) @@ -37,4 +37,9 @@ resumption exceptions. Even the older programming languages with resumption seem to be notable only for having resumption. +On the other hand, the functional equivalents to resumption are too new. +There does not seem to be any standard implementations in well-known +languages, so far they seem confined to extensions and research languages. +% There was some maybe interesting comparison to an OCaml extension +% but I'm not sure how to get that working if it is interesting. Instead, resumption is compared to its simulation in other programming languages: fixup functions that are explicitly passed into a function. Index: doc/theses/andrew_beach_MMath/uw-ethesis.bib =================================================================== --- doc/theses/andrew_beach_MMath/uw-ethesis.bib (revision 6aa84e084b48dcf666a33d982e713b31e37674ce) +++ doc/theses/andrew_beach_MMath/uw-ethesis.bib (revision 814f87d13c0b297d181252f3cdad7a0f2bccc966) @@ -50,5 +50,5 @@ author={The Rust Team}, key={Rust Panic Macro}, - howpublished={\href{https://doc.rust-lang.org/std/panic/index.html}{https://\-doc.rust-lang.org/\-std/\-panic/\-index.html}}, + howpublished={\href{https://doc.rust-lang.org/std/macro.panic.html}{https://\-doc.rust-lang.org/\-std/\-macro.panic.html}}, addendum={Accessed 2021-08-31}, }