I've got two programs, edited down from other slightly larger programs for clarity. They use condition-case to handle exceptions. I'm interested in handling a (mine) condition and a (mine too) differently. One of the program *does* distinguish between the two exceptions; one of them doesn't. I can't figure out why.
Variant 1 *doesn't* distinguish: ========== my-conditions-var1.scm ============================================= ;;;; -*- geiser-scheme-implementation: chicken -*- (import format) (import (chicken condition)) (define mine (condition '(mine))) (define mine-two (condition '(mine) '(two))) (define (check thunk) (condition-case (thunk) [ex (exn i/o) (format #t "This is an (exn i/o) condition: ~s~%" ex)] [ex (exn) (format #t "This is an exn condition of some sort: ~s~%" ex)] [ex (mine too) (format #t "This is a (mine too) condition: ~s~%" ex)] [ex (mine) (format #t "This is a (mine) condition: ~s~%" ex)] [ex () (format #t "This is something else: ex: ~s~%" ex)])) (check (lambda () (/ 1 0))) (check (lambda () (signal mine))) (check (lambda () (signal mine-two))) (check (lambda () (signal (condition '(mine) '(two))))) (check (lambda () (signal (condition `(exn msg "bogus message" args "bogus args") '(i/o))))) ========== End of my-conditions-var1.scm ====================================== Here's the output: ========== my-conditions-var1.out ============================================= This is an exn condition of some sort: #<condition: (exn arithmetic)> This is a (mine) condition: #<condition: (mine)> This is a (mine) condition: #<condition: (mine two)> This is a (mine) condition: #<condition: (mine two)> This is an (exn i/o) condition: #<condition: (exn i/o)> ========== End of my-conditions-var1.out ====================================== Notice that it's the (mine) branch of the condition-case that catches both conditions. But it can distinguish between an (exn i/o) condition and other exn conditions. Why not (mine) and (mine two)? Here's variant 2, which *does* distinguish: ========== my-conditions-var2.scm ============================================= (import (format)) (import (chicken condition)) (define mine-too (condition '(mine) '(two))) (define (check a-condition) (condition-case (signal a-condition) [ex (mine two) (format #t "This is mine, too: ~s~%" ex)] [ex (mine) (format #t "This is mine: ~s~%" ex)] [ex (exn i/o) (format #t "This is an i/o exn: ~s~%" ex)] [ex (exn) (format #t "This is some kind of exn: ~s~%" ex)] [ex () (format #t "This is something else: ~s~%" ex)])) (check (condition '(mine))) (check (condition '(mine) '(two))) (check mine-too) (check (condition '(exn msg "bogus message" args "bogus args") '(i/o))) (check (condition '(exn msg "bogus message 2" args "bogus args 2"))) (check 'this-is-not-a-condition-but-is-signaled) ========== End of my-conditions-var2.scm ====================================== Here's its output: ========== my-conditions-var2.out ============================================= This is mine: #<condition: (mine)> This is mine, too: #<condition: (mine two)> This is mine, too: #<condition: (mine two)> This is an i/o exn: #<condition: (exn i/o)> This is some kind of exn: #<condition: (exn)> This is something else: this-is-not-a-condition-but-is-signaled ========== End of my-conditions-var2.out ====================================== I don't see why the first variant doesn't distinguish between (mine) and (mine too) and the second variant does. What am I missing? -- T. Kurt Bond, tkurtb...@gmail.com, tkurtbond.github.io and tkb.tx0.org