Improving Swift code for scalability

Using Swift
29

Technique 7: use defer to make manual read-modify-write sequences more readable, no matter how trivial, even in methods that do not throw

Sometimes, when the compiler diagnoses an instance of overlapping mutable accesses, you won't have any solution but to spell a manual read-modify-write pattern, as suggested by the compiler. But it makes for less straightforward code.

In this case, do not hesitate to use defer, no matter if it is library code, no matter how trivial the code, no matter the length of the containing block, no matter whether the latter even throws. Using defer is just more readable: note how in particular here how it allows the final line to just directly return the result of a called method (rather than having to define another temporary variable).

Addendum: but wait, did I not previously eliminate all uses of defer because I had just added them for convenience? The difference is, using defer here is not merely convenient… if you ask yourself the question "Even if I do not throw right now, what would I want to happen if I later allow the code that operates on or around the organ to throw?", the answer is clear: you most definitely want the current state of the organ to be put back in its place so that your object is in a consistent state before giving up control! So using defer here is convenient, but it is not merely convenient.

This technique is best seen in action, as of the current version as of this writing, in the context of this patch:

diff --git a/AsyncCountdown/AsyncCountdown.swift b/AsyncCountdown/AsyncCountdown.swift
--- a/AsyncCountdown/AsyncCountdown.swift
+++ b/AsyncCountdown/AsyncCountdown.swift
@@ -228,6 +228,7 @@
     mutating func popFromWithin(_ context: inout MainTableNonGCD<Contents, Target>, after locator: IndexedReferenceNonGCD<Target, WritableNonGCD>) -> Result<IndexedReferenceNonGCD<Target, WritableNonGCD>, PotentiallySentinelIndexedReferenceNonGCD<Target, WritableNonGCD>.SentinelBlown> {
         var organ = locator[context].next;
         defer { // as if we were pushing on the undo stack as part of the "do"
+
             locator.open(&context, { $0.next = organ; });
         }
         return organ.popWithoutAccounting(&context).map({