# Module Std_kernel.Exn

    module Exn: Exn

    type t = exn

`sexp_of_t` uses a global table of sexp converters. To register a converter for a new exception, add "with sexp" to its definition. If no suitable converter is found, the standard converter in `Printexc` will be used to generate an atomic S-expression.

    include Pretty_printer.S

    exception Finally of t * t

Raised when finalization after an exception failed, too. The first exception argument is the one raised by the initial function, the second exception the one raised by the finalizer.

    exception Reraised of string * t

    val raise_without_backtrace : t -> 'a

Same as `raise`, except that the backtrace is not recorded.

    val reraise : t -> string -> 'a

    val reraisef : t -> ('a, unit, string, unit -> 'b) Pervasives.format4 -> 'a

Types with `format4` are hard to read, so here's an example.

          let foobar str =
            try
              ...
            with exn ->
              Exn.reraisef exn "Foobar is buggy on: %s" str ()

    val to_string : t -> string

    val to_string_mach : t -> string

    val protectx : f:('a -> 'b) -> 'a -> finally:('a -> unit) -> 'b

Executes `f` and afterwards executes `finally`, whether `f` throws an exception or not.

    val protect : f:(unit -> 'a) -> finally:(unit -> unit) -> 'a

    val handle_uncaught : exit:bool -> (unit -> unit) -> unit

`handle_uncaught ~exit f` catches an exception escaping `f` and prints an error message to stderr. Exits with return code 1 if `exit` is `true`. Otherwise returns unit.

    val handle_uncaught_and_exit : (unit -> 'a) -> 'a

`handle_uncaught_and_exit f` returns `f ()`, unless that raises, in which case it prints the exception and exits nonzero.

    val reraise_uncaught : string -> (unit -> 'a) -> 'a

Traces exceptions passing through. Useful because in practice backtraces still don't seem to work.

Example:

        let rogue_function () = if Random.bool () then failwith "foo" else 3
        let traced_function () = Exn.reraise_uncaught "rogue_function" rogue_function
        traced_function ();;

    : Program died with Reraised("rogue_function", Failure "foo")

    val does_raise : (unit -> 'a) -> bool

`does_raise f` returns `true` iff `f ()` raises, which is often useful in unit tests.

    val backtrace : unit -> string

The same as `Printexc.get_backtrace`

    val sexp_of_t : t -> Sexplib.Sexp.t

Raised when finalization after an exception failed, too. The first exception argument is the one raised by the initial function, the second exception the one raised by the finalizer.
Same as `raise`, except that the backtrace is not recorded.
Types with `format4` are hard to read, so here's an example.

          let foobar str =
            try
              ...
            with exn ->
              Exn.reraisef exn "Foobar is buggy on: %s" str ()

Executes `f` and afterwards executes `finally`, whether `f` throws an exception or not.
`handle_uncaught ~exit f` catches an exception escaping `f` and prints an error message to stderr. Exits with return code 1 if `exit` is `true`. Otherwise returns unit.
`handle_uncaught_and_exit f` returns `f ()`, unless that raises, in which case it prints the exception and exits nonzero.
Traces exceptions passing through. Useful because in practice backtraces still don't seem to work.

Example:

        let rogue_function () = if Random.bool () then failwith "foo" else 3
        let traced_function () = Exn.reraise_uncaught "rogue_function" rogue_function
        traced_function ();;

    : Program died with Reraised("rogue_function", Failure "foo")

`does_raise f` returns `true` iff `f ()` raises, which is often useful in unit tests.
The same as `Printexc.get_backtrace`