Re: Exception with multiple irritants

[Zelphir Kaltstahl <zelphirkaltstahl@posteo.de>]

On 11/25/22 01:03, Zelphir Kaltstahl wrote:
> Hello Guile Users!
>
> I have a question regarding exception creation in general and maybe in 
> specific about irritants.
>
> I created a new exception type:
>
> ~~~~
> (library (exceptions)
>   (export make-contract-violated-exception-plain
>           make-exception-contract-violated-compound
>           &contract-violated
>           contract-violated-exception?)
>   (import (except (rnrs base) let-values)
>           (only (guile)
>                 lambda* λ
>                 record-constructor
>                 make-exception-type
>                 &programming-error)
>           (ice-9 exceptions))
>
>   ;; Create a custom exception type, to make it clearer,
>   ;; that a contract failed, and not only an arbitrary
>   ;; assertion.
>   (define &contract-violated
>     (make-exception-type
>      ;; name of the new exception type
>      '&contract-violated
>      ;; parent exception type
>      &programming-error
>      ;; list of values the constructor of the exception
>      ;; takes and their names in the record
>      '()))
>
>   (define make-contract-violated-exception-plain
>     ;; record-constructor is a procedure, which will return
>     ;; the constructor for any record.
>     (record-constructor
>      ;; Create an exception type, which is a record. This
>      ;; record has a constructor, which we can name using
>      ;; define for example.
>      &contract-violated))
>
>   (define contract-violated-exception?
>     (exception-predicate &contract-violated))
>
>   (define make-exception-contract-violated-compound
>     (λ (message origin irritants)
>       (make-exception
>        (make-contract-violated-exception-plain)
>        (make-exception-with-message message)
>        (make-exception-with-origin origin)
>        (make-exception-with-irritants irritants)))))
> ~~~~
>
> However, I realized, when a contract is violated, it would be nice to not only 
> see the violated contract or condition as irritants, but also the values of 
> the irritants. So I simply tried adding them as well in the exception:
>
> ~~~~
> ...
> (define make-exception-contract-violated-compound
>     (λ (message origin irritants irritant-values)
>       (make-exception
>        (make-contract-violated-exception-plain)
>        (make-exception-with-message message)
>        (make-exception-with-origin origin)
>        (make-exception-with-irritants irritants)
>        (make-exception-with-irritants irritant-values))))
> ...
> ~~~~
>
> Note, that now I have 2 times `make-exception-with-irritants` in there. This 
> does not cause an error and `exception-irritants` still returns the first 
> irritants, so my tests also all still pass, as I have not tested for there not 
> to be other exception attributes.
>
> For example a violated exception example could look like this:
>
> ~~~~
> (define-with-contract bla
>   (require (> foo 10))
>   (ensure (> <?> 0))
>   (λ (foo)
>     (- 20 foo)))
>
> (bla 10)
>
> ice-9/boot-9.scm:1685:16: In procedure raise-exception:
> ERROR:
>   1. &contract-violated
>   2. &message: "contract violated"
>   3. &origin: bla
>   4. &irritants: (> foo 10)
>   5. &irritants: (> 10 10)
> ~~~~
>
> Nice! Now I have the value of `foo` in this case as well and that could be 
> useful information in cases, when I get a violated contract unexpectedly.
>
> However, having irritants twice seems a bit weird. Is this something, that is 
> safe to do? Something expected and probably unchanging in future versions of 
> GNU Guile? Or does it merely work by chance?
>
> I could always make another exception type like 
> "exception-with-irritant-values" or something and use that, instead of a 
> second "with irritants" call.
>
> Best regards,
> Zelphir

Hi!

Does anyone know this? Is it OK and reliable to have more than 1 
`exception-with-irritant-values` in a compound exception?

Regards,
Zelphir

-- 
repositories: https://notabug.org/ZelphirKaltstahl