I'm not sure I follow your point from below. 

Let's say we create a selector predicate which checks the thrown object to see if it's a string that ends with a question mark, just for example. My predicate handler would potentially have to accommodate all kinds of stuff thrown by throw+:

1. If I throw a matching string, predicate returns true, exception gets handled by the registered handler.
2. If I throw a non-matching string, predicate returns false, exception gets passed to the next catch clause.
3. If I throw anything that causes the string operations called in my predicate to throw an exception, the exception will get caught within the multi-method and the predicate will return false. At that point the exception gets passed to the next catch clause. 

Case 3 should include attempting to match a Throwable instance, so no errors originating outside of the predicate selector would be suppressed. Essentially, any errors which happen within the predicate will turn that predicate call into a false value for the purposes of _matching the thrown object to a selector_, not handing the thrown object itself.

However, this does mean that predicate exceptions get suppressed, which is a bit concerning. I think I have a solution, though. I realized that I wasn't using try+ here. Consider:

```clojure
(try+
  (selector object)
  (catch Throwable e
    (throw+ {:type ::predicate-selector-exception :predicate-arg object})))
```

The slingshot docs say:

> When throw+ throws a non-Throwable object from within a try+ catch clause, the outermost wrapper of the caught object being processed is captured as the cause of the new throw+.

I take that to mean that the exception caught while calling the predicate would be contained within the hidden `&throw-context` arg as the `:cause` if you catch it in a try+ later. As well, if you include the object passed to the predicate within the new exception, you can see what argument caused the predicate to fail.

At that point, I think all of the bases are covered. People could easily debug the predicate exception, and you'd be able to see what the original exception was in those cases.

I might have some time to look at this after tomorrow to see if it's viable. Let me know what you think.

Cheers!