Initial commit
Test (in pplus-core) / in-core (push) Failing after 28m44s

This commit is contained in:
alexm committed 2026-11-12 22:23:48 -05:00
commit 568474d52f
1591 files changed
+528213

No files matched your search

+169
View File
@@ -0,0 +1,169 @@
def __exit__(self, error: Error) raises -> Bool
```
Given the `Error` that occurred as an argument, the method can do any of the
following:
- Return `True` to suppress the error.
- Return `False` to re-raise the error.
- Raise a new error.
The following is an example of a context manager that suppresses only a certain
error condition and propagates all others:
```mojo title="conditional_context_mgr.mojo"
import std.time
@fieldwise_init
struct ConditionalTimer(ImplicitlyCopyable):
var start_time: Int
def __init__(out self):
self.start_time = 0
def __enter__(mut self) -> Self:
self.start_time = Int(time.perf_counter_ns())
return self
def __exit__(mut self):
var end_time = time.perf_counter_ns()
var elapsed_time_ms = round(
Float64(end_time - self.start_time) / 1e6, 3
)
print("Elapsed time:", elapsed_time_ms, "milliseconds")
def __exit__(mut self, e: Error) -> Bool:
if String(e) == "just a warning":
print("Suppressing error:", e)
self.__exit__()
return True
else:
print("Propagating error")
self.__exit__()
return False
def flaky_identity(n: Int) raises -> Int:
if (n % 4) == 0:
raise "really bad"
elif (n % 2) == 0:
raise "just a warning"
else:
return n
def main() raises:
for i in range(1, 9):
with ConditionalTimer():
print("\nBeginning execution")
print("i =", i)
time.sleep(0.1)
if i == 3:
print("continue executed")
continue
var j = flaky_identity(i)
print("j =", j)
print("Ending execution")
```
Running this example produces this output:
```output
Beginning execution
i = 1
j = 1
Ending execution
Elapsed time: 105.0 milliseconds
Beginning execution
i = 2
Suppressing error: just a warning
Elapsed time: 106.0 milliseconds
Beginning execution
i = 3
continue executed
Elapsed time: 106.0 milliseconds
Beginning execution
i = 4
Propagating error
Elapsed time: 106.0 milliseconds
Unhandled exception caught during execution: really bad
```
### Handle typed errors in `__exit__()`
The `__exit__(self, error: Error)` overload handles only `Error` values.
To handle typed errors, implement a parameterized `__exit__()` method with a
compile-time error type parameter:
```mojo
def __exit__[ErrType: AnyType](self, err: ErrType) -> Bool
```
This method receives the typed error directly, preserving its full type
information. You can use
[reflection](/docs/manual/metaprogramming/reflection/) to inspect the error
type at compile time. For example, you can:
- `reflect[ErrType].name()` — Get the error type's name as a string.
- `comptime if conforms_to(ErrType, Writable)` — Check if the error
implements `Writable`, and if so, access the error through its `Writable`
interface.
The following `ResourceGuard` example demonstrates this pattern:
```mojo
from std.reflection import *
@fieldwise_init
struct ConnectionError(Copyable, Writable):
var message: String
def write_to(self, mut writer: Some[Writer]):
writer.write("ConnectionError: ", self.message)
struct ResourceGuard(ImplicitlyCopyable):
var name: String
var suppress_errors: Bool
def __init__(out self, name: String, suppress_errors: Bool = False):
self.name = name
self.suppress_errors = suppress_errors
def __enter__(self) -> Self:
print("Acquiring:", self.name)
return self
def __exit__(self):
print("Releasing:", self.name, "(no error)")
def __exit__[ErrType: AnyType](self, err: ErrType) -> Bool:
comptime type_name = reflect[ErrType].name()
print("Releasing:", self.name)
print(" Error type:", type_name)
comptime if conforms_to(ErrType, Writable):
print(" Message:", err)
return self.suppress_errors
```
When no error occurs, `__exit__(self)` runs as usual. When a typed error occurs,
`__exit__[ErrType]()` runs instead, giving you access to the error type and
its data:
```mojo
# No error — calls __exit__(self)
with ResourceGuard("database"):
print("Working...")
# Typed error, suppressed — __exit__[ErrType] returns True
with ResourceGuard("cache", suppress_errors=True):
use_connection() # raises ConnectionError
print("Continued after suppressed error")