102 lines
3.1 KiB
Mojo
102 lines
3.1 KiB
Mojo
# These are equivalent
|
|
raise Error("file not found")
|
|
raise "file not found"
|
|
```
|
|
|
|
The string literal form is a convenience—the compiler automatically wraps it in
|
|
an `Error`.
|
|
|
|
By declaring `raises`, you tell Mojo that a function may raise an error:
|
|
|
|
```mojo
|
|
def read_file_fn(path: String) raises -> String:
|
|
if not path:
|
|
raise "path cannot be empty"
|
|
return "contents of " + path
|
|
```
|
|
|
|
:::tip
|
|
|
|
If you need structured error data—like separate fields for an error code and
|
|
description—or allocation-free errors for GPU kernels, see
|
|
[Typed errors](#typed-errors) later on this page. For most application code,
|
|
`Error` with a descriptive string message is all you need.
|
|
|
|
:::
|
|
|
|
## Handle an error
|
|
|
|
Mojo uses `try`/`except` to detect and handle errors. The full syntax is:
|
|
|
|
```mojo
|
|
try:
|
|
# Code that might raise an error
|
|
except e:
|
|
# Runs if an error occurs
|
|
else:
|
|
# Runs if no error occurs
|
|
finally:
|
|
# Always runs, regardless of outcome
|
|
```
|
|
|
|
You must include one or both of `except` and `finally`. The `else` clause is
|
|
optional.
|
|
|
|
### How each clause works
|
|
|
|
- `try` — Contains code that might raise an error. If no error occurs, the
|
|
entire block executes. If an error occurs, execution stops at the `raise`
|
|
point and continues with the `except` clause (if present) or the `finally`
|
|
clause.
|
|
|
|
- `except` — Runs only when an error occurs in the `try` block. If you
|
|
provide a variable name (`except e:`), the error is bound to that variable.
|
|
A `try` block can have only one `except` clause.
|
|
|
|
- `else` — Runs only when no error occurs in the `try` block. The `else`
|
|
clause is *skipped* if the `try` clause exits via `continue`, `break`, or
|
|
`return`.
|
|
|
|
- `finally` — Runs after the `try` and any `except` or `else` clause,
|
|
regardless of outcome. It executes even if another clause exits via
|
|
`continue`, `break`, `return`, or by raising a new error. Use `finally` to
|
|
release resources (such as file handles) that must be cleaned up regardless
|
|
of whether an error occurred.
|
|
|
|
### Example
|
|
|
|
The following example demonstrates all four clauses. The `process_record()`
|
|
function raises `Error` for different conditions, and the caller loops over
|
|
a list of IDs to exercise each clause:
|
|
|
|
```mojo title="handle_error.mojo"
|
|
def process_record(id: Int) raises -> String:
|
|
if id < 0:
|
|
raise Error("invalid record ID: must be non-negative")
|
|
if id > 999:
|
|
raise Error("record not found")
|
|
return String("record_", id)
|
|
|
|
|
|
def main() raises:
|
|
try:
|
|
for id in [5, 0, 1001, -3, 42]:
|
|
var result: String
|
|
try:
|
|
print()
|
|
print("try => id:", id)
|
|
if id == 0:
|
|
continue
|
|
result = process_record(id)
|
|
except e:
|
|
if "invalid" in String(e):
|
|
print("except => fatal:", e)
|
|
raise e
|
|
print("except => handled:", e)
|
|
else:
|
|
print("else => success:", result)
|
|
finally:
|
|
print("finally => done with id:", id)
|
|
except e:
|
|
print("\nre-raised error:", e)
|