Exercises

1. Write a function parseUpper that accepts a byte and returns the uppercase letter value. Return error.InvalidUppercase if the byte is not between 'A' and 'Z'.

fn parseUpper(c: u8) !u8 {
    // ...
}

2. Write a function safeDivide that divides two integers. Return error.DivisionByZero when the divisor is zero.

fn safeDivide(a: u32, b: u32) !u32 {
    // ...
}

3. Write a function first that returns the first byte of a slice. Return error.EmptySlice if the slice is empty.

fn first(s: []const u8) !u8 {
    // ...
}

4. Write a function last that returns the last byte of a slice.

5. Write a function requirePositive that returns error.NegativeNumber if its argument is less than zero.

6. Rewrite this code using try:

const value = parseNumber(text) catch |err| return err;

7. Rewrite this code using catch:

const value = try parseNumber(text);

8. Write a function parseTwoDigits that parses two ASCII digits into a number between 0 and 99.

try parseTwoDigits('4', '2') // 42

9. Write a function that opens a file and closes it with defer.

10. Allocate memory with an allocator and release it with defer.

11. Allocate memory and return it from a function. Use errdefer so that memory is freed only on failure.

12. Write a function that translates error.FileNotFound into error.MissingConfig.

13. Write a program that reads a filename from the command line and prints a clear error message if opening the file fails.

14. Write a parser that never prints errors directly. Handle all printing in main.

15. Write a function that parses an integer from a byte slice and returns:

16. Write a function that reads a file into memory using:

• readFileAlloc
• defer
• try
• catch

17. Write a function that creates two resources and releases them in reverse order using multiple defer statements.

18. Modify a previous program so that all resource cleanup is handled by defer and all error propagation uses try.

19. Write a small command-line calculator:

calc 10 / 2
5

calc 10 / 0
error: DivisionByZero

20. Write a program that loads a configuration file and applies these rules:

21. Write a function that retries a failing operation three times before returning the final error.

22. Write a small library with public functions that return explicit error sets.

23. Write a wrapper function that converts low-level filesystem errors into application-level errors.

24. Review a previous chapter program and identify:

• where try should be used
• where catch should be used
• where defer belongs
• where errdefer belongs
• where the program boundary should handle errors

25. Write a complete program that:

• reads a file
• parses integers from it
• allocates memory dynamically
• handles malformed input
• frees all resources correctly
• prints useful error messages only at the outer boundary

This chapter introduced four central ideas:

These appear throughout Zig programs. Most library APIs use them directly, and most real programs depend on them for resource management and control flow.