const v: error{A}!i32 = error.A;

if (v) |_| {} else |_| {} // explicitly ignoring the values captured
if (v) {} else {} // the captures are completely omitted, yet this still works

test "capturing and ignoring on an optional value" {
    // This one seems to work pretty much as this proposal suggests.

    const val: ?i32 = null;

    // :: Explicitly ignoring the capture
    // Compiles successfully (as wanted)
    if (val) |_| {} else {}

    // :: Ommiting the capture
    // Does not compile, although the error is somewhat cryptic. I might be interpreting it wrong...
    if (val) {} else {}
}

test "capturing and ignoring on an error union" {
    const val: error{A}!i32 = error.A;

    // :: Explicitly ignoring both captures
    if (val) |_| {} else |_| {}

    // :: Explicitly ignoring only the error capture
    // This works fine - with this proposal, it shouldn't.
    if (val) {} else |_| {}

    // :: Explicitly ignoring only the success capture
    // Hmm... this one errors out, but because the compiler thought we were trying to capture an optional value.
    if (val) |_| {} else {}
}

test "forgetting to capture on a for loop" {
    const arr: [5]u8 = [_]u8{ 1, 2, 3, 4, 5 };

    // This one hopefully does not compile already, although it complains about `{` being an invalid token. Maybe a
    // clearer error (a note maybe?) could be shown here ("missing capture").
    for (arr) {}
}

test "capturing and ignoring on a while loop" {
    // Just a sample struct to iterate from 0 to 4.
    const To4Iterator = struct {
        i: u8 = 0,

        fn next(self: *@This()) ?u8 {
            if (self.i < 5) {
                self.i  = 1;
                return self.i - 1;
            } else {
                return null;
            }
        }
    };

    var it = To4Iterator{};

    // Works as expected
    while (it.next()) |_| {}

    // Hopefully this doesn't work, but, as the other errors, the one from here is kind of unclear and might not be for this reason.
    while (it.next()) {}
}