From daf0a99f94e8d9ebc1efa3fcda841078a2b2bec3 Mon Sep 17 00:00:00 2001
From: DerTee <grrrrrrrahhh@yahoo.com>
Date: Thu, 21 Apr 2022 07:09:21 +0200
Subject: 064_builtins: clarify @addWithOverflow explanation

There were misunderstandings concerning
overflowing operations and overflowed variables.
Hopefully it's clearer now.
---
 exercises/064_builtins.zig | 40 ++++++++++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 12 deletions(-)

(limited to 'exercises')

diff --git a/exercises/064_builtins.zig b/exercises/064_builtins.zig
index 508f8ed..018bf95 100644
--- a/exercises/064_builtins.zig
+++ b/exercises/064_builtins.zig
@@ -41,22 +41,38 @@ pub fn main() void {
     var my_result: u4 = undefined;
     var overflowed: bool = undefined;
     overflowed = @addWithOverflow(u4, a, b, &my_result);
-    //
+
+    // Check out our fancy formatting! b:0>4 means, "print
+    // as a binary number, zero-pad right-aligned four digits."
     // The print() below will produce: "1101 + 0101 = 0010 (true)".
-    // Let's make sense of this answer by counting up from 1101:
+    print("{b:0>4} + {b:0>4} = {b:0>4} ({})", .{ a, b, my_result, overflowed });
+
+    // Let's make sense of this answer. The value of 'b' in decimal is 5.
+    // Let's add 5 to 'a' but go one by one and see where it overflows:
     //
-    //                     Overflowed?
-    //    1101 + 1 = 1110      No.
-    //    1110 + 1 = 1111      No.
-    //    1111 + 1 = 0000      Yes! (Real answer is 10000)
-    //    0000 + 1 = 0001      No.
-    //    0001 + 1 = 0010      No.
+    //   a  |  b   | result | overflowed?
+    // ----------------------------------
+    // 1101 + 0001 =  1110  | false
+    // 1110 + 0001 =  1111  | false
+    // 1111 + 0001 =  0000  | true  (the real answer is 10000)
+    // 0000 + 0001 =  0001  | false
+    // 0001 + 0001 =  0010  | false
     //
-    // Also, check out our fancy formatting! b:0>4 means, "print
-    // as a binary number, zero-pad right-aligned four digits."
-    print("{b:0>4} + {b:0>4} = {b:0>4} ({})", .{ a, b, my_result, overflowed });
+    // In the last two lines the value of 'a' is corrupted because there was
+    // an overflow in line 3, but the operations of lines 4 and 5 themselves
+    // do not overflow.
+    // There is a difference between
+    //  - a value, that overflowed at some point and is now corrupted
+    //  - a single operation that overflows and maybe causes subsequent errors
+    // In practise we usually notice the overflowed value first and have to work
+    // our way backwards to the operation that caused the overflow.
+    //
+    // If there was no overflow at all while adding 5 to a, what value would
+    // 'my_result' hold? Write the answer in into 'expected_result'.
+    const expected_result: u8 = ???;
+    print(". Without overflow: {b:0>8}. ", .{expected_result});
 
-    print(". Furthermore, ", .{});
+    print("Furthermore, ", .{});
 
     // Here's a fun one:
     //
-- 
cgit v1.2.3-70-g09d2